chore(docker): add start_period to postgres and redis healthchecks

.cursor/rules/build-and-deployment.mdc

@@ -0,0 +1,61 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+# Build & Deployment Best Practices
+
+## Build Process
+
+### Running Builds
+- Use `pnpm build` from project root for full build
+- Monitor for React hooks warnings and fix them immediately
+- Ensure all TypeScript errors are resolved before deployment
+
+### Common Build Issues & Fixes
+
+#### React Hooks Warnings
+- Capture ref values in variables within useEffect cleanup
+- Avoid accessing `.current` directly in cleanup functions
+- Pattern for fixing ref cleanup warnings:
+```typescript
+useEffect(() => {
+  const currentRef = myRef.current;
+  return () => {
+    if (currentRef) {
+      currentRef.cleanup();
+    }
+  };
+}, []);
+```
+
+#### Test Failures During Build
+- Ensure all test mocks include required constants like `SESSION_MAX_AGE`
+- Mock Next.js navigation hooks properly: `useParams`, `useRouter`, `useSearchParams`
+- Remove unused imports and constants from test files
+- Use literal values instead of imported constants when the constant isn't actually needed
+
+### Test Execution
+- Run `pnpm test` to execute all tests
+- Use `pnpm test -- --run filename.test.tsx` for specific test files
+- Fix test failures before merging code
+- Ensure 100% test coverage for new components
+
+### Performance Monitoring
+- Monitor build times and optimize if necessary
+- Watch for memory usage during builds
+- Use proper caching strategies for faster rebuilds
+
+### Deployment Checklist
+1. All tests passing
+2. Build completes without warnings
+3. TypeScript compilation successful
+4. No linter errors
+5. Database migrations applied (if any)
+6. Environment variables configured
+
+### EKS Deployment Considerations
+- Ensure latest code is deployed to all pods
+- Monitor AWS RDS Performance Insights for database issues
+- Verify environment-specific configurations
+- Check pod health and resource usage

.cursor/rules/cache-optimization.mdc

@@ -0,0 +1,415 @@
+---
+description: Caching rules for performance improvements
+globs: 
+alwaysApply: false
+---
+# Cache Optimization Patterns for Formbricks
+
+## Cache Strategy Overview
+
+Formbricks uses a **hybrid caching approach** optimized for enterprise scale:
+
+- **Redis** for persistent cross-request caching  
+- **React `cache()`** for request-level deduplication
+- **NO Next.js `unstable_cache()`** - avoid for reliability
+
+## Key Files
+
+### Core Cache Infrastructure
+- [packages/cache/src/service.ts](mdc:packages/cache/src/service.ts) - Redis cache service
+- [packages/cache/src/client.ts](mdc:packages/cache/src/client.ts) - Cache client initialization and singleton management  
+- [apps/web/lib/cache/index.ts](mdc:apps/web/lib/cache/index.ts) - Cache service proxy for web app
+- [packages/cache/src/index.ts](mdc:packages/cache/src/index.ts) - Cache package exports and utilities
+
+### Environment State Caching (Critical Endpoint)
+- [apps/web/app/api/v1/client/[environmentId]/environment/route.ts](mdc:apps/web/app/api/v1/client/[environmentId]/environment/route.ts) - Main endpoint serving hundreds of thousands of SDK clients
+- [apps/web/app/api/v1/client/[environmentId]/environment/lib/data.ts](mdc:apps/web/app/api/v1/client/[environmentId]/environment/lib/data.ts) - Optimized data layer with caching
+
+## Enterprise-Grade Cache Key Patterns
+
+**Always use** the `createCacheKey` utilities from the cache package:
+
+```typescript
+// ✅ Correct patterns
+createCacheKey.environment.state(environmentId)     // "fb:env:abc123:state"
+createCacheKey.organization.billing(organizationId) // "fb:org:xyz789:billing"
+createCacheKey.license.status(organizationId)       // "fb:license:org123:status"
+createCacheKey.user.permissions(userId, orgId)      // "fb:user:456:org:123:permissions"
+
+// ❌ Never use flat keys - collision-prone
+"environment_abc123"
+"user_data_456"
+```
+
+## When to Use Each Cache Type
+
+### Use React `cache()` for Request Deduplication
+```typescript
+// ✅ Prevents multiple calls within same request
+export const getEnterpriseLicense = reactCache(async () => {
+  // Complex license validation logic
+});
+```
+
+### Use `cache.withCache()` for Simple Database Queries
+```typescript
+// ✅ Simple caching with automatic fallback (TTL in milliseconds)
+export const getActionClasses = (environmentId: string) => {
+  return cache.withCache(() => fetchActionClassesFromDB(environmentId), 
+    createCacheKey.environment.actionClasses(environmentId),
+    60 * 30 * 1000 // 30 minutes in milliseconds
+  );
+};
+```
+
+### Use Explicit Redis Cache for Complex Business Logic
+```typescript
+// ✅ Full control for high-stakes endpoints
+export const getEnvironmentState = async (environmentId: string) => {
+  const cached = await environmentStateCache.getEnvironmentState(environmentId);
+  if (cached) return cached;
+  
+  const fresh = await buildComplexState(environmentId);
+  await environmentStateCache.setEnvironmentState(environmentId, fresh);
+  return fresh;
+};
+```
+
+## Caching Decision Framework
+
+### When TO Add Caching
+
+```typescript
+// ✅ Expensive operations that benefit from caching
+- Database queries (>10ms typical)
+- External API calls (>50ms typical)  
+- Complex computations (>5ms)
+- File system operations
+- Heavy data transformations
+
+// Example: Database query with complex joins (TTL in milliseconds)
+export const getEnvironmentWithDetails = withCache(
+  async (environmentId: string) => {
+    return prisma.environment.findUnique({
+      where: { id: environmentId },
+      include: { /* complex joins */ }
+    });
+  },
+  { key: createCacheKey.environment.details(environmentId), ttl: 60 * 30 * 1000 } // 30 minutes
+)();
+```
+
+### When NOT to Add Caching
+
+```typescript
+// ❌ Don't cache these operations - minimal overhead
+- Simple property access (<0.1ms)
+- Basic transformations (<1ms)
+- Functions that just call already-cached functions
+- Pure computation without I/O
+
+// ❌ Bad example: Redundant caching
+const getCachedLicenseFeatures = withCache(
+  async () => {
+    const license = await getEnterpriseLicense(); // Already cached!
+    return license.active ? license.features : null; // Just property access
+  },
+  { key: "license-features", ttl: 1800 * 1000 } // 30 minutes in milliseconds
+);
+
+// ✅ Good example: Simple and efficient
+const getLicenseFeatures = async () => {
+  const license = await getEnterpriseLicense(); // Already cached
+  return license.active ? license.features : null; // 0.1ms overhead
+};
+```
+
+### Computational Overhead Analysis
+
+Before adding caching, analyze the overhead:
+
+```typescript
+// ✅ High overhead - CACHE IT
+- Database queries: ~10-100ms
+- External APIs: ~50-500ms  
+- File I/O: ~5-50ms
+- Complex algorithms: >5ms
+
+// ❌ Low overhead - DON'T CACHE
+- Property access: ~0.001ms
+- Simple lookups: ~0.1ms
+- Basic validation: ~1ms
+- Type checks: ~0.01ms
+
+// Example decision tree:
+const expensiveOperation = async () => {
+  return prisma.query(); // 50ms - CACHE IT
+};
+
+const cheapOperation = (data: any) => {
+  return data.property; // 0.001ms - DON'T CACHE
+};
+```
+
+### Avoid Cache Wrapper Anti-Pattern
+
+```typescript
+// ❌ Don't create wrapper functions just for caching
+const getCachedUserPermissions = withCache(
+  async (userId: string) => getUserPermissions(userId),
+  { key: createCacheKey.user.permissions(userId), ttl: 3600 * 1000 } // 1 hour in milliseconds
+);
+
+// ✅ Add caching directly to the original function
+export const getUserPermissions = withCache(
+  async (userId: string) => {
+    return prisma.user.findUnique({
+      where: { id: userId },
+      include: { permissions: true }
+    });
+  },
+  { key: createCacheKey.user.permissions(userId), ttl: 3600 * 1000 } // 1 hour in milliseconds
+);
+```
+
+## TTL Coordination Strategy
+
+### Multi-Layer Cache Coordination
+For endpoints serving client SDKs, coordinate TTLs across layers:
+
+```typescript
+// Client SDK cache (expiresAt) - longest TTL for fewer requests
+const CLIENT_TTL = 60;           // 1 minute (seconds for client)
+
+// Server Redis cache - shorter TTL ensures fresh data for clients  
+const SERVER_TTL = 60 * 1000;   // 1 minutes in milliseconds
+
+// HTTP cache headers (seconds)
+const BROWSER_TTL = 60;         // 1 minute (max-age)
+const CDN_TTL = 60;             // 1 minute (s-maxage)
+const CORS_TTL = 60 * 60;            // 1 hour (balanced approach)
+```
+
+### Standard TTL Guidelines (in milliseconds for cache-manager + Keyv)
+```typescript
+// Configuration data - rarely changes
+const CONFIG_TTL = 60 * 60 * 24 * 1000;     // 24 hours
+
+// User data - moderate frequency  
+const USER_TTL = 60 * 60 * 2 * 1000;        // 2 hours
+
+// Survey data - changes moderately
+const SURVEY_TTL = 60 * 15 * 1000;          // 15 minutes
+
+// Billing data - expensive to compute
+const BILLING_TTL = 60 * 30 * 1000;         // 30 minutes
+
+// Action classes - infrequent changes
+const ACTION_CLASS_TTL = 60 * 30 * 1000;    // 30 minutes
+```
+
+## High-Frequency Endpoint Optimization
+
+### Performance Patterns for High-Volume Endpoints
+
+```typescript
+// ✅ Optimized high-frequency endpoint pattern
+export const GET = async (request: NextRequest, props: { params: Promise<{ id: string }> }) => {
+  const params = await props.params;
+
+  try {
+    // Simple validation (avoid Zod for high-frequency)
+    if (!params.id || typeof params.id !== 'string') {
+      return responses.badRequestResponse("ID is required", undefined, true);
+    }
+
+    // Single optimized query with caching
+    const data = await getOptimizedData(params.id);
+
+    return responses.successResponse(
+      {
+        data,
+        expiresAt: new Date(Date.now() + CLIENT_TTL * 1000), // SDK cache duration
+      },
+      true,
+      "public, s-maxage=1800, max-age=3600, stale-while-revalidate=1800, stale-if-error=3600"
+    );
+  } catch (err) {
+    // Simplified error handling for performance
+    if (err instanceof ResourceNotFoundError) {
+      return responses.notFoundResponse(err.resourceType, err.resourceId);
+    }
+    logger.error({ error: err, url: request.url }, "Error in high-frequency endpoint");
+    return responses.internalServerErrorResponse(err.message, true);
+  }
+};
+```
+
+### Avoid These Performance Anti-Patterns
+
+```typescript
+// ❌ Avoid for high-frequency endpoints
+const inputValidation = ZodSchema.safeParse(input);     // Too slow
+const startTime = Date.now(); logger.debug(...);       // Logging overhead
+const { data, revalidateEnvironment } = await get();   // Complex return types
+```
+
+### CORS Optimization
+```typescript
+// ✅ Balanced CORS caching (not too aggressive)
+export const OPTIONS = async (): Promise<Response> => {
+  return responses.successResponse(
+    {},
+    true,
+    "public, s-maxage=3600, max-age=3600" // 1 hour balanced approach
+  );
+};
+```
+
+## Redis Cache Migration from Next.js
+
+### Avoid Legacy Next.js Patterns
+```typescript
+// ❌ Old Next.js unstable_cache pattern (avoid)
+const getCachedData = unstable_cache(
+  async (id) => fetchData(id),
+  ['cache-key'],
+  { tags: ['environment'], revalidate: 900 }
+);
+
+// ❌ Don't use revalidateEnvironment flags with Redis
+return { data, revalidateEnvironment: true }; // This gets cached incorrectly!
+
+// ✅ New Redis pattern with withCache (TTL in milliseconds)
+export const getCachedData = (id: string) => 
+  withCache(
+    () => fetchData(id),
+    {
+      key: createCacheKey.environment.data(id),
+      ttl: 60 * 15 * 1000, // 15 minutes in milliseconds
+    }
+  )();
+```
+
+### Remove Revalidation Logic
+When migrating from Next.js `unstable_cache`:
+- Remove `revalidateEnvironment` or similar flags
+- Remove tag-based invalidation logic  
+- Use TTL-based expiration instead
+- Handle one-time updates (like `appSetupCompleted`) directly in cache
+
+## Data Layer Optimization
+
+### Single Query Pattern
+```typescript
+// ✅ Optimize with single database query
+export const getOptimizedEnvironmentData = async (environmentId: string) => {
+  return prisma.environment.findUniqueOrThrow({
+    where: { id: environmentId },
+    include: {
+      project: { 
+        select: { id: true, recontactDays: true, /* ... */ }
+      },
+      organization: {
+        select: { id: true, billing: true }
+      },
+      surveys: {
+        where: { status: "inProgress" },
+        select: { id: true, name: true, /* ... */ }
+      },
+      actionClasses: {
+        select: { id: true, name: true, /* ... */ }
+      }
+    }
+  });
+};
+
+// ❌ Avoid multiple separate queries
+const environment = await getEnvironment(id);
+const organization = await getOrganization(environment.organizationId);  
+const surveys = await getSurveys(id);
+const actionClasses = await getActionClasses(id);
+```
+
+## Invalidation Best Practices
+
+**Always use explicit key-based invalidation:**
+
+```typescript
+// ✅ Clear and debuggable
+await invalidateCache(createCacheKey.environment.state(environmentId));
+await invalidateCache([
+  createCacheKey.environment.surveys(environmentId),
+  createCacheKey.environment.actionClasses(environmentId)
+]);
+
+// ❌ Avoid complex tag systems
+await invalidateByTags(["environment", "survey"]); // Don't do this
+```
+
+## Critical Performance Targets
+
+### High-Frequency Endpoint Goals
+- **Cache hit ratio**: >85%
+- **Response time P95**: <200ms  
+- **Database load reduction**: >60%
+- **HTTP cache duration**: 1hr browser, 30min Cloudflare
+- **SDK refresh interval**: 1 hour with 30min server cache
+
+### Performance Monitoring
+- Use **existing elastic cache analytics** for metrics
+- Log cache errors and warnings (not debug info)
+- Track database query reduction
+- Monitor response times for cached endpoints
+- **Avoid performance logging** in high-frequency endpoints
+
+## Error Handling Pattern
+
+Always provide fallback to fresh data on cache errors:
+
+```typescript
+try {
+  const cached = await cache.get(key);
+  if (cached) return cached;
+  
+  const fresh = await fetchFresh();
+  await cache.set(key, fresh, ttl); // ttl in milliseconds
+  return fresh;
+} catch (error) {
+  // ✅ Always fallback to fresh data
+  logger.warn("Cache error, fetching fresh", { key, error });
+  return fetchFresh();
+}
+```
+
+## Common Pitfalls to Avoid
+
+1. **Never use Next.js `unstable_cache()`** - unreliable in production
+2. **Don't use revalidation flags with Redis** - they get cached incorrectly
+3. **Avoid Zod validation** for simple parameters in high-frequency endpoints
+4. **Don't add performance logging** to high-frequency endpoints
+5. **Coordinate TTLs** between client and server caches
+6. **Don't over-engineer** with complex tag systems  
+7. **Avoid caching rapidly changing data** (real-time metrics)
+8. **Always validate cache keys** to prevent collisions
+9. **Don't add redundant caching layers** - analyze computational overhead first
+10. **Avoid cache wrapper functions** - add caching directly to expensive operations
+11. **Don't cache property access or simple transformations** - overhead is negligible
+12. **Analyze the full call chain** before adding caching to avoid double-caching
+13. **Remember TTL is in milliseconds** for cache-manager + Keyv stack (not seconds)
+
+## Monitoring Strategy
+
+- Use **existing elastic cache analytics** for metrics
+- Log cache errors and warnings  
+- Track database query reduction
+- Monitor response times for cached endpoints
+- **Don't add custom metrics** that duplicate existing monitoring
+
+## Important Notes
+
+### TTL Units
+- **cache-manager + Keyv**: TTL in **milliseconds**
+- **Direct Redis commands**: TTL in **seconds** (EXPIRE, SETEX) or **milliseconds** (PEXPIRE, PSETEX)
+- **HTTP cache headers**: TTL in **seconds** (max-age, s-maxage)
+- **Client SDK**: TTL in **seconds** (expiresAt calculation)

.cursor/rules/database-performance.mdc

@@ -0,0 +1,41 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+# Database Performance & Prisma Best Practices
+
+## Critical Performance Rules
+
+### Response Count Queries
+- **NEVER** use `skip`/`offset` with `prisma.response.count()` - this causes expensive subqueries with OFFSET
+- Always use only `where` clauses for count operations: `prisma.response.count({ where: { ... } })`
+- For pagination, separate count queries from data queries
+- Reference: [apps/web/lib/response/service.ts](mdc:apps/web/lib/response/service.ts) line 654-686
+
+### Prisma Query Optimization
+- Use proper indexes defined in [packages/database/schema.prisma](mdc:packages/database/schema.prisma)
+- Leverage existing indexes: `@@index([surveyId, createdAt])`, `@@index([createdAt])`
+- Use cursor-based pagination for large datasets instead of offset-based
+- Cache frequently accessed data using React Cache and custom cache tags
+
+### Date Range Filtering
+- When filtering by `createdAt`, always use indexed queries
+- Combine with `surveyId` for optimal performance: `{ surveyId, createdAt: { gte: start, lt: end } }`
+- Avoid complex WHERE clauses that can't utilize indexes
+
+### Count vs Data Separation
+- Always separate count queries from data fetching queries
+- Use `Promise.all()` to run count and data queries in parallel
+- Example pattern from [apps/web/modules/api/v2/management/responses/lib/response.ts](mdc:apps/web/modules/api/v2/management/responses/lib/response.ts):
+```typescript
+const [responses, totalCount] = await Promise.all([
+  prisma.response.findMany(query),
+  prisma.response.count({ where: whereClause }),
+]);
+```
+
+### Monitoring & Debugging
+- Monitor AWS RDS Performance Insights for problematic queries
+- Look for queries with OFFSET in count operations - these indicate performance issues
+- Use proper error handling with `DatabaseError` for Prisma exceptions

.cursor/rules/database.mdc

@@ -0,0 +1,105 @@
+---
+description: >
+globs: schema.prisma
+alwaysApply: false
+---
+# Formbricks Database Schema Reference
+
+This rule provides a reference to the Formbricks database structure. For the most up-to-date and complete schema definitions, please refer to the schema.prisma file directly.
+
+## Database Overview
+
+Formbricks uses PostgreSQL with Prisma ORM. The schema is designed for multi-tenancy with strong data isolation between organizations.
+
+### Core Hierarchy
+
+```
+Organization
+└── Project
+    └── Environment (production/development)
+        ├── Survey
+        ├── Contact
+        ├── ActionClass
+        └── Integration
+```
+
+## Schema Reference
+
+For the complete and up-to-date database schema, please refer to:
+
+- Main schema: `packages/database/schema.prisma`
+- JSON type definitions: `packages/database/json-types.ts`
+
+The schema.prisma file contains all model definitions, relationships, enums, and field types. The json-types.ts file contains TypeScript type definitions for JSON fields.
+
+## Data Access Patterns
+
+### Multi-tenancy
+
+- All data is scoped by Organization
+- Environment-level isolation for surveys and contacts
+- Project-level grouping for related surveys
+
+### Soft Deletion
+
+Some models use soft deletion patterns:
+
+- Check `isActive` fields where present
+- Use proper filtering in queries
+
+### Cascading Deletes
+
+Configured cascade relationships:
+
+- Organization deletion cascades to all child entities
+- Survey deletion removes responses, displays, triggers
+- Contact deletion removes attributes and responses
+
+## Common Query Patterns
+
+### Survey with Responses
+
+```typescript
+// Include response count and latest responses
+const survey = await prisma.survey.findUnique({
+  where: { id: surveyId },
+  include: {
+    responses: {
+      take: 10,
+      orderBy: { createdAt: "desc" },
+    },
+    _count: {
+      select: { responses: true },
+    },
+  },
+});
+```
+
+### Environment Scoping
+
+```typescript
+// Always scope by environment
+const surveys = await prisma.survey.findMany({
+  where: {
+    environmentId: environmentId,
+    // Additional filters...
+  },
+});
+```
+
+### Contact with Attributes
+
+```typescript
+const contact = await prisma.contact.findUnique({
+  where: { id: contactId },
+  include: {
+    attributes: {
+      include: {
+        attributeKey: true,
+      },
+    },
+  },
+});
+```
+
+This schema supports Formbricks' core functionality: multi-tenant survey management, user targeting, response collection, and analysis, all while maintaining strict data isolation and security.

.cursor/rules/documentations.mdc

@@ -0,0 +1,28 @@
+---
+description: Guideline for writing end-user facing documentation in the apps/docs folder
+globs:
+alwaysApply: false
+---
+
+Follow these instructions and guidelines when asked to write documentation in the apps/docs folder
+
+Follow this structure to write the title, describtion and pick a matching icon and insert it at the top of the MDX file:
+
+---
+
+title: "FEATURE NAME"
+description: "1 concise sentence to describe WHEN the feature is being used and FOR WHAT BENEFIT."
+icon: "link"
+
+---
+
+- Description: 1 concise sentence to describe WHEN the feature is being used and FOR WHAT BENEFIT.
+- Make ample use of the Mintlify components you can find here https://mintlify.com/docs/llms.txt - e.g. if docs describe consecutive steps, always use Mintlify Step component.
+- In all Headlines, only capitalize the current feature and nothing else, to Camel Case.
+- The page should never start with H1 headline, because it's already part of the template.
+- Tonality: Keep it concise and to the point. Avoid Jargon where possible.
+- If a feature is part of the Enterprise Edition, use this note:
+
+<Note>
+  FEATURE NAME is part of the [Enterprise Edition](/self-hosting/advanced/license) 
+</Note>

.cursor/rules/formbricks-architecture.mdc

@@ -0,0 +1,332 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+# Formbricks Architecture & Patterns
+
+## Monorepo Structure
+
+### Apps Directory
+- `apps/web/` - Main Next.js web application
+- `packages/` - Shared packages and utilities
+
+### Key Directories in Web App
+```
+apps/web/
+├── app/                    # Next.js 13+ app directory
+│   ├── (app)/             # Main application routes
+│   ├── (auth)/            # Authentication routes
+│   ├── api/               # API routes
+├── components/            # Shared components
+├── lib/                   # Utility functions and services
+└── modules/               # Feature-specific modules
+```
+
+## Routing Patterns
+
+### App Router Structure
+The application uses Next.js 13+ app router with route groups:
+
+```
+(app)/environments/[environmentId]/
+├── surveys/[surveyId]/
+│   ├── (analysis)/        # Analysis views
+│   │   ├── responses/     # Response management
+│   │   ├── summary/       # Survey summary
+│   │   └── hooks/         # Analysis-specific hooks
+│   ├── edit/              # Survey editing
+│   └── settings/          # Survey settings
+```
+
+### Dynamic Routes
+- `[environmentId]` - Environment-specific routes
+- `[surveyId]` - Survey-specific routes
+
+## Service Layer Pattern
+
+### Service Organization
+Services are organized by domain in `apps/web/lib/`:
+
+```typescript
+// Example: Response service
+// apps/web/lib/response/service.ts
+export const getResponseCountAction = async ({
+  surveyId,
+  filterCriteria,
+}: {
+  surveyId: string;
+  filterCriteria: any;
+}) => {
+  // Service implementation
+};
+```
+
+### Action Pattern
+Server actions follow a consistent pattern:
+
+```typescript
+// Action wrapper for service calls
+export const getResponseCountAction = async (params) => {
+  try {
+    const result = await responseService.getCount(params);
+    return { data: result };
+  } catch (error) {
+    return { error: error.message };
+  }
+};
+```
+
+## Context Patterns
+
+### Provider Structure
+Context providers follow a consistent pattern:
+
+```typescript
+// Provider component
+export const ResponseFilterProvider = ({ children }: { children: React.ReactNode }) => {
+  const [selectedFilter, setSelectedFilter] = useState(defaultFilter);
+  
+  const value = {
+    selectedFilter,
+    setSelectedFilter,
+    // ... other state and methods
+  };
+
+  return (
+    <ResponseFilterContext.Provider value={value}>
+      {children}
+    </ResponseFilterContext.Provider>
+  );
+};
+
+// Hook for consuming context
+export const useResponseFilter = () => {
+  const context = useContext(ResponseFilterContext);
+  if (!context) {
+    throw new Error('useResponseFilter must be used within ResponseFilterProvider');
+  }
+  return context;
+};
+```
+
+### Context Composition
+Multiple contexts are often composed together:
+
+```typescript
+// Layout component with multiple providers
+export default function AnalysisLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <ResponseFilterProvider>
+      <ResponseCountProvider>
+        {children}
+      </ResponseCountProvider>
+    </ResponseFilterProvider>
+  );
+}
+```
+
+## Component Patterns
+
+### Page Components
+Page components are located in the app directory and follow this pattern:
+
+```typescript
+// apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/responses/page.tsx
+export default function ResponsesPage() {
+  return (
+    <div>
+      <ResponsesTable />
+      <ResponsesPagination />
+    </div>
+  );
+}
+```
+
+### Component Organization
+- **Pages** - Route components in app directory
+- **Components** - Reusable UI components
+- **Modules** - Feature-specific components and logic
+
+### Shared Components
+Common components are in `apps/web/components/`:
+- UI components (buttons, inputs, modals)
+- Layout components (headers, sidebars)
+- Data display components (tables, charts)
+
+## Hook Patterns
+
+### Custom Hook Structure
+Custom hooks follow consistent patterns:
+
+```typescript
+export const useResponseCount = ({ 
+  survey, 
+  initialCount 
+}: {
+  survey: TSurvey;
+  initialCount?: number;
+}) => {
+  const [responseCount, setResponseCount] = useState(initialCount ?? 0);
+  const [isLoading, setIsLoading] = useState(false);
+  
+  // Hook logic...
+  
+  return {
+    responseCount,
+    isLoading,
+    refetch,
+  };
+};
+```
+
+### Hook Dependencies
+- Use context hooks for shared state
+- Implement proper cleanup with AbortController
+- Optimize dependency arrays to prevent unnecessary re-renders
+
+## Data Fetching Patterns
+
+### Server Actions
+The app uses Next.js server actions for data fetching:
+
+```typescript
+// Server action
+export async function getResponsesAction(params: GetResponsesParams) {
+  const responses = await getResponses(params);
+  return { data: responses };
+}
+
+// Client usage
+const { data } = await getResponsesAction(params);
+```
+
+### Error Handling
+Consistent error handling across the application:
+
+```typescript
+try {
+  const result = await apiCall();
+  return { data: result };
+} catch (error) {
+  console.error("Operation failed:", error);
+  return { error: error.message };
+}
+```
+
+## Type Safety
+
+### Type Organization
+Types are organized in packages:
+- `@formbricks/types` - Shared type definitions
+- Local types in component/hook files
+
+### Common Types
+```typescript
+import { TSurvey } from "@formbricks/types/surveys/types";
+import { TResponse } from "@formbricks/types/responses";
+import { TEnvironment } from "@formbricks/types/environment";
+```
+
+## State Management
+
+### Local State
+- Use `useState` for component-specific state
+- Use `useReducer` for complex state logic
+- Use refs for mutable values that don't trigger re-renders
+
+### Global State
+- React Context for feature-specific shared state
+- URL state for filters and pagination
+- Server state through server actions
+
+## Performance Considerations
+
+### Code Splitting
+- Dynamic imports for heavy components
+- Route-based code splitting with app router
+- Lazy loading for non-critical features
+
+### Caching Strategy
+- Server-side caching for database queries
+- Client-side caching with React Query (where applicable)
+- Static generation for public pages
+
+## Testing Strategy
+
+### Test Organization
+```
+component/
+├── Component.tsx
+├── Component.test.tsx
+└── hooks/
+    ├── useHook.ts
+    └── useHook.test.tsx
+```
+
+### Test Patterns
+- Unit tests for utilities and services
+- Integration tests for components with context
+- Hook tests with proper mocking
+
+## Build & Deployment
+
+### Build Process
+- TypeScript compilation
+- Next.js build optimization
+- Asset optimization and bundling
+
+### Environment Configuration
+- Environment-specific configurations
+- Feature flags for gradual rollouts
+- Database connection management
+
+## Security Patterns
+
+### Authentication
+- Session-based authentication
+- Environment-based access control
+- API route protection
+
+### Data Validation
+- Input validation on both client and server
+- Type-safe API contracts
+- Sanitization of user inputs
+
+## Monitoring & Observability
+
+### Error Tracking
+- Client-side error boundaries
+- Server-side error logging
+- Performance monitoring
+
+### Analytics
+- User interaction tracking
+- Performance metrics
+- Database query monitoring
+
+## Best Practices Summary
+
+### Code Organization
+- ✅ Follow the established directory structure
+- ✅ Use consistent naming conventions
+- ✅ Separate concerns (UI, logic, data)
+- ✅ Keep components focused and small
+
+### Performance
+- ✅ Implement proper loading states
+- ✅ Use AbortController for async operations
+- ✅ Optimize database queries
+- ✅ Implement proper caching strategies
+
+### Type Safety
+- ✅ Use TypeScript throughout
+- ✅ Define proper interfaces for props
+- ✅ Use type guards for runtime validation
+- ✅ Leverage shared type packages
+
+### Testing
+- ✅ Write tests for critical functionality
+- ✅ Mock external dependencies properly
+- ✅ Test error scenarios and edge cases
+- ✅ Maintain good test coverage

.cursor/rules/github-actions-security.mdc

@@ -0,0 +1,232 @@
+---
+description: Security best practices and guidelines for writing GitHub Actions and workflows
+globs: .github/workflows/*.yml,.github/workflows/*.yaml,.github/actions/*/action.yml,.github/actions/*/action.yaml
+---
+
+# GitHub Actions Security Best Practices
+
+## Required Security Measures
+
+### 1. Set Minimum GITHUB_TOKEN Permissions
+
+Always explicitly set the minimum required permissions for GITHUB_TOKEN:
+
+```yaml
+permissions:
+  contents: read
+  # Only add additional permissions if absolutely necessary:
+  # pull-requests: write  # for commenting on PRs
+  # issues: write         # for creating/updating issues
+  # checks: write         # for publishing check results
+```
+
+### 2. Add Harden-Runner as First Step
+
+For **every job** on `ubuntu-latest`, add Harden-Runner as the first step:
+
+```yaml
+- name: Harden the runner
+  uses: step-security/harden-runner@ec9f2d5744a09debf3a187a3f4f675c53b671911 # v2.13.0
+  with:
+    egress-policy: audit # or 'block' for stricter security
+```
+
+### 3. Pin Actions to Full Commit SHA
+
+**Always** pin third-party actions to their full commit SHA, not tags:
+
+```yaml
+# ❌ BAD - uses mutable tag
+- uses: actions/checkout@v4
+
+# ✅ GOOD - pinned to immutable commit SHA
+- uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+```
+
+### 4. Secure Variable Handling
+
+Prevent command injection by properly quoting variables:
+
+```yaml
+# ❌ BAD - potential command injection
+run: echo "Processing ${{ inputs.user_input }}"
+
+# ✅ GOOD - properly quoted
+env:
+  USER_INPUT: ${{ inputs.user_input }}
+run: echo "Processing ${USER_INPUT}"
+```
+
+Use `${VARIABLE}` syntax in shell scripts instead of `$VARIABLE`.
+
+### 5. Environment Variables for Secrets
+
+Store sensitive data in environment variables, not inline:
+
+```yaml
+# ❌ BAD
+run: curl -H "Authorization: Bearer ${{ secrets.TOKEN }}" api.example.com
+
+# ✅ GOOD
+env:
+  API_TOKEN: ${{ secrets.TOKEN }}
+run: curl -H "Authorization: Bearer ${API_TOKEN}" api.example.com
+```
+
+## Workflow Structure Best Practices
+
+### Required Workflow Elements
+
+```yaml
+name: "Descriptive Workflow Name"
+
+on:
+  # Define specific triggers
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+# Always set explicit permissions
+permissions:
+  contents: read
+
+jobs:
+  job-name:
+    name: "Descriptive Job Name"
+    runs-on: ubuntu-latest
+    timeout-minutes: 30 # tune per job; standardize repo-wide
+
+    # Set job-level permissions if different from workflow level
+    permissions:
+      contents: read
+
+    steps:
+      # Always start with Harden-Runner on ubuntu-latest
+      - name: Harden the runner
+        uses: step-security/harden-runner@v2
+        with:
+          egress-policy: audit
+
+      # Pin all actions to commit SHA
+      - name: Checkout code
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+```
+
+### Input Validation for Actions
+
+For composite actions, always validate inputs:
+
+```yaml
+inputs:
+  user_input:
+    description: "User provided input"
+    required: true
+
+runs:
+  using: "composite"
+  steps:
+    - name: Validate input
+      shell: bash
+      run: |
+        # Harden shell and validate input format/content before use
+        set -euo pipefail
+
+        USER_INPUT="${{ inputs.user_input }}"
+
+        if [[ ! "${USER_INPUT}" =~ ^[A-Za-z0-9._-]+$ ]]; then
+          echo "❌ Invalid input format"
+          exit 1
+        fi
+```
+
+## Docker Security in Actions
+
+### Pin Docker Images to Digests
+
+```yaml
+# ❌ BAD - mutable tag
+container: node:18
+
+# ✅ GOOD - pinned to digest
+container: node:18@sha256:a1ba21bf0c92931d02a8416f0a54daad66cb36a85d6a37b82dfe1604c4c09cad
+```
+
+## Common Patterns
+
+### Secure File Operations
+
+```yaml
+- name: Process files securely
+  shell: bash
+  env:
+    FILE_PATH: ${{ inputs.file_path }}
+  run: |
+    set -euo pipefail  # Fail on errors, undefined vars, pipe failures
+
+    # Use absolute paths and validate
+    SAFE_PATH=$(realpath "${FILE_PATH}")
+    if [[ "$SAFE_PATH" != "${GITHUB_WORKSPACE}"/* ]]; then
+      echo "❌ Path outside workspace"
+      exit 1
+    fi
+```
+
+### Artifact Handling
+
+```yaml
+- name: Upload artifacts securely
+  uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874 # v4.4.0
+  with:
+    name: build-artifacts
+    path: |
+      dist/
+      !dist/**/*.log  # Exclude sensitive files
+    retention-days: 30
+```
+
+### GHCR authentication for pulls/scans
+
+```yaml
+# Minimal permissions required for GHCR pulls/scans
+permissions:
+  contents: read
+  packages: read
+
+steps:
+  - name: Log in to GitHub Container Registry
+    uses: docker/login-action@184bdaa0721073962dff0199f1fb9940f07167d1 # v3.5.0
+    with:
+      registry: ghcr.io
+      username: ${{ github.actor }}
+      password: ${{ secrets.GITHUB_TOKEN }}
+```
+
+## Security Checklist
+
+- [ ] Minimum GITHUB_TOKEN permissions set
+- [ ] Harden-Runner added to all ubuntu-latest jobs
+- [ ] All third-party actions pinned to commit SHA
+- [ ] Input validation implemented for custom actions
+- [ ] Variables properly quoted in shell scripts
+- [ ] Secrets stored in environment variables
+- [ ] Docker images pinned to digests (if used)
+- [ ] Error handling with `set -euo pipefail`
+- [ ] File paths validated and sanitized
+- [ ] No sensitive data in logs or outputs
+- [ ] GHCR login performed before pulls/scans (packages: read)
+- [ ] Job timeouts configured (`timeout-minutes`)
+
+## Recommended Additional Workflows
+
+Consider adding these security-focused workflows to your repository:
+
+1. **CodeQL Analysis** - Static Application Security Testing (SAST)
+2. **Dependency Review** - Scan for vulnerable dependencies in PRs
+3. **Dependabot Configuration** - Automated dependency updates
+
+## Resources
+
+- [GitHub Security Hardening Guide](https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions)
+- [Step Security Harden-Runner](https://github.com/step-security/harden-runner)
+- [Secure-Repo Best Practices](https://github.com/step-security/secure-repo)

.cursor/rules/i18n-management.mdc

@@ -0,0 +1,457 @@
+---
+title: i18n Management with Lingo.dev
+description: Guidelines for managing internationalization (i18n) with Lingo.dev, including translation workflow, key validation, and best practices
+---
+
+# i18n Management with Lingo.dev
+
+This rule defines the workflow and best practices for managing internationalization (i18n) in the Formbricks project using Lingo.dev.
+
+## Overview
+
+Formbricks uses [Lingo.dev](https://lingo.dev) for managing translations across multiple languages. The translation workflow includes:
+
+1. **Translation Keys**: Defined in code using the `t()` function from `react-i18next`
+2. **Translation Files**: JSON files stored in `apps/web/locales/` for each supported language
+3. **Validation**: Automated scanning to detect missing and unused translation keys
+4. **CI/CD**: Pre-commit hooks and GitHub Actions to enforce translation quality
+
+## Translation Workflow
+
+### 1. Using Translations in Code
+
+When adding translatable text in the web app, use the `t()` function or `<Trans>` component:
+
+**Using the `t()` function:**
+```tsx
+import { useTranslate } from "@/lib/i18n/translate";
+
+const MyComponent = () => {
+  const { t } = useTranslate();
+  
+  return (
+    <div>
+      <h1>{t("common.welcome")}</h1>
+      <p>{t("pages.dashboard.description")}</p>
+    </div>
+  );
+};
+```
+
+**Using the `<Trans>` component (for text with HTML elements):**
+```tsx
+import { Trans } from "react-i18next";
+
+const MyComponent = () => {
+  return (
+    <div>
+      <p>
+        <Trans
+          i18nKey="auth.terms_agreement"
+          components={{ 
+            link: <a href="/terms" />,
+            b: <b />
+          }}
+        />
+      </p>
+    </div>
+  );
+};
+```
+
+**Key Naming Conventions:**
+- Use dot notation for nested keys: `section.subsection.key`
+- Use descriptive names: `auth.login.success_message` not `auth.msg1`
+- Group related keys together: `auth.*`, `errors.*`, `common.*`
+- Use lowercase with underscores: `user_profile_settings` not `UserProfileSettings`
+
+### 2. Translation File Structure
+
+Translation files are located in `apps/web/locales/` and use the following naming convention:
+- `en-US.json` (English - United States, default)
+- `de-DE.json` (German)
+- `fr-FR.json` (French)
+- `pt-BR.json` (Portuguese - Brazil)
+- etc.
+
+**File Structure:**
+```json
+{
+  "common": {
+    "welcome": "Welcome",
+    "save": "Save",
+    "cancel": "Cancel"
+  },
+  "auth": {
+    "login": {
+      "title": "Login",
+      "email_placeholder": "Enter your email",
+      "password_placeholder": "Enter your password"
+    }
+  }
+}
+```
+
+### 3. Adding New Translation Keys
+
+When adding new translation keys:
+
+1. **Add the key in your code** using `t("your.new.key")`
+2. **Add translation for that key in en-US.json file**
+3. **Run the translation workflow:**
+   ```bash
+   pnpm i18n
+   ```
+   This will:
+   - Generate translations for all languages using Lingo.dev
+   - Validate that all keys are present and used
+
+4. **Review and commit** the generated translation files
+
+### 4. Available Scripts
+
+```bash
+# Generate translations using Lingo.dev
+pnpm generate-translations
+
+# Scan and validate translation keys
+pnpm scan-translations
+
+# Full workflow: generate + validate
+pnpm i18n
+
+# Validate only (without generation)
+pnpm i18n:validate
+```
+
+## Translation Key Validation
+
+### Automated Validation
+
+The project includes automated validation that runs:
+- **Pre-commit hook**: Validates translations before allowing commits (when `LINGODOTDEV_API_KEY` is set)
+- **GitHub Actions**: Validates translations on every PR and push to main
+
+### Validation Rules
+
+The validation script (`scan-translations.ts`) checks for:
+
+1. **Missing Keys**: Translation keys used in code but not present in translation files
+2. **Unused Keys**: Translation keys present in translation files but not used in code
+3. **Incomplete Translations**: Keys that exist in the default language (`en-US`) but are missing in target languages
+
+**What gets scanned:**
+- All `.ts` and `.tsx` files in `apps/web/`
+- Both `t()` function calls and `<Trans i18nKey="">` components
+- All locale files (`de-DE.json`, `fr-FR.json`, `ja-JP.json`, etc.)
+
+**What gets excluded:**
+- Test files (`*.test.ts`, `*.test.tsx`, `*.spec.ts`, `*.spec.tsx`)
+- Build directories (`node_modules`, `dist`, `build`, `.next`, `coverage`)
+- Locale files themselves (from code scanning)
+
+**Note:** Test files are excluded because they often use mock or example translation keys for testing purposes that don't need to exist in production translation files.
+
+### Fixing Validation Errors
+
+#### Missing Keys
+
+If you encounter missing key errors:
+
+```
+❌ MISSING KEYS (2):
+
+   These keys are used in code but not found in translation files:
+
+   • auth.signup.email_required
+   • settings.profile.update_success
+```
+
+**Resolution:**
+1. Ensure that translations for those keys are present in en-US.json .  
+2. Run `pnpm generate-translations` to have Lingo.dev generate the missing translations
+3. OR manually add the keys to `apps/web/locales/en-US.json`:
+   ```json
+   {
+     "auth": {
+       "signup": {
+         "email_required": "Email is required"
+       }
+     },
+     "settings": {
+       "profile": {
+         "update_success": "Profile updated successfully"
+       }
+     }
+   }
+   ```
+3. Run `pnpm scan-translations` to verify
+4. Commit the changes
+
+#### Unused Keys
+
+If you encounter unused key errors:
+
+```
+⚠️  UNUSED KEYS (1):
+
+   These keys exist in translation files but are not used in code:
+
+   • old.deprecated.key
+```
+
+**Resolution:**
+1. If the key is truly unused, remove it from all translation files
+2. If the key should be used, add it to your code using `t("old.deprecated.key")`
+3. Run `pnpm scan-translations` to verify
+4. Commit the changes
+
+#### Incomplete Translations
+
+If you encounter incomplete translation errors:
+
+```
+⚠️  INCOMPLETE TRANSLATIONS:
+
+   Some keys from en-US are missing in target languages:
+
+   📝 de-DE (5 missing keys):
+      • auth.new_feature.title
+      • auth.new_feature.description
+      • settings.advanced.option
+      ... and 2 more
+```
+
+**Resolution:**
+1. **Recommended:** Run `pnpm generate-translations` to have Lingo.dev automatically translate the missing keys
+2. **Manual:** Add the missing keys to the target language files:
+   ```bash
+   # Copy the structure from en-US.json and translate the values
+   # For example, in de-DE.json:
+   {
+     "auth": {
+       "new_feature": {
+         "title": "Neues Feature",
+         "description": "Beschreibung des neuen Features"
+       }
+     }
+   }
+   ```
+3. Run `pnpm scan-translations` to verify all translations are complete
+4. Commit the changes
+
+## Pre-commit Hook Behavior
+
+The pre-commit hook will:
+
+1. Run `lint-staged` for code formatting
+2. If `LINGODOTDEV_API_KEY` is set:
+   - Generate translations using Lingo.dev
+   - Validate translation keys
+   - Auto-add updated locale files to the commit
+   - **Block the commit** if validation fails
+3. If `LINGODOTDEV_API_KEY` is not set:
+   - Skip translation validation (for community contributors)
+   - Show a warning message
+
+## Environment Variables
+
+### LINGODOTDEV_API_KEY
+
+This is the API key for Lingo.dev integration.
+
+**For Core Team:**
+- Add to your local `.env` file
+- Required for running translation generation
+
+**For Community Contributors:**
+- Not required for local development
+- Translation validation will be skipped
+- The CI will still validate translations
+
+## Best Practices
+
+### 1. Keep Keys Organized
+
+Group related keys together:
+```json
+{
+  "auth": {
+    "login": { ... },
+    "signup": { ... },
+    "forgot_password": { ... }
+  },
+  "dashboard": {
+    "header": { ... },
+    "sidebar": { ... }
+  }
+}
+```
+
+### 2. Avoid Hardcoded Strings
+
+**❌ Bad:**
+```tsx
+<button>Click here</button>
+```
+
+**✅ Good:**
+```tsx
+<button>{t("common.click_here")}</button>
+```
+
+### 3. Use Interpolation for Dynamic Content
+
+**❌ Bad:**
+```tsx
+{t("welcome")} {userName}!
+```
+
+**✅ Good:**
+```tsx
+{t("auth.welcome_message", { userName })}
+```
+
+With translation:
+```json
+{
+  "auth": {
+    "welcome_message": "Welcome, {userName}!"
+  }
+}
+```
+
+### 4. Avoid Dynamic Key Construction
+
+**❌ Bad:**
+```tsx
+const key = `errors.${errorCode}`;
+t(key);
+```
+
+**✅ Good:**
+```tsx
+switch (errorCode) {
+  case "401":
+    return t("errors.unauthorized");
+  case "404":
+    return t("errors.not_found");
+  default:
+    return t("errors.unknown");
+}
+```
+
+### 5. Test Translation Keys
+
+When adding new features:
+1. Add translation keys
+2. Test in multiple languages using the language switcher
+3. Ensure text doesn't overflow in longer translations (German, French)
+4. Run `pnpm scan-translations` before committing
+
+## Troubleshooting
+
+### Issue: Pre-commit hook fails with validation errors
+
+**Solution:**
+```bash
+# Run the full i18n workflow
+pnpm i18n
+
+# Fix any missing or unused keys
+# Then commit again
+git add .
+git commit -m "your message"
+```
+
+### Issue: Translation validation passes locally but fails in CI
+
+**Solution:**
+- Ensure all translation files are committed
+- Check that `scan-translations.ts` hasn't been modified
+- Verify that locale files are properly formatted JSON
+
+### Issue: Cannot commit because of missing translations
+
+**Solution:**
+```bash
+# If you have LINGODOTDEV_API_KEY:
+pnpm generate-translations
+
+# If you don't have the API key (community contributor):
+# Manually add the missing keys to en-US.json
+# Then run validation:
+pnpm scan-translations
+```
+
+### Issue: Getting "unused keys" for keys that are used
+
+**Solution:**
+- The script scans `.ts` and `.tsx` files only
+- If keys are used in other file types, they may be flagged
+- Verify the key is actually used with `grep -r "your.key" apps/web/`
+- If it's a false positive, consider updating the scanning patterns in `scan-translations.ts`
+
+## AI Assistant Guidelines
+
+When assisting with i18n-related tasks, always:
+
+1. **Use the `t()` function** for all user-facing text
+2. **Follow key naming conventions** (lowercase, dots for nesting)
+3. **Run validation** after making changes: `pnpm scan-translations`
+4. **Fix missing keys** by adding them to `en-US.json`
+5. **Remove unused keys** from all translation files
+6. **Test the pre-commit hook** if making changes to translation workflow
+7. **Update this rule file** if translation workflow changes
+
+### Fixing Missing Translation Keys
+
+When the AI encounters missing translation key errors:
+
+1. Identify the missing keys from the error output
+2. Determine the appropriate section and naming for each key
+3. Add the keys to `apps/web/locales/en-US.json` with meaningful English text
+4. Ensure proper JSON structure and nesting
+5. Run `pnpm scan-translations` to verify
+6. Inform the user that other language files will be updated via Lingo.dev
+
+**Example:**
+```typescript
+// Error: Missing key "settings.api.rate_limit_exceeded"
+
+// Add to en-US.json:
+{
+  "settings": {
+    "api": {
+      "rate_limit_exceeded": "API rate limit exceeded. Please try again later."
+    }
+  }
+}
+```
+
+### Removing Unused Translation Keys
+
+When the AI encounters unused translation key errors:
+
+1. Verify the keys are truly unused by searching the codebase
+2. Remove the keys from `apps/web/locales/en-US.json`
+3. Note that removal from other language files can be handled via Lingo.dev
+4. Run `pnpm scan-translations` to verify
+
+## Migration Notes
+
+This project previously used Tolgee for translations. As of this migration:
+
+- **Old scripts**: `tolgee-pull` is deprecated (kept for reference)
+- **New scripts**: Use `pnpm i18n` or `pnpm generate-translations`
+- **Old workflows**: `tolgee.yml` and `tolgee-missing-key-check.yml` removed
+- **New workflow**: `translation-check.yml` handles all validation
+
+---
+
+**Last Updated:** October 14, 2025
+**Related Files:**
+- `scan-translations.ts` - Translation validation script
+- `.husky/pre-commit` - Pre-commit hook with i18n validation
+- `.github/workflows/translation-check.yml` - CI workflow for translation validation
+- `apps/web/locales/*.json` - Translation files

.cursor/rules/react-context-patterns.mdc

@@ -0,0 +1,52 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+# React Context & Provider Patterns
+
+## Context Provider Best Practices
+
+### Provider Implementation
+- Use TypeScript interfaces for provider props with optional `initialCount` for testing
+- Implement proper cleanup in `useEffect` to avoid React hooks warnings
+- Reference: [apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/components/ResponseCountProvider.tsx](mdc:apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/components/ResponseCountProvider.tsx)
+
+### Cleanup Pattern for Refs
+```typescript
+useEffect(() => {
+  const currentPendingRequests = pendingRequests.current;
+  const currentAbortController = abortController.current;
+  
+  return () => {
+    if (currentAbortController) {
+      currentAbortController.abort();
+    }
+    currentPendingRequests.clear();
+  };
+}, []);
+```
+
+### Testing Context Providers
+- Always wrap components using context in the provider during tests
+- Use `initialCount` prop for predictable test scenarios
+- Mock context dependencies like `useParams`, `useResponseFilter`
+- Example from [apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/SurveyAnalysisCTA.test.tsx](mdc:apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/SurveyAnalysisCTA.test.tsx):
+
+```typescript
+render(
+  <ResponseCountProvider survey={dummySurvey} initialCount={5}>
+    <ComponentUnderTest />
+  </ResponseCountProvider>
+);
+```
+
+### Required Mocks for Context Testing
+- Mock `next/navigation` with `useParams` returning environment and survey IDs
+- Mock response filter context and actions
+- Mock API actions that the provider depends on
+
+### Context Hook Usage
+- Create custom hooks like `useResponseCountContext()` for consuming context
+- Provide meaningful error messages when context is used outside provider
+- Use context for shared state that multiple components need to access

.cursor/rules/review-and-refine.mdc

@@ -0,0 +1,179 @@
+---
+description: Apply these quality standards before finalizing code changes to ensure DRY principles, React best practices, TypeScript conventions, and maintainable code.
+globs:
+alwaysApply: false
+---
+
+# Review & Refine
+
+Before finalizing any code changes, review your implementation against these quality standards:
+
+## Core Principles
+
+### DRY (Don't Repeat Yourself)
+
+- Extract duplicated logic into reusable functions or hooks
+- If the same code appears in multiple places, consolidate it
+- Create helper functions at appropriate scope (component-level, module-level, or utility files)
+- Avoid copy-pasting code blocks
+
+### Code Reduction
+
+- Remove unnecessary code, comments, and abstractions
+- Prefer built-in solutions over custom implementations
+- Consolidate similar logic
+- Remove dead code and unused imports
+- Question if every line of code is truly needed
+
+## React Best Practices
+
+### Component Design
+
+- Keep components focused on a single responsibility
+- Extract complex logic into custom hooks
+- Prefer composition over prop drilling
+- Use children props and render props when appropriate
+- Keep component files under 300 lines when possible
+
+### Hooks Usage
+
+- Follow Rules of Hooks (only call at top level, only in React functions)
+- Extract complex `useEffect` logic into custom hooks
+- Use `useMemo` and `useCallback` only when you have a measured performance issue
+- Declare dependencies arrays correctly - don't ignore exhaustive-deps warnings
+- Keep `useEffect` focused on a single concern
+
+### State Management
+
+- Colocate state as close as possible to where it's used
+- Lift state only when necessary
+- Use `useReducer` for complex state logic with multiple sub-values
+- Avoid derived state - compute values during render instead
+- Don't store values in state that can be computed from props
+
+### Event Handlers
+
+- Name event handlers with `handle` prefix (e.g., `handleClick`, `handleSubmit`)
+- Extract complex event handler logic into separate functions
+- Avoid inline arrow functions in JSX when they contain complex logic
+
+## TypeScript Best Practices
+
+### Type Safety
+
+- Prefer type inference over explicit types when possible
+- Use `const` assertions for literal types
+- Avoid `any` - use `unknown` if type is truly unknown
+- Use discriminated unions for complex conditional logic
+- Leverage type guards and narrowing
+
+### Interface & Type Usage
+
+- Use existing types from `@formbricks/types` - don't recreate them
+- Prefer `interface` for object shapes that might be extended
+- Prefer `type` for unions, intersections, and mapped types
+- Define types close to where they're used unless they're shared
+- Export types from index files for shared types
+
+### Type Assertions
+
+- Avoid type assertions (`as`) when possible
+- Use type guards instead of assertions
+- Only assert when you have more information than TypeScript
+
+## Code Organization
+
+### Separation of Concerns
+
+- Separate business logic from UI rendering
+- Extract API calls into separate functions or modules
+- Keep data transformation separate from component logic
+- Use custom hooks for stateful logic that doesn't render UI
+
+### Function Clarity
+
+- Functions should do one thing well
+- Name functions clearly and descriptively
+- Keep functions small (aim for under 20 lines)
+- Extract complex conditionals into named boolean variables or functions
+- Avoid deep nesting (max 3 levels)
+
+### File Structure
+
+- Group related functions together
+- Order declarations logically (types → hooks → helpers → component)
+- Keep imports organized (external → internal → relative)
+- Consider splitting large files by concern
+
+## Additional Quality Checks
+
+### Performance
+
+- Don't optimize prematurely - measure first
+- Avoid creating new objects/arrays/functions in render unnecessarily
+- Use keys properly in lists (stable, unique identifiers)
+- Lazy load heavy components when appropriate
+
+### Accessibility
+
+- Use semantic HTML elements
+- Include ARIA labels where needed
+- Ensure keyboard navigation works
+- Check color contrast and focus states
+
+### Error Handling
+
+- Handle error states in components
+- Provide user feedback for failed operations
+- Use error boundaries for component errors
+- Log errors appropriately (avoid swallowing errors silently)
+
+### Naming Conventions
+
+- Use descriptive names (avoid abbreviations unless very common)
+- Boolean variables/props should sound like yes/no questions (`isLoading`, `hasError`, `canEdit`)
+- Arrays should be plural (`users`, `choices`, `items`)
+- Event handlers: `handleX` in components, `onX` for props
+- Constants in UPPER_SNAKE_CASE only for true constants
+
+### Code Readability
+
+- Prefer early returns to reduce nesting
+- Use destructuring to make code clearer
+- Break complex expressions into named variables
+- Add comments only when code can't be made self-explanatory
+- Use whitespace to group related code
+
+### Testing Considerations
+
+- Write code that's easy to test (pure functions, clear inputs/outputs)
+- Avoid hard-to-mock dependencies when possible
+- Keep side effects at the edges of your code
+
+## Review Checklist
+
+Before submitting your changes, ask yourself:
+
+1. **DRY**: Is there any duplicated logic I can extract?
+2. **Clarity**: Would another developer understand this code easily?
+3. **Simplicity**: Is this the simplest solution that works?
+4. **Types**: Am I using TypeScript effectively?
+5. **React**: Am I following React idioms and best practices?
+6. **Performance**: Are there obvious performance issues?
+7. **Separation**: Are concerns properly separated?
+8. **Testing**: Is this code testable?
+9. **Maintenance**: Will this be easy to change in 6 months?
+10. **Deletion**: Can I remove any code and still accomplish the goal?
+
+## When to Apply This Rule
+
+Apply this rule:
+
+- After implementing a feature but before marking it complete
+- When you notice your code feels "messy" or complex
+- Before requesting code review
+- When you see yourself copy-pasting code
+- After receiving feedback about code quality
+
+Don't let perfect be the enemy of good, but always strive for:
+**Simple, readable, maintainable code that does one thing well.**

.cursor/rules/storybook-component-migration.mdc

@@ -0,0 +1,216 @@
+---
+description: Migrate deprecated UI components to a unified component
+globs: 
+alwaysApply: false
+---
+# Component Migration Automation Rule
+
+## Overview
+This rule automates the migration of deprecated components to new component systems in React/TypeScript codebases.
+
+## Trigger
+When the user requests component migration (e.g., "migrate [DeprecatedComponent] to [NewComponent]" or "component migration").
+
+## Process
+
+### Step 1: Discovery and Planning
+1. **Identify migration parameters:**
+   - Ask user for deprecated component name (e.g., "Modal")
+   - Ask user for new component name(s) (e.g., "Dialog")
+   - Ask for any components to exclude (e.g., "ModalWithTabs")
+   - Ask for specific import paths if needed
+
+2. **Scan codebase** for deprecated components:
+   - Search for `import.*[DeprecatedComponent]` patterns
+   - Exclude specified components that should not be migrated
+   - List all found components with file paths
+   - Present numbered list to user for confirmation
+
+### Step 2: Component-by-Component Migration
+For each component, follow this exact sequence:
+
+#### 2.1 Component Migration
+- **Import changes:**
+  - Ask user to provide the new import structure
+  - Example transformation pattern:
+  ```typescript
+  // FROM:
+  import { [DeprecatedComponent] } from "@/components/ui/[DeprecatedComponent]"
+  
+  // TO:
+  import {
+    [NewComponent],
+    [NewComponentPart1],
+    [NewComponentPart2],
+    // ... other parts
+  } from "@/components/ui/[NewComponent]"
+  ```
+
+- **Props transformation:**
+  - Ask user for prop mapping rules (e.g., `open` → `open`, `setOpen` → `onOpenChange`)
+  - Ask for props to remove (e.g., `noPadding`, `closeOnOutsideClick`, `size`)
+  - Apply transformations based on user specifications
+
+- **Structure transformation:**
+  - Ask user for the new component structure pattern
+  - Apply the transformation maintaining all functionality
+  - Preserve all existing logic, state management, and event handlers
+
+#### 2.2 Wait for User Approval
+- Present the migration changes
+- Wait for explicit user approval before proceeding
+- If rejected, ask for specific feedback and iterate
+#### 2.3 Re-read and Apply Additional Changes
+- Re-read the component file to capture any user modifications
+- Apply any additional improvements the user made
+- Ensure all changes are incorporated
+
+#### 2.4 Test File Updates
+- **Find corresponding test file** (same name with `.test.tsx` or `.test.ts`)
+- **Update test mocks:**
+  - Ask user for new component mock structure
+  - Replace old component mocks with new ones
+  - Example pattern:
+  ```typescript
+  // Add to test setup:
+  jest.mock("@/components/ui/[NewComponent]", () => ({
+    [NewComponent]: ({ children, [props] }: any) => ([mock implementation]),
+    [NewComponentPart1]: ({ children }: any) => <div data-testid="[new-component-part1]">{children}</div>,
+    [NewComponentPart2]: ({ children }: any) => <div data-testid="[new-component-part2]">{children}</div>,
+    // ... other parts
+  }));
+  ```
+- **Update test expectations:**
+  - Change test IDs from old component to new component
+  - Update any component-specific assertions
+  - Ensure all new component parts used in the component are mocked
+
+#### 2.5 Run Tests and Optimize
+- Execute `Node package manager test -- ComponentName.test.tsx`
+- Fix any failing tests
+- Optimize code quality (imports, formatting, etc.)
+- Re-run tests until all pass
+- **Maximum 3 iterations** - if still failing, ask user for guidance
+
+#### 2.6 Wait for Final Approval
+- Present test results and any optimizations made
+- Wait for user approval of the complete migration
+- If rejected, iterate based on feedback
+
+#### 2.7 Git Commit
+- Run: `git add .`
+- Run: `git commit -m "migrate [ComponentName] from [DeprecatedComponent] to [NewComponent]"`
+- Confirm commit was successful
+
+### Step 3: Final Report Generation
+After all components are migrated, generate a comprehensive GitHub PR report:
+
+#### PR Title
+```
+feat: migrate [DeprecatedComponent] components to [NewComponent] system
+```
+
+#### PR Description Template
+```markdown
+## 🔄 [DeprecatedComponent] to [NewComponent] Migration
+
+### Overview
+Migrated [X] [DeprecatedComponent] components to the new [NewComponent] component system to modernize the UI architecture and improve consistency.
+
+### Components Migrated
+[List each component with file path]
+
+### Technical Changes
+- **Imports:** Replaced `[DeprecatedComponent]` with `[NewComponent], [NewComponentParts...]`
+- **Props:** [List prop transformations]
+- **Structure:** Implemented proper [NewComponent] component hierarchy
+- **Styling:** [Describe styling changes]
+- **Tests:** Updated all test mocks and expectations
+
+### Migration Pattern
+```typescript
+// Before
+<[DeprecatedComponent] [oldProps]>
+  [oldStructure]
+</[DeprecatedComponent]>
+
+// After
+<[NewComponent] [newProps]>
+  [newStructure]
+</[NewComponent]>
+```
+
+### Testing
+- ✅ All existing tests updated and passing
+- ✅ Component functionality preserved
+- ✅ UI/UX behavior maintained
+
+### How to Test This PR
+1. **Functional Testing:**
+   - Navigate to each migrated component's usage
+   - Verify [component] opens and closes correctly
+   - Test all interactive elements within [components]
+   - Confirm styling and layout are preserved
+
+2. **Automated Testing:**
+   ```bash
+   Node package manager test
+   ```
+
+3. **Visual Testing:**
+   - Check that all [components] maintain proper styling
+   - Verify responsive behavior
+   - Test keyboard navigation and accessibility
+
+### Breaking Changes
+[List any breaking changes or state "None - this is a drop-in replacement maintaining all existing functionality."]
+
+### Notes
+- [Any excluded components] were preserved as they already use [NewComponent] internally
+- All form validation and complex state management preserved
+- Enhanced code quality with better imports and formatting
+```
+
+## Special Considerations
+
+### Excluded Components
+- **DO NOT MIGRATE** components specified by user as exclusions
+- They may already use the new component internally or have other reasons
+- Inform user these are skipped and why
+
+### Complex Components
+- Preserve all existing functionality (forms, validation, state management)
+- Maintain prop interfaces
+- Keep all event handlers and callbacks
+- Preserve accessibility features
+
+### Test Coverage
+- Ensure all new component parts are mocked when used
+- Mock all new component parts that appear in the component
+- Update test IDs from old component to new component
+- Maintain all existing test scenarios
+
+### Error Handling
+- If tests fail after 3 iterations, stop and ask user for guidance
+- If component is too complex, ask user for specific guidance
+- If unsure about functionality preservation, ask for clarification
+
+### Migration Patterns
+- Always ask user for specific migration patterns before starting
+- Confirm import structures, prop mappings, and component hierarchies
+- Adapt to different component architectures (simple replacements, complex restructuring, etc.)
+
+## Success Criteria
+- All deprecated components successfully migrated to new components
+- All tests passing
+- No functionality lost
+- Code quality maintained or improved
+- User approval on each component
+- Successful git commits for each migration
+- Comprehensive PR report generated
+
+## Usage Examples
+- "migrate Modal to Dialog"
+- "migrate Button to NewButton" 
+- "migrate Card to ModernCard"
+- "component migration" (will prompt for details) 

.cursor/rules/storybook-create-new-story.mdc

@@ -0,0 +1,177 @@
+---
+description: Create a story in Storybook for a given component
+globs:
+alwaysApply: false
+---
+
+# Formbricks Storybook Stories
+
+## When generating Storybook stories for Formbricks components:
+
+### 1. **File Structure**
+- Create `stories.tsx` (not `.stories.tsx`) in component directory
+- Use exact import: `import { Meta, StoryObj } from "@storybook/react-vite";`
+- Import component from `"./index"`
+
+### 2. **Story Structure Template**
+```tsx
+import { Meta, StoryObj } from "@storybook/react-vite";
+import { ComponentName } from "./index";
+
+// For complex components with configurable options
+// consider this as an example the options need to reflect the props types
+interface StoryOptions {
+  showIcon: boolean;
+  numberOfElements: number;
+  customLabels: string[];
+}
+
+type StoryProps = React.ComponentProps<typeof ComponentName> & StoryOptions;
+
+const meta: Meta<StoryProps> = {
+  title: "UI/ComponentName",
+  component: ComponentName,
+  tags: ["autodocs"],
+  parameters: {
+    layout: "centered",
+    controls: { sort: "alpha", exclude: [] },
+    docs: {
+      description: {
+        component: "The **ComponentName** component provides [description].",
+      },
+    },
+  },
+  argTypes: {
+    // Organize in exactly these categories: Behavior, Appearance, Content
+  },
+};
+
+export default meta;
+type Story = StoryObj<typeof ComponentName> & { args: StoryOptions };
+```
+
+### 3. **ArgTypes Organization**
+Organize ALL argTypes into exactly three categories:
+- **Behavior**: disabled, variant, onChange, etc.
+- **Appearance**: size, color, layout, styling, etc.  
+- **Content**: text, icons, numberOfElements, etc.
+
+Format:
+```tsx
+argTypes: {
+  propName: {
+    control: "select" | "boolean" | "text" | "number",
+    options: ["option1", "option2"], // for select
+    description: "Clear description",
+    table: {
+      category: "Behavior" | "Appearance" | "Content",
+      type: { summary: "string" },
+      defaultValue: { summary: "default" },
+    },
+    order: 1,
+  },
+}
+```
+
+### 4. **Required Stories**
+Every component must include:
+- `Default`: Most common use case
+- `Disabled`: If component supports disabled state
+- `WithIcon`: If component supports icons
+- Variant stories for each variant (Primary, Secondary, Error, etc.)
+- Edge case stories (ManyElements, LongText, CustomStyling)
+
+### 5. **Story Format**
+```tsx
+export const Default: Story = {
+  args: {
+    // Props with realistic values
+  },
+};
+
+export const EdgeCase: Story = {
+  args: { /* ... */ },
+  parameters: {
+    docs: {
+      description: {
+        story: "Use this when [specific scenario].",
+      },
+    },
+  },
+};
+```
+
+### 6. **Dynamic Content Pattern**
+For components with dynamic content, create render function:
+```tsx
+const renderComponent = (args: StoryProps) => {
+  const { numberOfElements, showIcon, customLabels } = args;
+  
+  // Generate dynamic content
+  const elements = Array.from({ length: numberOfElements }, (_, i) => ({
+    id: `element-${i}`,
+    label: customLabels[i] || `Element ${i + 1}`,
+    icon: showIcon ? <IconComponent /> : undefined,
+  }));
+  
+  return <ComponentName {...args} elements={elements} />;
+};
+
+export const Dynamic: Story = {
+  render: renderComponent,
+  args: {
+    numberOfElements: 3,
+    showIcon: true,
+    customLabels: ["First", "Second", "Third"],
+  },
+};
+```
+
+### 7. **State Management**
+For interactive components:
+```tsx
+import { useState } from "react";
+
+const ComponentWithState = (args: any) => {
+  const [value, setValue] = useState(args.defaultValue);
+  
+  return (
+    <ComponentName
+      {...args}
+      value={value}
+      onChange={(newValue) => {
+        setValue(newValue);
+        args.onChange?.(newValue);
+      }}
+    />
+  );
+};
+
+export const Interactive: Story = {
+  render: ComponentWithState,
+  args: { defaultValue: "initial" },
+};
+```
+
+### 8. **Quality Requirements**
+- Include component description in parameters.docs
+- Add story documentation for non-obvious use cases
+- Test edge cases (overflow, empty states, many elements)
+- Ensure no TypeScript errors
+- Use realistic prop values
+- Include at least 3-5 story variants
+- Example values need to be in the context of survey application
+
+### 9. **Naming Conventions**
+- **Story titles**: "UI/ComponentName"
+- **Story exports**: PascalCase (Default, WithIcon, ManyElements)
+- **Categories**: "Behavior", "Appearance", "Content" (exact spelling)
+- **Props**: camelCase matching component props
+
+### 10. **Special Cases**
+- **Generic components**: Remove `component` from meta if type conflicts
+- **Form components**: Include Invalid, WithValue stories
+- **Navigation**: Include ManyItems stories
+- **Modals, Dropdowns and Popups **: Include trigger and content structure
+
+## Generate stories that are comprehensive, well-documented, and reflect all component states and edge cases. 

.env.example

@@ -184,13 +184,8 @@ ENTERPRISE_LICENSE_KEY=
 # Ignore Rate Limiting across the Formbricks app
 # RATE_LIMITING_DISABLED=1
 
-# OpenTelemetry OTLP endpoint (base URL, exporters append /v1/traces and /v1/metrics)
-# OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
-# OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
-# OTEL_SERVICE_NAME=formbricks
-# OTEL_RESOURCE_ATTRIBUTES=deployment.environment=development
-# OTEL_TRACES_SAMPLER=parentbased_traceidratio
-# OTEL_TRACES_SAMPLER_ARG=1
+# OpenTelemetry URL for tracing
+# OPENTELEMETRY_LISTENER_URL=http://localhost:4318/v1/traces
 
 # Unsplash API Key
 UNSPLASH_ACCESS_KEY=

.github/workflows/release-helm-chart.yml

@@ -65,8 +65,8 @@ jobs:
           set -euo pipefail
 
           echo "Updating Chart.yaml with version: ${VERSION}"
-          yq -i ".version = \"${VERSION}\"" charts/formbricks/Chart.yaml
-          yq -i ".appVersion = \"${VERSION}\"" charts/formbricks/Chart.yaml
+          yq -i ".version = \"${VERSION}\"" helm-chart/Chart.yaml
+          yq -i ".appVersion = \"${VERSION}\"" helm-chart/Chart.yaml
 
           echo "✅ Successfully updated Chart.yaml"
 
@@ -77,7 +77,7 @@ jobs:
           set -euo pipefail
 
           echo "Packaging Helm chart version: ${VERSION}"
-          helm package ./charts/formbricks
+          helm package ./helm-chart
 
           echo "✅ Successfully packaged formbricks-${VERSION}.tgz"
 

.github/workflows/sonarqube.yml

@@ -9,7 +9,6 @@ on:
   merge_group:
 permissions:
   contents: read
-  pull-requests: read
 jobs:
   sonarqube:
     name: SonarQube
@@ -51,9 +50,6 @@ jobs:
           pnpm test:coverage
       - name: SonarQube Scan
         uses: SonarSource/sonarqube-scan-action@2500896589ef8f7247069a56136f8dc177c27ccf
-        with:
-          args: >
-            -Dsonar.verbose=true
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # Needed to get PR information, if any
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

.github/workflows/translation-check.yml

@@ -32,20 +32,21 @@ jobs:
         with:
           egress-policy: audit
 
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis
+      - name: Checkout repository
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
-      - name: Setup Node.js 22.x
-        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af
+      - name: Setup Node.js
+        uses: actions/setup-node@1d0ff469b7ec7b3cb9d8673fde0c81c44821de2a # v4.2.0
         with:
-          node-version: 22.x
+          node-version: 18
 
-      - name: Install pnpm
-        uses: pnpm/action-setup@a7487c7e89a18df4991f7f222e4898a00d66ddda # v4.1.0
+      - name: Setup pnpm
+        uses: pnpm/action-setup@a3252b78c470c02df07e9d59298aecedc3ccdd6d # v3.0.0
+        with:
+          version: 9.15.9
 
       - name: Install dependencies
-        run: pnpm install --config.platform=linux --config.architecture=x64
+        run: pnpm install --frozen-lockfile
 
       - name: Validate translation keys
         run: |

.gitignore

@@ -13,7 +13,6 @@
 **/.next/
 **/out/
 **/build
-**/next-env.d.ts
 
 # node
 **/dist/
@@ -64,5 +63,3 @@ packages/ios/FormbricksSDK/FormbricksSDK.xcodeproj/project.xcworkspace/xcuserdat
 .cursorrules
 i18n.cache
 stats.html
-# next-agents-md
-.next-docs/

apps/storybook/package.json

@@ -11,24 +11,24 @@
     "clean": "rimraf .turbo node_modules dist storybook-static"
   },
   "dependencies": {
-    "@formbricks/survey-ui": "workspace:*"
+    "@formbricks/survey-ui": "workspace:*",
+    "eslint-plugin-react-refresh": "0.4.24"
   },
   "devDependencies": {
-    "@chromatic-com/storybook": "^5.0.0",
-    "@storybook/addon-a11y": "10.1.11",
-    "@storybook/addon-links": "10.1.11",
-    "@storybook/addon-onboarding": "10.1.11",
-    "@storybook/react-vite": "10.1.11",
-    "@typescript-eslint/eslint-plugin": "8.53.0",
-    "@tailwindcss/vite": "4.1.18",
-    "@typescript-eslint/parser": "8.53.0",
-    "@vitejs/plugin-react": "5.1.2",
-    "esbuild": "0.25.12",
-    "eslint-plugin-react-refresh": "0.4.26",
-    "eslint-plugin-storybook": "10.1.11",
+    "@chromatic-com/storybook": "^4.1.3",
+    "@storybook/addon-a11y": "10.0.8",
+    "@storybook/addon-links": "10.0.8",
+    "@storybook/addon-onboarding": "10.0.8",
+    "@storybook/react-vite": "10.0.8",
+    "@typescript-eslint/eslint-plugin": "8.48.0",
+    "@tailwindcss/vite": "4.1.17",
+    "@typescript-eslint/parser": "8.48.0",
+    "@vitejs/plugin-react": "5.1.1",
+    "esbuild": "0.27.0",
+    "eslint-plugin-storybook": "10.0.8",
     "prop-types": "15.8.1",
-    "storybook": "10.1.11",
-    "vite": "7.3.1",
-    "@storybook/addon-docs": "10.1.11"
+    "storybook": "10.0.8",
+    "vite": "7.2.4",
+    "@storybook/addon-docs": "10.0.8"
   }
 }

apps/web/.eslintignore

@@ -1,7 +0,0 @@
-node_modules/
-.next/
-public/
-playwright/
-dist/
-coverage/
-vendor/

apps/web/.eslintrc.js

@@ -1,4 +1,20 @@
 module.exports = {
   extends: ["@formbricks/eslint-config/legacy-next.js"],
   ignorePatterns: ["**/package.json", "**/tsconfig.json"],
+  overrides: [
+    {
+      files: ["locales/*.json"],
+      plugins: ["i18n-json"],
+      rules: {
+        "i18n-json/identical-keys": [
+          "error",
+          {
+            filePath: require("path").join(__dirname, "locales", "en-US.json"),
+            checkExtraKeys: false,
+            checkMissingKeys: true,
+          },
+        ],
+      },
+    },
+  ],
 };

apps/web/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:24-alpine3.23 AS base
+FROM node:22-alpine3.22 AS base
 
 #
 ## step 1: Prune monorepo
@@ -20,7 +20,7 @@ FROM base AS installer
 # Enable corepack and prepare pnpm
 RUN npm install --ignore-scripts -g corepack@latest 
 RUN corepack enable
-RUN corepack prepare pnpm@10.28.2 --activate
+RUN corepack prepare pnpm@9.15.9 --activate
 
 # Install necessary build tools and compilers
 RUN apk update && apk add --no-cache cmake g++ gcc jq make openssl-dev python3
@@ -69,14 +69,20 @@ RUN --mount=type=secret,id=database_url \
     --mount=type=secret,id=sentry_auth_token \
     /tmp/read-secrets.sh pnpm build --filter=@formbricks/web...
 
+# Extract Prisma version
+RUN jq -r '.devDependencies.prisma' packages/database/package.json > /prisma_version.txt
+
 #
 ## step 3: setup production runner
 #
 FROM base AS runner
 
-# Update npm to latest, then create user
-# Note: npm's bundled tar has a known vulnerability but npm is only used during build, not at runtime
-RUN npm install --ignore-scripts -g npm@latest \
+RUN npm install --ignore-scripts -g corepack@latest && \
+    corepack enable
+
+RUN apk add --no-cache curl \
+    && apk add --no-cache supercronic \
+    # && addgroup --system --gid 1001 nodejs \
     && addgroup -S nextjs \
     && adduser -S -u 1001 -G nextjs nextjs
 
@@ -98,56 +104,31 @@ RUN chown -R nextjs:nextjs ./apps/web/.next/static && chmod -R 755 ./apps/web/.n
 COPY --from=installer /app/apps/web/public ./apps/web/public
 RUN chown -R nextjs:nextjs ./apps/web/public && chmod -R 755 ./apps/web/public
 
-# Create packages/database directory structure with proper ownership for runtime migrations
-RUN mkdir -p ./packages/database/migrations && chown -R nextjs:nextjs ./packages/database
-
-COPY --from=installer /app/packages/database/package.json ./packages/database/package.json
-RUN chown nextjs:nextjs ./packages/database/package.json && chmod 644 ./packages/database/package.json
-
 COPY --from=installer /app/packages/database/schema.prisma ./packages/database/schema.prisma
 RUN chown nextjs:nextjs ./packages/database/schema.prisma && chmod 644 ./packages/database/schema.prisma
 
 COPY --from=installer /app/packages/database/dist ./packages/database/dist
 RUN chown -R nextjs:nextjs ./packages/database/dist && chmod -R 755 ./packages/database/dist
 
-# Copy prisma client packages
 COPY --from=installer /app/node_modules/@prisma/client ./node_modules/@prisma/client
 RUN chown -R nextjs:nextjs ./node_modules/@prisma/client && chmod -R 755 ./node_modules/@prisma/client
 
 COPY --from=installer /app/node_modules/.prisma ./node_modules/.prisma
 RUN chown -R nextjs:nextjs ./node_modules/.prisma && chmod -R 755 ./node_modules/.prisma
 
+COPY --from=installer /prisma_version.txt .
+RUN chown nextjs:nextjs ./prisma_version.txt && chmod 644 ./prisma_version.txt
+
 COPY --from=installer /app/node_modules/@paralleldrive/cuid2 ./node_modules/@paralleldrive/cuid2
 RUN chmod -R 755 ./node_modules/@paralleldrive/cuid2
 
-COPY --from=installer /app/node_modules/uuid ./node_modules/uuid
-RUN chmod -R 755 ./node_modules/uuid
-
 COPY --from=installer /app/node_modules/@noble/hashes ./node_modules/@noble/hashes
 RUN chmod -R 755 ./node_modules/@noble/hashes
 
 COPY --from=installer /app/node_modules/zod ./node_modules/zod
 RUN chmod -R 755 ./node_modules/zod
 
-# Pino loads transport code in worker threads via dynamic require().
-# Next.js file tracing only traces static imports, missing runtime-loaded files
-# (e.g. pino/lib/transport-stream.js, transport targets).
-# Copy the full packages to ensure all runtime files are available.
-COPY --from=installer /app/node_modules/pino ./node_modules/pino
-RUN chmod -R 755 ./node_modules/pino
-
-COPY --from=installer /app/node_modules/pino-opentelemetry-transport ./node_modules/pino-opentelemetry-transport
-RUN chmod -R 755 ./node_modules/pino-opentelemetry-transport
-
-COPY --from=installer /app/node_modules/pino-abstract-transport ./node_modules/pino-abstract-transport
-RUN chmod -R 755 ./node_modules/pino-abstract-transport
-
-COPY --from=installer /app/node_modules/otlp-logger ./node_modules/otlp-logger
-RUN chmod -R 755 ./node_modules/otlp-logger
-
-# Install prisma CLI globally for database migrations and fix permissions for nextjs user
-RUN npm install --ignore-scripts -g prisma@6 \
-    && chown -R nextjs:nextjs /usr/local/lib/node_modules/prisma
+RUN npm install -g prisma@6
 
 # Create a startup script to handle the conditional logic
 COPY --from=installer /app/apps/web/scripts/docker/next-start.sh /home/nextjs/start.sh
@@ -157,8 +138,10 @@ EXPOSE 3000
 ENV HOSTNAME="0.0.0.0"
 USER nextjs
 
+# Prepare pnpm as the nextjs user to ensure it's available at runtime
 # Prepare volumes for uploads and SAML connections
-RUN mkdir -p /home/nextjs/apps/web/uploads/ && \
+RUN corepack prepare pnpm@9.15.9 --activate && \
+    mkdir -p /home/nextjs/apps/web/uploads/ && \
     mkdir -p /home/nextjs/apps/web/saml-connection
 
 VOLUME /home/nextjs/apps/web/uploads/

apps/web/app/(app)/(onboarding)/environments/[environmentId]/xm-templates/lib/utils.test.ts

@@ -25,7 +25,7 @@ const mockProject: TProject = {
   },
   placement: "bottomRight",
   clickOutsideClose: true,
-  overlay: "none",
+  darkOverlay: false,
   environments: [],
   languages: [],
   logo: null,

apps/web/app/(app)/(onboarding)/organizations/[organizationId]/workspaces/new/settings/components/ProjectSettings.tsx

@@ -3,7 +3,7 @@
 import { zodResolver } from "@hookform/resolvers/zod";
 import Image from "next/image";
 import { useRouter } from "next/navigation";
-import { useMemo, useState } from "react";
+import { useState } from "react";
 import { useForm } from "react-hook-form";
 import { toast } from "react-hot-toast";
 import { useTranslation } from "react-i18next";
@@ -17,7 +17,6 @@ import {
 import { createProjectAction } from "@/app/(app)/environments/[environmentId]/actions";
 import { previewSurvey } from "@/app/lib/templates";
 import { FORMBRICKS_SURVEYS_FILTERS_KEY_LS } from "@/lib/localStorage";
-import { buildStylingFromBrandColor } from "@/lib/styling/constants";
 import { getFormattedErrorMessage } from "@/lib/utils/helper";
 import { TOrganizationTeam } from "@/modules/ee/teams/project-teams/types/team";
 import { CreateTeamModal } from "@/modules/ee/teams/team-list/components/create-team-modal";
@@ -65,17 +64,10 @@ export const ProjectSettings = ({
   const { t } = useTranslation();
   const addProject = async (data: TProjectUpdateInput) => {
     try {
-      // Build the full styling from the chosen brand color so all derived
-      // colours (question, button, input, option, progress, etc.) are persisted.
-      // Without this, only brandColor is saved and the look-and-feel page falls
-      // back to STYLE_DEFAULTS computed from the default brand (#64748b).
-      const fullStyling = buildStylingFromBrandColor(data.styling?.brandColor?.light);
-
       const createProjectResponse = await createProjectAction({
         organizationId,
         data: {
           ...data,
-          styling: fullStyling,
           config: { channel, industry },
           teamIds: data.teamIds,
         },
@@ -120,7 +112,6 @@ export const ProjectSettings = ({
   const projectName = form.watch("name");
   const logoUrl = form.watch("logo.url");
   const brandColor = form.watch("styling.brandColor.light") ?? defaultBrandColor;
-  const previewStyling = useMemo(() => buildStylingFromBrandColor(brandColor), [brandColor]);
   const { isSubmitting } = form.formState;
 
   const organizationTeamsOptions = organizationTeams.map((team) => ({
@@ -235,7 +226,7 @@ export const ProjectSettings = ({
             alt="Logo"
             width={256}
             height={56}
-            className="absolute left-2 top-2 -mb-6 h-20 w-auto max-w-64 rounded-lg border object-contain p-1"
+            className="absolute top-2 left-2 -mb-6 h-20 w-auto max-w-64 rounded-lg border object-contain p-1"
           />
         )}
         <p className="text-sm text-slate-400">{t("common.preview")}</p>
@@ -244,7 +235,7 @@ export const ProjectSettings = ({
             appUrl={publicDomain}
             isPreviewMode={true}
             survey={previewSurvey(projectName || "my Product", t)}
-            styling={previewStyling}
+            styling={{ brandColor: { light: brandColor } }}
             isBrandingEnabled={false}
             languageCode="default"
             onFileUpload={async (file) => file.name}

apps/web/app/(app)/environments/[environmentId]/actions.ts

@@ -2,7 +2,7 @@
 
 import { z } from "zod";
 import { ZId } from "@formbricks/types/common";
-import { AuthorizationError, OperationNotAllowedError } from "@formbricks/types/errors";
+import { OperationNotAllowedError } from "@formbricks/types/errors";
 import { ZProjectUpdateInput } from "@formbricks/types/project";
 import { getMembershipByUserIdOrganizationId } from "@/lib/membership/service";
 import { getOrganization } from "@/lib/organization/service";
@@ -138,7 +138,7 @@ export const getProjectsForSwitcherAction = authenticatedActionClient
     // Need membership for getProjectsByUserId (1 DB query)
     const membership = await getMembershipByUserIdOrganizationId(ctx.user.id, parsedInput.organizationId);
     if (!membership) {
-      throw new AuthorizationError("Membership not found");
+      throw new Error("Membership not found");
     }
 
     return await getProjectsByUserId(ctx.user.id, membership);

apps/web/app/(app)/environments/[environmentId]/components/EnvironmentLayout.tsx

@@ -36,7 +36,7 @@ export const EnvironmentLayout = async ({ layoutData, children }: EnvironmentLay
   // Calculate derived values (no queries)
   const { isMember, isOwner, isManager } = getAccessFlags(membership.role);
 
-  const { features, lastChecked, isPendingDowngrade, active, status } = license;
+  const { features, lastChecked, isPendingDowngrade, active } = license;
   const isMultiOrgEnabled = features?.isMultiOrgEnabled ?? false;
   const organizationProjectsLimit = await getOrganizationProjectsLimit(organization.billing.limits);
   const isOwnerOrManager = isOwner || isManager;
@@ -63,7 +63,6 @@ export const EnvironmentLayout = async ({ layoutData, children }: EnvironmentLay
         active={active}
         environmentId={environment.id}
         locale={user.locale}
-        status={status}
       />
 
       <div className="flex h-full">

apps/web/app/(app)/environments/[environmentId]/components/MainNavigation.tsx

@@ -109,10 +109,7 @@ export const MainNavigation = ({
         href: `/environments/${environment.id}/contacts`,
         name: t("common.contacts"),
         icon: UserIcon,
-        isActive:
-          pathname?.includes("/contacts") ||
-          pathname?.includes("/segments") ||
-          pathname?.includes("/attributes"),
+        isActive: pathname?.includes("/contacts") || pathname?.includes("/segments"),
       },
       {
         name: t("common.configuration"),

apps/web/app/(app)/environments/[environmentId]/settings/(account)/profile/actions.ts

@@ -58,7 +58,7 @@ async function handleEmailUpdate({
     payload.email = inputEmail;
     await updateBrevoCustomer({ id: ctx.user.id, email: inputEmail });
   } else {
-    await sendVerificationNewEmail(ctx.user.id, inputEmail, ctx.user.locale);
+    await sendVerificationNewEmail(ctx.user.id, inputEmail);
   }
   return payload;
 }

apps/web/app/(app)/environments/[environmentId]/settings/(organization)/enterprise/components/EnterpriseLicenseStatus.tsx

@@ -1,142 +0,0 @@
-"use client";
-
-import { TFunction } from "i18next";
-import { RotateCcwIcon } from "lucide-react";
-import { useRouter } from "next/navigation";
-import { useState } from "react";
-import toast from "react-hot-toast";
-import { useTranslation } from "react-i18next";
-import { recheckLicenseAction } from "@/modules/ee/license-check/actions";
-import { Alert, AlertDescription } from "@/modules/ui/components/alert";
-import { Badge } from "@/modules/ui/components/badge";
-import { Button } from "@/modules/ui/components/button";
-import { SettingsCard } from "../../../components/SettingsCard";
-
-type LicenseStatus = "active" | "expired" | "unreachable" | "invalid_license";
-
-interface EnterpriseLicenseStatusProps {
-  status: LicenseStatus;
-  gracePeriodEnd?: Date;
-  environmentId: string;
-}
-
-const getBadgeConfig = (
-  status: LicenseStatus,
-  t: TFunction
-): { type: "success" | "error" | "warning" | "gray"; label: string } => {
-  switch (status) {
-    case "active":
-      return { type: "success", label: t("environments.settings.enterprise.license_status_active") };
-    case "expired":
-      return { type: "error", label: t("environments.settings.enterprise.license_status_expired") };
-    case "unreachable":
-      return { type: "warning", label: t("environments.settings.enterprise.license_status_unreachable") };
-    case "invalid_license":
-      return { type: "error", label: t("environments.settings.enterprise.license_status_invalid") };
-    default:
-      return { type: "gray", label: t("environments.settings.enterprise.license_status") };
-  }
-};
-
-export const EnterpriseLicenseStatus = ({
-  status,
-  gracePeriodEnd,
-  environmentId,
-}: EnterpriseLicenseStatusProps) => {
-  const { t } = useTranslation();
-  const router = useRouter();
-  const [isRechecking, setIsRechecking] = useState(false);
-
-  const handleRecheck = async () => {
-    setIsRechecking(true);
-    try {
-      const result = await recheckLicenseAction({ environmentId });
-      if (result?.serverError) {
-        toast.error(result.serverError || t("environments.settings.enterprise.recheck_license_failed"));
-        return;
-      }
-
-      if (result?.data) {
-        if (result.data.status === "unreachable") {
-          toast.error(t("environments.settings.enterprise.recheck_license_unreachable"));
-        } else if (result.data.status === "invalid_license") {
-          toast.error(t("environments.settings.enterprise.recheck_license_invalid"));
-        } else {
-          toast.success(t("environments.settings.enterprise.recheck_license_success"));
-        }
-        router.refresh();
-      } else {
-        toast.error(t("environments.settings.enterprise.recheck_license_failed"));
-      }
-    } catch (error) {
-      toast.error(
-        error instanceof Error ? error.message : t("environments.settings.enterprise.recheck_license_failed")
-      );
-    } finally {
-      setIsRechecking(false);
-    }
-  };
-
-  const badgeConfig = getBadgeConfig(status, t);
-
-  return (
-    <SettingsCard
-      title={t("environments.settings.enterprise.license_status")}
-      description={t("environments.settings.enterprise.license_status_description")}>
-      <div className="flex flex-col gap-4">
-        <div className="flex items-center justify-between gap-3">
-          <div className="flex flex-col gap-1.5">
-            <Badge type={badgeConfig.type} text={badgeConfig.label} size="normal" className="w-fit" />
-          </div>
-          <Button
-            type="button"
-            variant="outline"
-            size="sm"
-            onClick={handleRecheck}
-            disabled={isRechecking}
-            className="shrink-0">
-            {isRechecking ? (
-              <>
-                <RotateCcwIcon className="mr-2 h-4 w-4 animate-spin" />
-                {t("environments.settings.enterprise.rechecking")}
-              </>
-            ) : (
-              <>
-                <RotateCcwIcon className="mr-2 h-4 w-4" />
-                {t("environments.settings.enterprise.recheck_license")}
-              </>
-            )}
-          </Button>
-        </div>
-        {status === "unreachable" && gracePeriodEnd && (
-          <Alert variant="warning" size="small">
-            <AlertDescription className="overflow-visible whitespace-normal">
-              {t("environments.settings.enterprise.license_unreachable_grace_period", {
-                gracePeriodEnd: new Date(gracePeriodEnd).toLocaleDateString(undefined, {
-                  year: "numeric",
-                  month: "short",
-                  day: "numeric",
-                }),
-              })}
-            </AlertDescription>
-          </Alert>
-        )}
-        {status === "invalid_license" && (
-          <Alert variant="error" size="small">
-            <AlertDescription className="overflow-visible whitespace-normal">
-              {t("environments.settings.enterprise.license_invalid_description")}
-            </AlertDescription>
-          </Alert>
-        )}
-        <p className="border-t border-slate-100 pt-4 text-sm text-slate-500">
-          {t("environments.settings.enterprise.questions_please_reach_out_to")}{" "}
-          <a
-            className="font-medium text-slate-700 underline hover:text-slate-900"
-            href="mailto:hola@formbricks.com">
-            hola@formbricks.com
-          </a>
-        </p>
-      </div>
-    </SettingsCard>
-  );
-};

apps/web/app/(app)/environments/[environmentId]/settings/(organization)/enterprise/page.tsx

@@ -2,10 +2,9 @@ import { CheckIcon } from "lucide-react";
 import Link from "next/link";
 import { notFound } from "next/navigation";
 import { OrganizationSettingsNavbar } from "@/app/(app)/environments/[environmentId]/settings/(organization)/components/OrganizationSettingsNavbar";
-import { EnterpriseLicenseStatus } from "@/app/(app)/environments/[environmentId]/settings/(organization)/enterprise/components/EnterpriseLicenseStatus";
 import { IS_FORMBRICKS_CLOUD } from "@/lib/constants";
 import { getTranslate } from "@/lingodotdev/server";
-import { GRACE_PERIOD_MS, getEnterpriseLicense } from "@/modules/ee/license-check/lib/license";
+import { getEnterpriseLicense } from "@/modules/ee/license-check/lib/license";
 import { getEnvironmentAuth } from "@/modules/environments/lib/utils";
 import { Button } from "@/modules/ui/components/button";
 import { PageContentWrapper } from "@/modules/ui/components/page-content-wrapper";
@@ -26,8 +25,7 @@ const Page = async (props) => {
     return notFound();
   }
 
-  const licenseState = await getEnterpriseLicense();
-  const hasLicense = licenseState.status !== "no-license";
+  const { active: isEnterpriseEdition } = await getEnterpriseLicense();
 
   const paidFeatures = [
     {
@@ -92,22 +90,35 @@ const Page = async (props) => {
           activeId="enterprise"
         />
       </PageHeader>
-      {hasLicense ? (
-        <EnterpriseLicenseStatus
-          status={licenseState.status as "active" | "expired" | "unreachable" | "invalid_license"}
-          gracePeriodEnd={
-            licenseState.status === "unreachable"
-              ? new Date(licenseState.lastChecked.getTime() + GRACE_PERIOD_MS)
-              : undefined
-          }
-          environmentId={params.environmentId}
-        />
+      {isEnterpriseEdition ? (
+        <div>
+          <div className="mt-8 max-w-4xl rounded-lg border border-slate-300 bg-slate-100 shadow-sm">
+            <div className="space-y-4 p-8">
+              <div className="flex items-center gap-x-2">
+                <div className="rounded-full border border-green-300 bg-green-100 p-0.5 dark:bg-green-800">
+                  <CheckIcon className="h-5 w-5 p-0.5 text-green-500 dark:text-green-400" />
+                </div>
+                <p className="text-slate-800">
+                  {t(
+                    "environments.settings.enterprise.your_enterprise_license_is_active_all_features_unlocked"
+                  )}
+                </p>
+              </div>
+              <p className="text-sm text-slate-500">
+                {t("environments.settings.enterprise.questions_please_reach_out_to")}{" "}
+                <a className="font-semibold underline" href="mailto:hola@formbricks.com">
+                  hola@formbricks.com
+                </a>
+              </p>
+            </div>
+          </div>
+        </div>
       ) : (
         <div>
           <div className="relative isolate mt-8 overflow-hidden rounded-lg bg-slate-900 px-3 pt-8 shadow-2xl sm:px-8 md:pt-12 lg:flex lg:gap-x-10 lg:px-12 lg:pt-0">
             <svg
               viewBox="0 0 1024 1024"
-              className="absolute left-1/2 top-1/2 -z-10 h-[64rem] w-[64rem] -translate-y-1/2 [mask-image:radial-gradient(closest-side,white,transparent)] sm:left-full sm:-ml-80 lg:left-1/2 lg:ml-0 lg:-translate-x-1/2 lg:translate-y-0"
+              className="absolute top-1/2 left-1/2 -z-10 h-[64rem] w-[64rem] -translate-y-1/2 [mask-image:radial-gradient(closest-side,white,transparent)] sm:left-full sm:-ml-80 lg:left-1/2 lg:ml-0 lg:-translate-x-1/2 lg:translate-y-0"
               aria-hidden="true">
               <circle
                 cx={512}
@@ -142,8 +153,8 @@ const Page = async (props) => {
                 {t("environments.settings.enterprise.enterprise_features")}
               </h2>
               <ul className="my-4 space-y-4">
-                {paidFeatures.map((feature) => (
-                  <li key={feature.title} className="flex items-center">
+                {paidFeatures.map((feature, index) => (
+                  <li key={index} className="flex items-center">
                     <div className="rounded-full border border-green-300 bg-green-100 p-0.5 dark:bg-green-800">
                       <CheckIcon className="h-5 w-5 p-0.5 text-green-500 dark:text-green-400" />
                     </div>

apps/web/app/(app)/environments/[environmentId]/settings/(organization)/general/components/DeleteOrganization.tsx

@@ -7,7 +7,6 @@ import { useTranslation } from "react-i18next";
 import { TOrganization } from "@formbricks/types/organizations";
 import { deleteOrganizationAction } from "@/app/(app)/environments/[environmentId]/settings/(organization)/general/actions";
 import { FORMBRICKS_ENVIRONMENT_ID_LS } from "@/lib/localStorage";
-import { getFormattedErrorMessage } from "@/lib/utils/helper";
 import { Alert, AlertDescription } from "@/modules/ui/components/alert";
 import { Button } from "@/modules/ui/components/button";
 import { DeleteDialog } from "@/modules/ui/components/delete-dialog";
@@ -33,12 +32,7 @@ export const DeleteOrganization = ({
     setIsDeleting(true);
 
     try {
-      const result = await deleteOrganizationAction({ organizationId: organization.id });
-      if (result?.serverError) {
-        toast.error(getFormattedErrorMessage(result));
-        setIsDeleting(false);
-        return;
-      }
+      await deleteOrganizationAction({ organizationId: organization.id });
       toast.success(t("environments.settings.general.organization_deleted_successfully"));
       if (typeof localStorage !== "undefined") {
         localStorage.removeItem(FORMBRICKS_ENVIRONMENT_ID_LS);

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/responses/components/ResponseTableColumns.tsx

@@ -316,14 +316,6 @@ export const generateResponseTableColumns = (
     },
   };
 
-  const responseIdColumn: ColumnDef<TResponseTableData> = {
-    accessorKey: "responseId",
-    header: () => <div className="gap-x-1.5">{t("common.response_id")}</div>,
-    cell: ({ row }) => {
-      return <IdBadge id={row.original.responseId} />;
-    },
-  };
-
   const quotasColumn: ColumnDef<TResponseTableData> = {
     accessorKey: "quota",
     header: t("common.quota"),
@@ -422,7 +414,6 @@ export const generateResponseTableColumns = (
   const baseColumns = [
     personColumn,
     singleUseIdColumn,
-    responseIdColumn,
     dateColumn,
     ...(showQuotasColumn ? [quotasColumn] : []),
     statusColumn,

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/actions.ts

@@ -58,7 +58,6 @@ export const sendEmbedSurveyPreviewEmailAction = authenticatedActionClient
       ctx.user.email,
       emailHtml,
       survey.environmentId,
-      ctx.user.locale,
       organizationLogoUrl || ""
     );
   });

apps/web/app/(app)/environments/[environmentId]/surveys/[surveyId]/(analysis)/summary/components/FileUploadSummary.tsx

@@ -8,7 +8,7 @@ import { TSurvey, TSurveyElementSummaryFileUpload } from "@formbricks/types/surv
 import { TUserLocale } from "@formbricks/types/user";
 import { timeSince } from "@/lib/time";
 import { getContactIdentifier } from "@/lib/utils/contact";
-import { getOriginalFileNameFromUrl } from "@/modules/storage/url-helpers";
+import { getOriginalFileNameFromUrl } from "@/modules/storage/utils";
 import { PersonAvatar } from "@/modules/ui/components/avatars";
 import { Button } from "@/modules/ui/components/button";
 import { EmptyState } from "@/modules/ui/components/empty-state";

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/airtable/components/AddIntegrationModal.tsx

@@ -21,7 +21,6 @@ import { createOrUpdateIntegrationAction } from "@/app/(app)/environments/[envir
 import { BaseSelectDropdown } from "@/app/(app)/environments/[environmentId]/workspace/integrations/airtable/components/BaseSelectDropdown";
 import { fetchTables } from "@/app/(app)/environments/[environmentId]/workspace/integrations/airtable/lib/airtable";
 import AirtableLogo from "@/images/airtableLogo.svg";
-import { getFormattedErrorMessage } from "@/lib/utils/helper";
 import { recallToHeadline } from "@/lib/utils/recall";
 import { getElementsFromBlocks } from "@/modules/survey/lib/client-utils";
 import { AdditionalIntegrationSettings } from "@/modules/ui/components/additional-integration-settings";
@@ -269,14 +268,7 @@ export const AddIntegrationModal = ({
         airtableIntegrationData.config?.data.push(integrationData);
       }
 
-      const result = await createOrUpdateIntegrationAction({
-        environmentId,
-        integrationData: airtableIntegrationData,
-      });
-      if (result?.serverError) {
-        toast.error(getFormattedErrorMessage(result));
-        return;
-      }
+      await createOrUpdateIntegrationAction({ environmentId, integrationData: airtableIntegrationData });
       if (isEditMode) {
         toast.success(t("environments.integrations.integration_updated_successfully"));
       } else {
@@ -312,11 +304,7 @@ export const AddIntegrationModal = ({
       const integrationData = structuredClone(airtableIntegrationData);
       integrationData.config.data.splice(index, 1);
 
-      const result = await createOrUpdateIntegrationAction({ environmentId, integrationData });
-      if (result?.serverError) {
-        toast.error(getFormattedErrorMessage(result));
-        return;
-      }
+      await createOrUpdateIntegrationAction({ environmentId, integrationData });
       handleClose();
       router.refresh();
 

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/google-sheets/components/AddIntegrationModal.tsx

@@ -165,14 +165,7 @@ export const AddIntegrationModal = ({
         // create action
         googleSheetIntegrationData.config.data.push(integrationData);
       }
-      const result = await createOrUpdateIntegrationAction({
-        environmentId,
-        integrationData: googleSheetIntegrationData,
-      });
-      if (result?.serverError) {
-        toast.error(getFormattedErrorMessage(result));
-        return;
-      }
+      await createOrUpdateIntegrationAction({ environmentId, integrationData: googleSheetIntegrationData });
       if (selectedIntegration) {
         toast.success(t("environments.integrations.integration_updated_successfully"));
       } else {
@@ -212,14 +205,7 @@ export const AddIntegrationModal = ({
     googleSheetIntegrationData.config.data.splice(selectedIntegration!.index, 1);
     try {
       setIsDeleting(true);
-      const result = await createOrUpdateIntegrationAction({
-        environmentId,
-        integrationData: googleSheetIntegrationData,
-      });
-      if (result?.serverError) {
-        toast.error(getFormattedErrorMessage(result));
-        return;
-      }
+      await createOrUpdateIntegrationAction({ environmentId, integrationData: googleSheetIntegrationData });
       toast.success(t("environments.integrations.integration_removed_successfully"));
       setOpen(false);
     } catch (error) {

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/notion/components/AddIntegrationModal.tsx

@@ -22,7 +22,6 @@ import {
   createEmptyMapping,
 } from "@/app/(app)/environments/[environmentId]/workspace/integrations/notion/components/MappingRow";
 import NotionLogo from "@/images/notion.png";
-import { getFormattedErrorMessage } from "@/lib/utils/helper";
 import { recallToHeadline } from "@/lib/utils/recall";
 import { getElementsFromBlocks } from "@/modules/survey/lib/client-utils";
 import { Button } from "@/modules/ui/components/button";
@@ -218,14 +217,7 @@ export const AddIntegrationModal = ({
         notionIntegrationData.config.data.push(integrationData);
       }
 
-      const result = await createOrUpdateIntegrationAction({
-        environmentId,
-        integrationData: notionIntegrationData,
-      });
-      if (result?.serverError) {
-        toast.error(getFormattedErrorMessage(result));
-        return;
-      }
+      await createOrUpdateIntegrationAction({ environmentId, integrationData: notionIntegrationData });
       if (selectedIntegration) {
         toast.success(t("environments.integrations.integration_updated_successfully"));
       } else {
@@ -244,14 +236,7 @@ export const AddIntegrationModal = ({
     notionIntegrationData.config.data.splice(selectedIntegration!.index, 1);
     try {
       setIsDeleting(true);
-      const result = await createOrUpdateIntegrationAction({
-        environmentId,
-        integrationData: notionIntegrationData,
-      });
-      if (result?.serverError) {
-        toast.error(getFormattedErrorMessage(result));
-        return;
-      }
+      await createOrUpdateIntegrationAction({ environmentId, integrationData: notionIntegrationData });
       toast.success(t("environments.integrations.integration_removed_successfully"));
       setOpen(false);
     } catch (error) {

apps/web/app/(app)/environments/[environmentId]/workspace/integrations/slack/components/AddChannelMappingModal.tsx

@@ -17,7 +17,6 @@ import { TSurvey } from "@formbricks/types/surveys/types";
 import { getTextContent } from "@formbricks/types/surveys/validation";
 import { createOrUpdateIntegrationAction } from "@/app/(app)/environments/[environmentId]/workspace/integrations/actions";
 import SlackLogo from "@/images/slacklogo.png";
-import { getFormattedErrorMessage } from "@/lib/utils/helper";
 import { recallToHeadline } from "@/lib/utils/recall";
 import { getElementsFromBlocks } from "@/modules/survey/lib/client-utils";
 import { AdditionalIntegrationSettings } from "@/modules/ui/components/additional-integration-settings";
@@ -145,14 +144,7 @@ export const AddChannelMappingModal = ({
         // create action
         slackIntegrationData.config.data.push(integrationData);
       }
-      const result = await createOrUpdateIntegrationAction({
-        environmentId,
-        integrationData: slackIntegrationData,
-      });
-      if (result?.serverError) {
-        toast.error(getFormattedErrorMessage(result));
-        return;
-      }
+      await createOrUpdateIntegrationAction({ environmentId, integrationData: slackIntegrationData });
       if (selectedIntegration) {
         toast.success(t("environments.integrations.integration_updated_successfully"));
       } else {
@@ -189,14 +181,7 @@ export const AddChannelMappingModal = ({
     slackIntegrationData.config.data.splice(selectedIntegration!.index, 1);
     try {
       setIsDeleting(true);
-      const result = await createOrUpdateIntegrationAction({
-        environmentId,
-        integrationData: slackIntegrationData,
-      });
-      if (result?.serverError) {
-        toast.error(getFormattedErrorMessage(result));
-        return;
-      }
+      await createOrUpdateIntegrationAction({ environmentId, integrationData: slackIntegrationData });
       toast.success(t("environments.integrations.integration_removed_successfully"));
       setOpen(false);
     } catch (error) {

apps/web/app/api/(internal)/pipeline/lib/handleIntegrations.ts

@@ -21,7 +21,6 @@ import { getElementsFromBlocks } from "@/lib/survey/utils";
 import { getFormattedDateTimeString } from "@/lib/utils/datetime";
 import { parseRecallInfo } from "@/lib/utils/recall";
 import { truncateText } from "@/lib/utils/strings";
-import { resolveStorageUrlAuto } from "@/modules/storage/utils";
 
 const convertMetaObjectToString = (metadata: TResponseMeta): string => {
   let result: string[] = [];
@@ -257,16 +256,10 @@ const processElementResponse = (
     const selectedChoiceIds = responseValue as string[];
     return element.choices
       .filter((choice) => selectedChoiceIds.includes(choice.id))
-      .map((choice) => resolveStorageUrlAuto(choice.imageUrl))
+      .map((choice) => choice.imageUrl)
       .join("\n");
   }
 
-  if (element.type === TSurveyElementTypeEnum.FileUpload && Array.isArray(responseValue)) {
-    return responseValue
-      .map((url) => (typeof url === "string" ? resolveStorageUrlAuto(url) : url))
-      .join("; ");
-  }
-
   return processResponseData(responseValue);
 };
 
@@ -375,7 +368,7 @@ const buildNotionPayloadProperties = (
 
       responses[resp] = (pictureElement as any)?.choices
         .filter((choice) => selectedChoiceIds.includes(choice.id))
-        .map((choice) => resolveStorageUrlAuto(choice.imageUrl));
+        .map((choice) => choice.imageUrl);
     }
   });
 

apps/web/app/api/(internal)/pipeline/route.ts

@@ -18,7 +18,6 @@ import { convertDatesInObject } from "@/lib/time";
 import { queueAuditEvent } from "@/modules/ee/audit-logs/lib/handler";
 import { TAuditStatus, UNKNOWN_DATA } from "@/modules/ee/audit-logs/types/audit-log";
 import { sendResponseFinishedEmail } from "@/modules/email";
-import { resolveStorageUrlsInObject } from "@/modules/storage/utils";
 import { sendFollowUpsForResponse } from "@/modules/survey/follow-ups/lib/follow-ups";
 import { FollowUpSendError } from "@/modules/survey/follow-ups/types/follow-up";
 import { handleIntegrations } from "./lib/handleIntegrations";
@@ -31,10 +30,7 @@ export const POST = async (request: Request) => {
   }
 
   const jsonInput = await request.json();
-  const convertedJsonInput = convertDatesInObject(
-    jsonInput,
-    new Set(["contactAttributes", "variables", "data", "meta"])
-  );
+  const convertedJsonInput = convertDatesInObject(jsonInput);
 
   const inputValidation = ZPipelineInput.safeParse(convertedJsonInput);
 
@@ -96,15 +92,12 @@ export const POST = async (request: Request) => {
     ]);
   };
 
-  const resolvedResponseData = resolveStorageUrlsInObject(response.data);
-
   const webhookPromises = webhooks.map((webhook) => {
     const body = JSON.stringify({
       webhookId: webhook.id,
       event,
       data: {
         ...response,
-        data: resolvedResponseData,
         survey: {
           title: survey.name,
           type: survey.type,
@@ -222,14 +215,7 @@ export const POST = async (request: Request) => {
     }
 
     const emailPromises = usersWithNotifications.map((user) =>
-      sendResponseFinishedEmail(
-        user.email,
-        user.locale,
-        environmentId,
-        survey,
-        response,
-        responseCount
-      ).catch((error) => {
+      sendResponseFinishedEmail(user.email, environmentId, survey, response, responseCount).catch((error) => {
         logger.error(
           { error, url: request.url, userEmail: user.email },
           `Failed to send email to ${user.email}`

apps/web/app/api/google-sheet/callback/route.ts

@@ -1,5 +1,4 @@
 import { google } from "googleapis";
-import { getServerSession } from "next-auth";
 import { responses } from "@/app/lib/api/response";
 import {
   GOOGLE_SHEETS_CLIENT_ID,
@@ -7,29 +6,18 @@ import {
   GOOGLE_SHEETS_REDIRECT_URL,
   WEBAPP_URL,
 } from "@/lib/constants";
-import { hasUserEnvironmentAccess } from "@/lib/environment/auth";
 import { createOrUpdateIntegration } from "@/lib/integration/service";
-import { authOptions } from "@/modules/auth/lib/authOptions";
 
 export const GET = async (req: Request) => {
-  const url = new URL(req.url);
-  const environmentId = url.searchParams.get("state");
-  const code = url.searchParams.get("code");
+  const url = req.url;
+  const queryParams = new URLSearchParams(url.split("?")[1]); // Split the URL and get the query parameters
+  const environmentId = queryParams.get("state"); // Get the value of the 'state' parameter
+  const code = queryParams.get("code");
 
   if (!environmentId) {
     return responses.badRequestResponse("Invalid environmentId");
   }
 
-  const session = await getServerSession(authOptions);
-  if (!session) {
-    return responses.notAuthenticatedResponse();
-  }
-
-  const canUserAccessEnvironment = await hasUserEnvironmentAccess(session.user.id, environmentId);
-  if (!canUserAccessEnvironment) {
-    return responses.unauthorizedResponse();
-  }
-
   if (code && typeof code !== "string") {
     return responses.badRequestResponse("`code` must be a string");
   }

apps/web/app/api/v1/client/[environmentId]/app/sync/[userId]/route.ts

@@ -0,0 +1,180 @@
+// Deprecated: This api route is deprecated now and will be removed in the future.
+// Deprecated: This is currently only being used for the older react native SDKs. Please upgrade to the latest SDKs.
+import { NextRequest, userAgent } from "next/server";
+import { prisma } from "@formbricks/database";
+import { logger } from "@formbricks/logger";
+import { TJsPeopleUserIdInput, ZJsPeopleUserIdInput } from "@formbricks/types/js";
+import { TSurvey } from "@formbricks/types/surveys/types";
+import { getContactByUserId } from "@/app/api/v1/client/[environmentId]/app/sync/lib/contact";
+import { getSyncSurveys } from "@/app/api/v1/client/[environmentId]/app/sync/lib/survey";
+import { replaceAttributeRecall } from "@/app/api/v1/client/[environmentId]/app/sync/lib/utils";
+import { responses } from "@/app/lib/api/response";
+import { transformErrorToDetails } from "@/app/lib/api/validator";
+import { withV1ApiWrapper } from "@/app/lib/api/with-api-logging";
+import { getActionClasses } from "@/lib/actionClass/service";
+import { IS_FORMBRICKS_CLOUD } from "@/lib/constants";
+import { getEnvironment, updateEnvironment } from "@/lib/environment/service";
+import {
+  getMonthlyOrganizationResponseCount,
+  getOrganizationByEnvironmentId,
+} from "@/lib/organization/service";
+import { getProjectByEnvironmentId } from "@/lib/project/service";
+import { COLOR_DEFAULTS } from "@/lib/styling/constants";
+
+const validateInput = (
+  environmentId: string,
+  userId: string
+): { isValid: true; data: TJsPeopleUserIdInput } | { isValid: false; error: Response } => {
+  const inputValidation = ZJsPeopleUserIdInput.safeParse({ environmentId, userId });
+  if (!inputValidation.success) {
+    return {
+      isValid: false,
+      error: responses.badRequestResponse(
+        "Fields are missing or incorrectly formatted",
+        transformErrorToDetails(inputValidation.error),
+        true
+      ),
+    };
+  }
+  return { isValid: true, data: inputValidation.data };
+};
+
+const checkResponseLimit = async (environmentId: string): Promise<boolean> => {
+  if (!IS_FORMBRICKS_CLOUD) return false;
+
+  const organization = await getOrganizationByEnvironmentId(environmentId);
+  if (!organization) {
+    logger.error({ environmentId }, "Organization does not exist");
+
+    // fail closed if the organization does not exist
+    return true;
+  }
+
+  const currentResponseCount = await getMonthlyOrganizationResponseCount(organization.id);
+  const monthlyResponseLimit = organization.billing.limits.monthly.responses;
+  const isLimitReached = monthlyResponseLimit !== null && currentResponseCount >= monthlyResponseLimit;
+
+  return isLimitReached;
+};
+
+export const OPTIONS = async (): Promise<Response> => {
+  return responses.successResponse({}, true);
+};
+
+export const GET = withV1ApiWrapper({
+  handler: async ({
+    req,
+    props,
+  }: {
+    req: NextRequest;
+    props: { params: Promise<{ environmentId: string; userId: string }> };
+  }) => {
+    const params = await props.params;
+    try {
+      const { device } = userAgent(req);
+
+      // validate using zod
+      const validation = validateInput(params.environmentId, params.userId);
+      if (!validation.isValid) {
+        return { response: validation.error };
+      }
+
+      const { environmentId, userId } = validation.data;
+
+      const environment = await getEnvironment(environmentId);
+      if (!environment) {
+        throw new Error("Environment does not exist");
+      }
+
+      const project = await getProjectByEnvironmentId(environmentId);
+
+      if (!project) {
+        throw new Error("Project not found");
+      }
+
+      if (!environment.appSetupCompleted) {
+        await updateEnvironment(environment.id, { appSetupCompleted: true });
+      }
+
+      // check organization subscriptions and response limits
+      const isAppSurveyResponseLimitReached = await checkResponseLimit(environmentId);
+
+      let contact = await getContactByUserId(environmentId, userId);
+      if (!contact) {
+        contact = await prisma.contact.create({
+          data: {
+            attributes: {
+              create: {
+                attributeKey: {
+                  connect: {
+                    key_environmentId: {
+                      key: "userId",
+                      environmentId,
+                    },
+                  },
+                },
+                value: userId,
+              },
+            },
+            environment: { connect: { id: environmentId } },
+          },
+          select: {
+            id: true,
+            attributes: { select: { attributeKey: { select: { key: true } }, value: true } },
+          },
+        });
+      }
+
+      const contactAttributes = contact.attributes.reduce((acc, attribute) => {
+        acc[attribute.attributeKey.key] = attribute.value;
+        return acc;
+      }, {}) as Record<string, string>;
+
+      const [surveys, actionClasses] = await Promise.all([
+        getSyncSurveys(
+          environmentId,
+          contact.id,
+          contactAttributes,
+          device.type === "mobile" ? "phone" : "desktop"
+        ),
+        getActionClasses(environmentId),
+      ]);
+
+      const updatedProject: any = {
+        ...project,
+        brandColor: project.styling.brandColor?.light ?? COLOR_DEFAULTS.brandColor,
+        ...(project.styling.highlightBorderColor?.light && {
+          highlightBorderColor: project.styling.highlightBorderColor.light,
+        }),
+      };
+
+      const language = contactAttributes["language"];
+
+      // Scenario 1: Multi language and updated trigger action classes supported.
+      // Use the surveys as they are.
+      let transformedSurveys: TSurvey[] = surveys;
+
+      // creating state object
+      let state = {
+        surveys: !isAppSurveyResponseLimitReached
+          ? transformedSurveys.map((survey) => replaceAttributeRecall(survey, contactAttributes))
+          : [],
+        actionClasses,
+        language,
+        project: updatedProject,
+      };
+
+      return {
+        response: responses.successResponse({ ...state }, true),
+      };
+    } catch (error) {
+      logger.error({ error, url: req.url }, "Error in GET /api/v1/client/[environmentId]/app/sync/[userId]");
+      return {
+        response: responses.internalServerErrorResponse(
+          "Unable to handle the request: " + error.message,
+          true
+        ),
+      };
+    }
+  },
+});

apps/web/app/api/v1/client/[environmentId]/app/sync/lib/contact.test.ts

@@ -0,0 +1,83 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { prisma } from "@formbricks/database";
+import { TContact } from "@/modules/ee/contacts/types/contact";
+import { getContactByUserId } from "./contact";
+
+// Mock prisma
+vi.mock("@formbricks/database", () => ({
+  prisma: {
+    contact: {
+      findFirst: vi.fn(),
+    },
+  },
+}));
+
+const environmentId = "test-environment-id";
+const userId = "test-user-id";
+const contactId = "test-contact-id";
+
+const contactMock: Partial<TContact> & {
+  attributes: { value: string; attributeKey: { key: string } }[];
+} = {
+  id: contactId,
+  attributes: [
+    { attributeKey: { key: "userId" }, value: userId },
+    { attributeKey: { key: "email" }, value: "test@example.com" },
+  ],
+};
+
+describe("getContactByUserId", () => {
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  test("should return contact if found", async () => {
+    vi.mocked(prisma.contact.findFirst).mockResolvedValue(contactMock as any);
+
+    const contact = await getContactByUserId(environmentId, userId);
+
+    expect(prisma.contact.findFirst).toHaveBeenCalledWith({
+      where: {
+        attributes: {
+          some: {
+            attributeKey: {
+              key: "userId",
+              environmentId,
+            },
+            value: userId,
+          },
+        },
+      },
+      select: {
+        id: true,
+        attributes: { select: { attributeKey: { select: { key: true } }, value: true } },
+      },
+    });
+    expect(contact).toEqual(contactMock);
+  });
+
+  test("should return null if contact not found", async () => {
+    vi.mocked(prisma.contact.findFirst).mockResolvedValue(null);
+
+    const contact = await getContactByUserId(environmentId, userId);
+
+    expect(prisma.contact.findFirst).toHaveBeenCalledWith({
+      where: {
+        attributes: {
+          some: {
+            attributeKey: {
+              key: "userId",
+              environmentId,
+            },
+            value: userId,
+          },
+        },
+      },
+      select: {
+        id: true,
+        attributes: { select: { attributeKey: { select: { key: true } }, value: true } },
+      },
+    });
+    expect(contact).toBeNull();
+  });
+});

apps/web/app/api/v1/client/[environmentId]/app/sync/lib/contact.ts

@@ -0,0 +1,42 @@
+import "server-only";
+import { cache as reactCache } from "react";
+import { prisma } from "@formbricks/database";
+
+export const getContactByUserId = reactCache(
+  async (
+    environmentId: string,
+    userId: string
+  ): Promise<{
+    attributes: {
+      value: string;
+      attributeKey: {
+        key: string;
+      };
+    }[];
+    id: string;
+  } | null> => {
+    const contact = await prisma.contact.findFirst({
+      where: {
+        attributes: {
+          some: {
+            attributeKey: {
+              key: "userId",
+              environmentId,
+            },
+            value: userId,
+          },
+        },
+      },
+      select: {
+        id: true,
+        attributes: { select: { attributeKey: { select: { key: true } }, value: true } },
+      },
+    });
+
+    if (!contact) {
+      return null;
+    }
+
+    return contact;
+  }
+);

apps/web/app/api/v1/client/[environmentId]/app/sync/lib/survey.test.ts

@@ -0,0 +1,323 @@
+import { Prisma } from "@prisma/client";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { prisma } from "@formbricks/database";
+import { logger } from "@formbricks/logger";
+import { DatabaseError } from "@formbricks/types/errors";
+import { TProject } from "@formbricks/types/project";
+import { TSegment } from "@formbricks/types/segment";
+import { TSurvey } from "@formbricks/types/surveys/types";
+import { getProjectByEnvironmentId } from "@/lib/project/service";
+import { getSurveys } from "@/lib/survey/service";
+import { anySurveyHasFilters } from "@/lib/survey/utils";
+import { diffInDays } from "@/lib/utils/datetime";
+import { evaluateSegment } from "@/modules/ee/contacts/segments/lib/segments";
+import { getSyncSurveys } from "./survey";
+
+vi.mock("@/lib/project/service", () => ({
+  getProjectByEnvironmentId: vi.fn(),
+}));
+vi.mock("@/lib/survey/service", () => ({
+  getSurveys: vi.fn(),
+}));
+vi.mock("@/lib/survey/utils", () => ({
+  anySurveyHasFilters: vi.fn(),
+}));
+vi.mock("@/lib/utils/datetime", () => ({
+  diffInDays: vi.fn(),
+}));
+vi.mock("@/lib/utils/validate", () => ({
+  validateInputs: vi.fn(),
+}));
+vi.mock("@/modules/ee/contacts/segments/lib/segments", () => ({
+  evaluateSegment: vi.fn(),
+}));
+vi.mock("@formbricks/database", () => ({
+  prisma: {
+    display: {
+      findMany: vi.fn(),
+    },
+    response: {
+      findMany: vi.fn(),
+    },
+  },
+}));
+vi.mock("@formbricks/logger", () => ({
+  logger: {
+    error: vi.fn(),
+  },
+}));
+
+const environmentId = "test-env-id";
+const contactId = "test-contact-id";
+const contactAttributes = { userId: "user1", email: "test@example.com" };
+const deviceType = "desktop";
+
+const mockProject = {
+  id: "proj1",
+  name: "Test Project",
+  createdAt: new Date(),
+  updatedAt: new Date(),
+  organizationId: "org1",
+  environments: [],
+  recontactDays: 10,
+  inAppSurveyBranding: true,
+  linkSurveyBranding: true,
+  placement: "bottomRight",
+  clickOutsideClose: true,
+  darkOverlay: false,
+  languages: [],
+} as unknown as TProject;
+
+const baseSurvey: TSurvey = {
+  id: "survey1",
+  createdAt: new Date(),
+  updatedAt: new Date(),
+  name: "Test Survey 1",
+  environmentId: environmentId,
+  type: "app",
+  status: "inProgress",
+  questions: [],
+  displayOption: "displayOnce",
+  recontactDays: null,
+  autoClose: null,
+  delay: 0,
+  displayPercentage: null,
+  autoComplete: null,
+  segment: null,
+  surveyClosedMessage: null,
+  singleUse: null,
+  styling: null,
+  pin: null,
+  displayLimit: null,
+  welcomeCard: { enabled: false } as TSurvey["welcomeCard"],
+  endings: [],
+  triggers: [],
+  languages: [],
+  variables: [],
+  hiddenFields: { enabled: false },
+  createdBy: null,
+  isSingleResponsePerEmailEnabled: false,
+  isVerifyEmailEnabled: false,
+  projectOverwrites: null,
+  showLanguageSwitch: false,
+  isBackButtonHidden: false,
+  followUps: [],
+  recaptcha: { enabled: false, threshold: 0.5 },
+};
+
+// Helper function to create mock display objects
+const createMockDisplay = (id: string, surveyId: string, contactId: string, createdAt?: Date) => ({
+  id,
+  createdAt: createdAt || new Date(),
+  updatedAt: new Date(),
+  surveyId,
+  contactId,
+  responseId: null,
+  status: null,
+});
+
+// Helper function to create mock response objects
+const createMockResponse = (id: string, surveyId: string, contactId: string, createdAt?: Date) => ({
+  id,
+  createdAt: createdAt || new Date(),
+  updatedAt: new Date(),
+  finished: false,
+  surveyId,
+  contactId,
+  endingId: null,
+  data: {},
+  variables: {},
+  ttc: {},
+  meta: {},
+  contactAttributes: null,
+  singleUseId: null,
+  language: null,
+  displayId: null,
+});
+
+describe("getSyncSurveys", () => {
+  beforeEach(() => {
+    vi.mocked(getProjectByEnvironmentId).mockResolvedValue(mockProject);
+    vi.mocked(prisma.display.findMany).mockResolvedValue([]);
+    vi.mocked(prisma.response.findMany).mockResolvedValue([]);
+    vi.mocked(anySurveyHasFilters).mockReturnValue(false);
+    vi.mocked(evaluateSegment).mockResolvedValue(true);
+    vi.mocked(diffInDays).mockReturnValue(100); // Assume enough days passed
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  test("should throw error if product not found", async () => {
+    vi.mocked(getProjectByEnvironmentId).mockResolvedValue(null);
+    await expect(getSyncSurveys(environmentId, contactId, contactAttributes, deviceType)).rejects.toThrow(
+      "Project not found"
+    );
+  });
+
+  test("should return empty array if no surveys found", async () => {
+    vi.mocked(getSurveys).mockResolvedValue([]);
+    const result = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result).toEqual([]);
+  });
+
+  test("should return empty array if no 'app' type surveys in progress", async () => {
+    const surveys: TSurvey[] = [
+      { ...baseSurvey, id: "s1", type: "link", status: "inProgress" },
+      { ...baseSurvey, id: "s2", type: "app", status: "paused" },
+    ];
+    vi.mocked(getSurveys).mockResolvedValue(surveys);
+    const result = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result).toEqual([]);
+  });
+
+  test("should filter by displayOption 'displayOnce'", async () => {
+    const surveys: TSurvey[] = [{ ...baseSurvey, id: "s1", displayOption: "displayOnce" }];
+    vi.mocked(getSurveys).mockResolvedValue(surveys);
+    vi.mocked(prisma.display.findMany).mockResolvedValue([createMockDisplay("d1", "s1", contactId)]); // Already displayed
+
+    const result = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result).toEqual([]);
+
+    vi.mocked(prisma.display.findMany).mockResolvedValue([]); // Not displayed yet
+    const result2 = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result2).toEqual(surveys);
+  });
+
+  test("should filter by displayOption 'displayMultiple'", async () => {
+    const surveys: TSurvey[] = [{ ...baseSurvey, id: "s1", displayOption: "displayMultiple" }];
+    vi.mocked(getSurveys).mockResolvedValue(surveys);
+    vi.mocked(prisma.response.findMany).mockResolvedValue([createMockResponse("r1", "s1", contactId)]); // Already responded
+
+    const result = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result).toEqual([]);
+
+    vi.mocked(prisma.response.findMany).mockResolvedValue([]); // Not responded yet
+    const result2 = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result2).toEqual(surveys);
+  });
+
+  test("should filter by displayOption 'displaySome'", async () => {
+    const surveys: TSurvey[] = [{ ...baseSurvey, id: "s1", displayOption: "displaySome", displayLimit: 2 }];
+    vi.mocked(getSurveys).mockResolvedValue(surveys);
+    vi.mocked(prisma.display.findMany).mockResolvedValue([
+      createMockDisplay("d1", "s1", contactId),
+      createMockDisplay("d2", "s1", contactId),
+    ]); // Display limit reached
+
+    const result = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result).toEqual([]);
+
+    vi.mocked(prisma.display.findMany).mockResolvedValue([createMockDisplay("d1", "s1", contactId)]); // Within limit
+    const result2 = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result2).toEqual(surveys);
+
+    // Test with response already submitted
+    vi.mocked(prisma.response.findMany).mockResolvedValue([createMockResponse("r1", "s1", contactId)]);
+    const result3 = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result3).toEqual([]);
+  });
+
+  test("should not filter by displayOption 'respondMultiple'", async () => {
+    const surveys: TSurvey[] = [{ ...baseSurvey, id: "s1", displayOption: "respondMultiple" }];
+    vi.mocked(getSurveys).mockResolvedValue(surveys);
+    vi.mocked(prisma.display.findMany).mockResolvedValue([createMockDisplay("d1", "s1", contactId)]);
+    vi.mocked(prisma.response.findMany).mockResolvedValue([createMockResponse("r1", "s1", contactId)]);
+
+    const result = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result).toEqual(surveys);
+  });
+
+  test("should filter by product recontactDays if survey recontactDays is null", async () => {
+    const surveys: TSurvey[] = [{ ...baseSurvey, id: "s1", recontactDays: null }];
+    vi.mocked(getSurveys).mockResolvedValue(surveys);
+    const displayDate = new Date();
+    vi.mocked(prisma.display.findMany).mockResolvedValue([
+      createMockDisplay("d1", "s2", contactId, displayDate), // Display for another survey
+    ]);
+
+    vi.mocked(diffInDays).mockReturnValue(5); // Not enough days passed (product.recontactDays = 10)
+    const result = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result).toEqual([]);
+    expect(diffInDays).toHaveBeenCalledWith(expect.any(Date), displayDate);
+
+    vi.mocked(diffInDays).mockReturnValue(15); // Enough days passed
+    const result2 = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result2).toEqual(surveys);
+  });
+
+  test("should return surveys if no segment filters exist", async () => {
+    const surveys: TSurvey[] = [{ ...baseSurvey, id: "s1" }];
+    vi.mocked(getSurveys).mockResolvedValue(surveys);
+    vi.mocked(anySurveyHasFilters).mockReturnValue(false);
+
+    const result = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result).toEqual(surveys);
+    expect(evaluateSegment).not.toHaveBeenCalled();
+  });
+
+  test("should evaluate segment filters if they exist", async () => {
+    const segment = { id: "seg1", filters: [{}] } as TSegment; // Mock filter structure
+    const surveys: TSurvey[] = [{ ...baseSurvey, id: "s1", segment }];
+    vi.mocked(getSurveys).mockResolvedValue(surveys);
+    vi.mocked(anySurveyHasFilters).mockReturnValue(true);
+
+    // Case 1: Segment evaluation matches
+    vi.mocked(evaluateSegment).mockResolvedValue(true);
+    const result1 = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result1).toEqual(surveys);
+    expect(evaluateSegment).toHaveBeenCalledWith(
+      {
+        attributes: contactAttributes,
+        deviceType,
+        environmentId,
+        contactId,
+        userId: contactAttributes.userId,
+      },
+      segment.filters
+    );
+
+    // Case 2: Segment evaluation does not match
+    vi.mocked(evaluateSegment).mockResolvedValue(false);
+    const result2 = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result2).toEqual([]);
+  });
+
+  test("should handle Prisma errors", async () => {
+    const prismaError = new Prisma.PrismaClientKnownRequestError("Test Prisma Error", {
+      code: "P2025",
+      clientVersion: "test",
+    });
+    vi.mocked(getSurveys).mockRejectedValue(prismaError);
+
+    await expect(getSyncSurveys(environmentId, contactId, contactAttributes, deviceType)).rejects.toThrow(
+      DatabaseError
+    );
+    expect(logger.error).toHaveBeenCalledWith(prismaError);
+  });
+
+  test("should handle general errors", async () => {
+    const generalError = new Error("Something went wrong");
+    vi.mocked(getSurveys).mockRejectedValue(generalError);
+
+    await expect(getSyncSurveys(environmentId, contactId, contactAttributes, deviceType)).rejects.toThrow(
+      generalError
+    );
+  });
+
+  test("should throw ResourceNotFoundError if resolved surveys are null after filtering", async () => {
+    const segment = { id: "seg1", filters: [{}] } as TSegment; // Mock filter structure
+    const surveys: TSurvey[] = [{ ...baseSurvey, id: "s1", segment }];
+    vi.mocked(getSurveys).mockResolvedValue(surveys);
+    vi.mocked(anySurveyHasFilters).mockReturnValue(true);
+    vi.mocked(evaluateSegment).mockResolvedValue(false); // Ensure all surveys are filtered out
+
+    // This scenario is tricky to force directly as the code checks `if (!surveys)` before returning.
+    // However, if `Promise.all` somehow resolved to null/undefined (highly unlikely), it should throw.
+    // We can simulate this by mocking `Promise.all` if needed, but the current code structure makes this hard to test.
+    // Let's assume the filter logic works correctly and test the intended path.
+    const result = await getSyncSurveys(environmentId, contactId, contactAttributes, deviceType);
+    expect(result).toEqual([]); // Expect empty array, not an error in this case.
+  });
+});

apps/web/app/api/v1/client/[environmentId]/app/sync/lib/survey.ts

@@ -0,0 +1,148 @@
+import "server-only";
+import { Prisma } from "@prisma/client";
+import { cache as reactCache } from "react";
+import { prisma } from "@formbricks/database";
+import { logger } from "@formbricks/logger";
+import { ZId } from "@formbricks/types/common";
+import { DatabaseError, ResourceNotFoundError } from "@formbricks/types/errors";
+import { TSurvey } from "@formbricks/types/surveys/types";
+import { getProjectByEnvironmentId } from "@/lib/project/service";
+import { getSurveys } from "@/lib/survey/service";
+import { anySurveyHasFilters } from "@/lib/survey/utils";
+import { diffInDays } from "@/lib/utils/datetime";
+import { validateInputs } from "@/lib/utils/validate";
+import { evaluateSegment } from "@/modules/ee/contacts/segments/lib/segments";
+
+export const getSyncSurveys = reactCache(
+  async (
+    environmentId: string,
+    contactId: string,
+    contactAttributes: Record<string, string | number>,
+    deviceType: "phone" | "desktop" = "desktop"
+  ): Promise<TSurvey[]> => {
+    validateInputs([environmentId, ZId]);
+    try {
+      const project = await getProjectByEnvironmentId(environmentId);
+
+      if (!project) {
+        throw new Error("Project not found");
+      }
+
+      let surveys = await getSurveys(environmentId);
+
+      // filtered surveys for running and web
+      surveys = surveys.filter((survey) => survey.status === "inProgress" && survey.type === "app");
+
+      // if no surveys are left, return an empty array
+      if (surveys.length === 0) {
+        return [];
+      }
+
+      const displays = await prisma.display.findMany({
+        where: {
+          contactId,
+        },
+      });
+
+      const responses = await prisma.response.findMany({
+        where: {
+          contactId,
+        },
+      });
+
+      // filter surveys that meet the displayOption criteria
+      surveys = surveys.filter((survey) => {
+        switch (survey.displayOption) {
+          case "respondMultiple":
+            return true;
+          case "displayOnce":
+            return displays.filter((display) => display.surveyId === survey.id).length === 0;
+          case "displayMultiple":
+            if (!responses) return true;
+            else {
+              return responses.filter((response) => response.surveyId === survey.id).length === 0;
+            }
+          case "displaySome":
+            if (survey.displayLimit === null) {
+              return true;
+            }
+
+            if (responses && responses.filter((response) => response.surveyId === survey.id).length !== 0) {
+              return false;
+            }
+
+            return displays.filter((display) => display.surveyId === survey.id).length < survey.displayLimit;
+          default:
+            throw Error("Invalid displayOption");
+        }
+      });
+
+      const latestDisplay = displays[0];
+
+      // filter surveys that meet the recontactDays criteria
+      surveys = surveys.filter((survey) => {
+        if (!latestDisplay) {
+          return true;
+        } else if (survey.recontactDays !== null) {
+          const lastDisplaySurvey = displays.filter((display) => display.surveyId === survey.id)[0];
+          if (!lastDisplaySurvey) {
+            return true;
+          }
+          return diffInDays(new Date(), new Date(lastDisplaySurvey.createdAt)) >= survey.recontactDays;
+        } else if (project.recontactDays !== null) {
+          return diffInDays(new Date(), new Date(latestDisplay.createdAt)) >= project.recontactDays;
+        } else {
+          return true;
+        }
+      });
+
+      // if no surveys are left, return an empty array
+      if (surveys.length === 0) {
+        return [];
+      }
+
+      // if no surveys have segment filters, return the surveys
+      if (!anySurveyHasFilters(surveys)) {
+        return surveys;
+      }
+
+      // the surveys now have segment filters, so we need to evaluate them
+      const surveyPromises = surveys.map(async (survey) => {
+        const { segment } = survey;
+        // if the survey has no segment, or the segment has no filters, we return the survey
+        if (!segment || !segment.filters?.length) {
+          return survey;
+        }
+
+        // Evaluate the segment filters
+        const result = await evaluateSegment(
+          {
+            attributes: contactAttributes ?? {},
+            deviceType,
+            environmentId,
+            contactId,
+            userId: String(contactAttributes.userId),
+          },
+          segment.filters
+        );
+
+        return result ? survey : null;
+      });
+
+      const resolvedSurveys = await Promise.all(surveyPromises);
+      surveys = resolvedSurveys.filter((survey) => !!survey) as TSurvey[];
+
+      if (!surveys) {
+        throw new ResourceNotFoundError("Survey", environmentId);
+      }
+      return surveys;
+    } catch (error) {
+      if (error instanceof Prisma.PrismaClientKnownRequestError) {
+        logger.error(error);
+        throw new DatabaseError(error.message);
+      }
+
+      throw error;
+    }
+  }
+);

apps/web/app/api/v1/client/[environmentId]/app/sync/lib/utils.test.ts

@@ -0,0 +1,245 @@
+import { describe, expect, test, vi } from "vitest";
+import { TAttributes } from "@formbricks/types/attributes";
+import { TLanguage } from "@formbricks/types/project";
+import {
+  TSurvey,
+  TSurveyEnding,
+  TSurveyQuestion,
+  TSurveyQuestionTypeEnum,
+} from "@formbricks/types/surveys/types";
+import { parseRecallInfo } from "@/lib/utils/recall";
+import { replaceAttributeRecall } from "./utils";
+
+vi.mock("@/lib/utils/recall", () => ({
+  parseRecallInfo: vi.fn((text, attributes) => {
+    const recallPattern = /recall:([a-zA-Z0-9_-]+)/;
+    const match = text.match(recallPattern);
+    if (match && match[1]) {
+      const recallKey = match[1];
+      const attributeValue = attributes[recallKey];
+      if (attributeValue !== undefined) {
+        return text.replace(recallPattern, `parsed-${attributeValue}`);
+      }
+    }
+    return text; // Return original text if no match or attribute not found
+  }),
+}));
+
+const baseSurvey: TSurvey = {
+  id: "survey1",
+  createdAt: new Date(),
+  updatedAt: new Date(),
+  name: "Test Survey",
+  environmentId: "env1",
+  type: "app",
+  status: "inProgress",
+  questions: [],
+  endings: [],
+  welcomeCard: { enabled: false } as TSurvey["welcomeCard"],
+  languages: [
+    { language: { id: "lang1", code: "en" } as unknown as TLanguage, default: true, enabled: true },
+  ],
+  triggers: [],
+  recontactDays: null,
+  displayLimit: null,
+  singleUse: null,
+  styling: null,
+  surveyClosedMessage: null,
+  hiddenFields: { enabled: false },
+  variables: [],
+  createdBy: null,
+  isSingleResponsePerEmailEnabled: false,
+  isVerifyEmailEnabled: false,
+  projectOverwrites: null,
+  showLanguageSwitch: false,
+  isBackButtonHidden: false,
+  followUps: [],
+  recaptcha: { enabled: false, threshold: 0.5 },
+  displayOption: "displayOnce",
+  autoClose: null,
+  delay: 0,
+  displayPercentage: null,
+  autoComplete: null,
+  segment: null,
+  pin: null,
+  metadata: {},
+};
+
+const attributes: TAttributes = {
+  name: "John Doe",
+  email: "john.doe@example.com",
+  plan: "premium",
+};
+
+describe("replaceAttributeRecall", () => {
+  test("should replace recall info in question headlines and subheaders", () => {
+    const surveyWithRecall: TSurvey = {
+      ...baseSurvey,
+      questions: [
+        {
+          id: "q1",
+          type: TSurveyQuestionTypeEnum.OpenText,
+          headline: { default: "Hello recall:name!" },
+          subheader: { default: "Your email is recall:email" },
+          required: true,
+          buttonLabel: { default: "Next" },
+          placeholder: { default: "Type here..." },
+          longAnswer: false,
+          logic: [],
+        } as unknown as TSurveyQuestion,
+      ],
+    };
+
+    const result = replaceAttributeRecall(surveyWithRecall, attributes);
+    expect(result.questions[0].headline.default).toBe("Hello parsed-John Doe!");
+    expect(result.questions[0].subheader?.default).toBe("Your email is parsed-john.doe@example.com");
+    expect(vi.mocked(parseRecallInfo)).toHaveBeenCalledWith("Hello recall:name!", attributes);
+    expect(vi.mocked(parseRecallInfo)).toHaveBeenCalledWith("Your email is recall:email", attributes);
+  });
+
+  test("should replace recall info in welcome card headline", () => {
+    const surveyWithRecall: TSurvey = {
+      ...baseSurvey,
+      welcomeCard: {
+        enabled: true,
+        headline: { default: "Welcome, recall:name!" },
+        subheader: { default: "<p>Some content</p>" },
+        buttonLabel: { default: "Start" },
+        timeToFinish: false,
+        showResponseCount: false,
+      },
+    };
+
+    const result = replaceAttributeRecall(surveyWithRecall, attributes);
+    expect(result.welcomeCard.headline?.default).toBe("Welcome, parsed-John Doe!");
+    expect(vi.mocked(parseRecallInfo)).toHaveBeenCalledWith("Welcome, recall:name!", attributes);
+  });
+
+  test("should replace recall info in end screen headlines and subheaders", () => {
+    const surveyWithRecall: TSurvey = {
+      ...baseSurvey,
+      endings: [
+        {
+          type: "endScreen",
+          headline: { default: "Thank you, recall:name!" },
+          subheader: { default: "Your plan: recall:plan" },
+          buttonLabel: { default: "Finish" },
+          buttonLink: "https://example.com",
+        } as unknown as TSurveyEnding,
+      ],
+    };
+
+    const result = replaceAttributeRecall(surveyWithRecall, attributes);
+    expect(result.endings[0].type).toBe("endScreen");
+    if (result.endings[0].type === "endScreen") {
+      expect(result.endings[0].headline?.default).toBe("Thank you, parsed-John Doe!");
+      expect(result.endings[0].subheader?.default).toBe("Your plan: parsed-premium");
+      expect(vi.mocked(parseRecallInfo)).toHaveBeenCalledWith("Thank you, recall:name!", attributes);
+      expect(vi.mocked(parseRecallInfo)).toHaveBeenCalledWith("Your plan: recall:plan", attributes);
+    }
+  });
+
+  test("should handle multiple languages", () => {
+    const surveyMultiLang: TSurvey = {
+      ...baseSurvey,
+      languages: [
+        { language: { id: "lang1", code: "en" } as unknown as TLanguage, default: true, enabled: true },
+        { language: { id: "lang2", code: "es" } as unknown as TLanguage, default: false, enabled: true },
+      ],
+      questions: [
+        {
+          id: "q1",
+          type: TSurveyQuestionTypeEnum.OpenText,
+          headline: { default: "Hello recall:name!", es: "Hola recall:name!" },
+          required: true,
+          buttonLabel: { default: "Next", es: "Siguiente" },
+          placeholder: { default: "Type here...", es: "Escribe aquí..." },
+          longAnswer: false,
+          logic: [],
+        } as unknown as TSurveyQuestion,
+      ],
+    };
+
+    const result = replaceAttributeRecall(surveyMultiLang, attributes);
+    expect(result.questions[0].headline.default).toBe("Hello parsed-John Doe!");
+    expect(result.questions[0].headline.es).toBe("Hola parsed-John Doe!");
+    expect(vi.mocked(parseRecallInfo)).toHaveBeenCalledWith("Hello recall:name!", attributes);
+    expect(vi.mocked(parseRecallInfo)).toHaveBeenCalledWith("Hola recall:name!", attributes);
+  });
+
+  test("should not replace if recall key is not in attributes", () => {
+    const surveyWithRecall: TSurvey = {
+      ...baseSurvey,
+      questions: [
+        {
+          id: "q1",
+          type: TSurveyQuestionTypeEnum.OpenText,
+          headline: { default: "Your company: recall:company" },
+          required: true,
+          buttonLabel: { default: "Next" },
+          placeholder: { default: "Type here..." },
+          longAnswer: false,
+          logic: [],
+        } as unknown as TSurveyQuestion,
+      ],
+    };
+
+    const result = replaceAttributeRecall(surveyWithRecall, attributes);
+    expect(result.questions[0].headline.default).toBe("Your company: recall:company");
+    expect(vi.mocked(parseRecallInfo)).toHaveBeenCalledWith("Your company: recall:company", attributes);
+  });
+
+  test("should handle surveys with no recall information", async () => {
+    const surveyNoRecall: TSurvey = {
+      ...baseSurvey,
+      questions: [
+        {
+          id: "q1",
+          type: TSurveyQuestionTypeEnum.OpenText,
+          headline: { default: "Just a regular question" },
+          required: true,
+          buttonLabel: { default: "Next" },
+          placeholder: { default: "Type here..." },
+          longAnswer: false,
+          logic: [],
+        } as unknown as TSurveyQuestion,
+      ],
+      welcomeCard: {
+        enabled: true,
+        headline: { default: "Welcome!" },
+        subheader: { default: "<p>Some content</p>" },
+        buttonLabel: { default: "Start" },
+        timeToFinish: false,
+        showResponseCount: false,
+      },
+      endings: [
+        {
+          type: "endScreen",
+          headline: { default: "Thank you!" },
+          buttonLabel: { default: "Finish" },
+        } as unknown as TSurveyEnding,
+      ],
+    };
+    const parseRecallInfoSpy = vi.spyOn(await import("@/lib/utils/recall"), "parseRecallInfo");
+
+    const result = replaceAttributeRecall(surveyNoRecall, attributes);
+    expect(result).toEqual(surveyNoRecall); // Should be unchanged
+    expect(parseRecallInfoSpy).not.toHaveBeenCalled();
+    parseRecallInfoSpy.mockRestore();
+  });
+
+  test("should handle surveys with empty questions, endings, or disabled welcome card", async () => {
+    const surveyEmpty: TSurvey = {
+      ...baseSurvey,
+      questions: [],
+      endings: [],
+      welcomeCard: { enabled: false } as TSurvey["welcomeCard"],
+    };
+    const parseRecallInfoSpy = vi.spyOn(await import("@/lib/utils/recall"), "parseRecallInfo");
+
+    const result = replaceAttributeRecall(surveyEmpty, attributes);
+    expect(result).toEqual(surveyEmpty);
+    expect(parseRecallInfoSpy).not.toHaveBeenCalled();
+    parseRecallInfoSpy.mockRestore();
+  });
+});

apps/web/app/api/v1/client/[environmentId]/app/sync/lib/utils.ts

@@ -0,0 +1,55 @@
+import { TAttributes } from "@formbricks/types/attributes";
+import { TSurvey } from "@formbricks/types/surveys/types";
+import { parseRecallInfo } from "@/lib/utils/recall";
+
+export const replaceAttributeRecall = (survey: TSurvey, attributes: TAttributes): TSurvey => {
+  const surveyTemp = structuredClone(survey);
+  const languages = surveyTemp.languages
+    .map((surveyLanguage) => {
+      if (surveyLanguage.default) {
+        return "default";
+      }
+
+      if (surveyLanguage.enabled) {
+        return surveyLanguage.language.code;
+      }
+
+      return null;
+    })
+    .filter((language): language is string => language !== null);
+
+  surveyTemp.questions.forEach((question) => {
+    languages.forEach((language) => {
+      if (question.headline[language]?.includes("recall:")) {
+        question.headline[language] = parseRecallInfo(question.headline[language], attributes);
+      }
+      if (question.subheader && question.subheader[language]?.includes("recall:")) {
+        question.subheader[language] = parseRecallInfo(question.subheader[language], attributes);
+      }
+    });
+  });
+  if (surveyTemp.welcomeCard.enabled && surveyTemp.welcomeCard.headline) {
+    languages.forEach((language) => {
+      if (surveyTemp.welcomeCard.headline && surveyTemp.welcomeCard.headline[language]?.includes("recall:")) {
+        surveyTemp.welcomeCard.headline[language] = parseRecallInfo(
+          surveyTemp.welcomeCard.headline[language],
+          attributes
+        );
+      }
+    });
+  }
+  surveyTemp.endings.forEach((ending) => {
+    if (ending.type === "endScreen") {
+      languages.forEach((language) => {
+        if (ending.headline && ending.headline[language]?.includes("recall:")) {
+          ending.headline[language] = parseRecallInfo(ending.headline[language], attributes);
+          if (ending.subheader && ending.subheader[language]?.includes("recall:")) {
+            ending.subheader[language] = parseRecallInfo(ending.subheader[language], attributes);
+          }
+        }
+      });
+    }
+  });
+
+  return surveyTemp;
+};

apps/web/app/api/v1/client/[environmentId]/contacts/[userId]/attributes/route.ts

@@ -0,0 +1,6 @@
+import {
+  OPTIONS,
+  PUT,
+} from "@/modules/ee/contacts/api/v1/client/[environmentId]/contacts/[userId]/attributes/route";
+
+export { OPTIONS, PUT };

apps/web/app/api/v1/client/[environmentId]/environment/lib/data.test.ts

@@ -1,314 +0,0 @@
-import { Prisma } from "@prisma/client";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { prisma } from "@formbricks/database";
-import { logger } from "@formbricks/logger";
-import { DatabaseError, ResourceNotFoundError } from "@formbricks/types/errors";
-import { getEnvironmentStateData } from "./data";
-
-// Mock dependencies
-vi.mock("@formbricks/database", () => ({
-  prisma: {
-    environment: {
-      findUnique: vi.fn(),
-    },
-  },
-}));
-
-vi.mock("@formbricks/logger", () => ({
-  logger: {
-    error: vi.fn(),
-  },
-}));
-
-vi.mock("@/modules/survey/lib/utils", () => ({
-  transformPrismaSurvey: vi.fn((survey) => survey),
-}));
-
-const environmentId = "cjld2cjxh0000qzrmn831i7rn";
-
-const mockEnvironmentData = {
-  id: environmentId,
-  type: "production",
-  appSetupCompleted: true,
-  project: {
-    id: "project-123",
-    recontactDays: 30,
-    clickOutsideClose: true,
-    overlay: "none",
-    placement: "bottomRight",
-    inAppSurveyBranding: true,
-    styling: { allowStyleOverwrite: false },
-    organization: {
-      id: "org-123",
-      billing: {
-        plan: "free",
-        limits: { monthly: { responses: 100 } },
-      },
-    },
-  },
-  actionClasses: [
-    {
-      id: "action-1",
-      type: "code",
-      name: "Test Action",
-      key: "test-action",
-      noCodeConfig: null,
-    },
-  ],
-  surveys: [
-    {
-      id: "survey-1",
-      name: "Test Survey",
-      type: "app",
-      status: "inProgress",
-      welcomeCard: { enabled: false },
-      questions: [],
-      blocks: null,
-      variables: [],
-      showLanguageSwitch: false,
-      languages: [],
-      endings: [],
-      autoClose: null,
-      styling: null,
-      recaptcha: { enabled: false },
-      segment: null,
-      recontactDays: null,
-      displayLimit: null,
-      displayOption: "displayOnce",
-      hiddenFields: { enabled: false },
-      isBackButtonHidden: false,
-      triggers: [],
-      displayPercentage: null,
-      delay: 0,
-      projectOverwrites: null,
-    },
-  ],
-};
-
-describe("getEnvironmentStateData", () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
-
-  test("should return environment state data when environment exists", async () => {
-    vi.mocked(prisma.environment.findUnique).mockResolvedValue(mockEnvironmentData as never);
-
-    const result = await getEnvironmentStateData(environmentId);
-
-    expect(result).toEqual({
-      environment: {
-        id: environmentId,
-        type: "production",
-        appSetupCompleted: true,
-        project: {
-          id: "project-123",
-          recontactDays: 30,
-          clickOutsideClose: true,
-          overlay: "none",
-          placement: "bottomRight",
-          inAppSurveyBranding: true,
-          styling: { allowStyleOverwrite: false },
-        },
-      },
-      organization: {
-        id: "org-123",
-        billing: {
-          plan: "free",
-          limits: { monthly: { responses: 100 } },
-        },
-      },
-      surveys: mockEnvironmentData.surveys,
-      actionClasses: mockEnvironmentData.actionClasses,
-    });
-
-    expect(prisma.environment.findUnique).toHaveBeenCalledWith({
-      where: { id: environmentId },
-      select: expect.objectContaining({
-        id: true,
-        type: true,
-        appSetupCompleted: true,
-        project: expect.any(Object),
-        actionClasses: expect.any(Object),
-        surveys: expect.any(Object),
-      }),
-    });
-  });
-
-  test("should throw ResourceNotFoundError when environment is not found", async () => {
-    vi.mocked(prisma.environment.findUnique).mockResolvedValue(null);
-
-    await expect(getEnvironmentStateData(environmentId)).rejects.toThrow(ResourceNotFoundError);
-    await expect(getEnvironmentStateData(environmentId)).rejects.toThrow("environment");
-  });
-
-  test("should throw ResourceNotFoundError when project is not found", async () => {
-    vi.mocked(prisma.environment.findUnique).mockResolvedValue({
-      ...mockEnvironmentData,
-      project: null,
-    } as never);
-
-    await expect(getEnvironmentStateData(environmentId)).rejects.toThrow(ResourceNotFoundError);
-  });
-
-  test("should throw ResourceNotFoundError when organization is not found", async () => {
-    vi.mocked(prisma.environment.findUnique).mockResolvedValue({
-      ...mockEnvironmentData,
-      project: {
-        ...mockEnvironmentData.project,
-        organization: null,
-      },
-    } as never);
-
-    await expect(getEnvironmentStateData(environmentId)).rejects.toThrow(ResourceNotFoundError);
-  });
-
-  test("should throw DatabaseError on Prisma database errors", async () => {
-    const prismaError = new Prisma.PrismaClientKnownRequestError("Connection failed", {
-      code: "P2024",
-      clientVersion: "5.0.0",
-    });
-    vi.mocked(prisma.environment.findUnique).mockRejectedValue(prismaError);
-
-    await expect(getEnvironmentStateData(environmentId)).rejects.toThrow(DatabaseError);
-    expect(logger.error).toHaveBeenCalled();
-  });
-
-  test("should rethrow unexpected errors", async () => {
-    const unexpectedError = new Error("Unexpected error");
-    vi.mocked(prisma.environment.findUnique).mockRejectedValue(unexpectedError);
-
-    await expect(getEnvironmentStateData(environmentId)).rejects.toThrow("Unexpected error");
-    expect(logger.error).toHaveBeenCalled();
-  });
-
-  test("should handle empty surveys array", async () => {
-    vi.mocked(prisma.environment.findUnique).mockResolvedValue({
-      ...mockEnvironmentData,
-      surveys: [],
-    } as never);
-
-    const result = await getEnvironmentStateData(environmentId);
-
-    expect(result.surveys).toEqual([]);
-  });
-
-  test("should handle empty actionClasses array", async () => {
-    vi.mocked(prisma.environment.findUnique).mockResolvedValue({
-      ...mockEnvironmentData,
-      actionClasses: [],
-    } as never);
-
-    const result = await getEnvironmentStateData(environmentId);
-
-    expect(result.actionClasses).toEqual([]);
-  });
-
-  test("should transform surveys using transformPrismaSurvey", async () => {
-    const multipleSurveys = [
-      ...mockEnvironmentData.surveys,
-      {
-        ...mockEnvironmentData.surveys[0],
-        id: "survey-2",
-        name: "Second Survey",
-      },
-    ];
-
-    vi.mocked(prisma.environment.findUnique).mockResolvedValue({
-      ...mockEnvironmentData,
-      surveys: multipleSurveys,
-    } as never);
-
-    const result = await getEnvironmentStateData(environmentId);
-
-    expect(result.surveys).toHaveLength(2);
-  });
-
-  test("should correctly map project properties to environment.project", async () => {
-    const customProject = {
-      ...mockEnvironmentData.project,
-      recontactDays: 14,
-      clickOutsideClose: false,
-      overlay: "dark",
-      placement: "center",
-      inAppSurveyBranding: false,
-      styling: { allowStyleOverwrite: true, brandColor: "#ff0000" },
-    };
-
-    vi.mocked(prisma.environment.findUnique).mockResolvedValue({
-      ...mockEnvironmentData,
-      project: customProject,
-    } as never);
-
-    const result = await getEnvironmentStateData(environmentId);
-
-    expect(result.environment.project).toEqual({
-      id: "project-123",
-      recontactDays: 14,
-      clickOutsideClose: false,
-      overlay: "dark",
-      placement: "center",
-      inAppSurveyBranding: false,
-      styling: { allowStyleOverwrite: true, brandColor: "#ff0000" },
-    });
-  });
-
-  test("should validate environmentId input", async () => {
-    // Invalid CUID should throw validation error
-    await expect(getEnvironmentStateData("invalid-id")).rejects.toThrow();
-  });
-
-  test("should handle different environment types", async () => {
-    vi.mocked(prisma.environment.findUnique).mockResolvedValue({
-      ...mockEnvironmentData,
-      type: "development",
-    } as never);
-
-    const result = await getEnvironmentStateData(environmentId);
-
-    expect(result.environment.type).toBe("development");
-  });
-
-  test("should handle appSetupCompleted false", async () => {
-    vi.mocked(prisma.environment.findUnique).mockResolvedValue({
-      ...mockEnvironmentData,
-      appSetupCompleted: false,
-    } as never);
-
-    const result = await getEnvironmentStateData(environmentId);
-
-    expect(result.environment.appSetupCompleted).toBe(false);
-  });
-
-  test("should correctly extract organization billing data", async () => {
-    const customBilling = {
-      plan: "enterprise",
-      stripeCustomerId: "cus_123",
-      limits: {
-        monthly: { responses: 10000, miu: 50000 },
-        projects: 100,
-      },
-    };
-
-    vi.mocked(prisma.environment.findUnique).mockResolvedValue({
-      ...mockEnvironmentData,
-      project: {
-        ...mockEnvironmentData.project,
-        organization: {
-          id: "org-enterprise",
-          billing: customBilling,
-        },
-      },
-    } as never);
-
-    const result = await getEnvironmentStateData(environmentId);
-
-    expect(result.organization).toEqual({
-      id: "org-enterprise",
-      billing: customBilling,
-    });
-  });
-});

apps/web/app/api/v1/client/[environmentId]/environment/lib/data.ts

@@ -10,7 +10,6 @@ import {
   TJsEnvironmentStateSurvey,
 } from "@formbricks/types/js";
 import { validateInputs } from "@/lib/utils/validate";
-import { resolveStorageUrlsInObject } from "@/modules/storage/utils";
 import { transformPrismaSurvey } from "@/modules/survey/lib/utils";
 
 /**
@@ -55,7 +54,7 @@ export const getEnvironmentStateData = async (environmentId: string): Promise<En
             id: true,
             recontactDays: true,
             clickOutsideClose: true,
-            overlay: true,
+            darkOverlay: true,
             placement: true,
             inAppSurveyBranding: true,
             styling: true,
@@ -175,17 +174,17 @@ export const getEnvironmentStateData = async (environmentId: string): Promise<En
           id: environmentData.project.id,
           recontactDays: environmentData.project.recontactDays,
           clickOutsideClose: environmentData.project.clickOutsideClose,
-          overlay: environmentData.project.overlay,
+          darkOverlay: environmentData.project.darkOverlay,
           placement: environmentData.project.placement,
           inAppSurveyBranding: environmentData.project.inAppSurveyBranding,
-          styling: resolveStorageUrlsInObject(environmentData.project.styling),
+          styling: environmentData.project.styling,
         },
       },
       organization: {
         id: environmentData.project.organization.id,
         billing: environmentData.project.organization.billing,
       },
-      surveys: resolveStorageUrlsInObject(transformedSurveys),
+      surveys: transformedSurveys,
       actionClasses: environmentData.actionClasses as TJsEnvironmentStateActionClass[],
     };
   } catch (error) {

apps/web/app/api/v1/client/[environmentId]/environment/lib/environmentState.test.ts

@@ -58,7 +58,7 @@ const mockProject: TJsEnvironmentStateProject = {
   inAppSurveyBranding: true,
   placement: "bottomRight",
   clickOutsideClose: true,
-  overlay: "none",
+  darkOverlay: false,
   styling: {
     allowStyleOverwrite: false,
   },

apps/web/app/api/v1/client/[environmentId]/identify/contacts/[userId]/route.ts

@@ -0,0 +1,6 @@
+import {
+  GET,
+  OPTIONS,
+} from "@/modules/ee/contacts/api/v1/client/[environmentId]/identify/contacts/[userId]/route";
+
+export { GET, OPTIONS };

apps/web/app/api/v1/client/[environmentId]/responses/[responseId]/route.ts

@@ -1,15 +1,13 @@
 import { NextRequest } from "next/server";
 import { logger } from "@formbricks/logger";
 import { DatabaseError, InvalidInputError, ResourceNotFoundError } from "@formbricks/types/errors";
-import { TResponse, TResponseUpdateInput, ZResponseUpdateInput } from "@formbricks/types/responses";
-import { TSurvey } from "@formbricks/types/surveys/types";
+import { ZResponseUpdateInput } from "@formbricks/types/responses";
 import { responses } from "@/app/lib/api/response";
 import { transformErrorToDetails } from "@/app/lib/api/validator";
 import { withV1ApiWrapper } from "@/app/lib/api/with-api-logging";
 import { sendToPipeline } from "@/app/lib/pipelines";
 import { getResponse } from "@/lib/response/service";
 import { getSurvey } from "@/lib/survey/service";
-import { formatValidationErrorsForV1Api, validateResponseData } from "@/modules/api/lib/validation";
 import { validateOtherOptionLengthForMultipleChoice } from "@/modules/api/v2/lib/element";
 import { createQuotaFullObject } from "@/modules/ee/quotas/lib/helpers";
 import { validateFileUploads } from "@/modules/storage/utils";
@@ -33,35 +31,6 @@ const handleDatabaseError = (error: Error, url: string, endpoint: string, respon
   return responses.internalServerErrorResponse("Unknown error occurred", true);
 };
 
-const validateResponse = (
-  response: TResponse,
-  survey: TSurvey,
-  responseUpdateInput: TResponseUpdateInput
-) => {
-  // Validate response data against validation rules
-  const mergedData = {
-    ...response.data,
-    ...responseUpdateInput.data,
-  };
-
-  const validationErrors = validateResponseData(
-    survey.blocks,
-    mergedData,
-    responseUpdateInput.language ?? response.language ?? "en",
-    survey.questions
-  );
-
-  if (validationErrors) {
-    return {
-      response: responses.badRequestResponse(
-        "Validation failed",
-        formatValidationErrorsForV1Api(validationErrors),
-        true
-      ),
-    };
-  }
-};
-
 export const PUT = withV1ApiWrapper({
   handler: async ({
     req,
@@ -144,11 +113,6 @@ export const PUT = withV1ApiWrapper({
       };
     }
 
-    const validationResult = validateResponse(response, survey, inputValidation.data);
-    if (validationResult) {
-      return validationResult;
-    }
-
     // update response with quota evaluation
     let updatedResponse;
     try {

apps/web/app/api/v1/client/[environmentId]/responses/route.ts

@@ -6,14 +6,12 @@ import { ZEnvironmentId } from "@formbricks/types/environment";
 import { InvalidInputError } from "@formbricks/types/errors";
 import { TResponseWithQuotaFull } from "@formbricks/types/quota";
 import { TResponseInput, ZResponseInput } from "@formbricks/types/responses";
-import { TSurvey } from "@formbricks/types/surveys/types";
 import { responses } from "@/app/lib/api/response";
 import { transformErrorToDetails } from "@/app/lib/api/validator";
 import { withV1ApiWrapper } from "@/app/lib/api/with-api-logging";
 import { sendToPipeline } from "@/app/lib/pipelines";
 import { getSurvey } from "@/lib/survey/service";
 import { getClientIpFromHeaders } from "@/lib/utils/client-ip";
-import { formatValidationErrorsForV1Api, validateResponseData } from "@/modules/api/lib/validation";
 import { getIsContactsEnabled } from "@/modules/ee/license-check/lib/utils";
 import { createQuotaFullObject } from "@/modules/ee/quotas/lib/helpers";
 import { validateFileUploads } from "@/modules/storage/utils";
@@ -35,26 +33,6 @@ export const OPTIONS = async (): Promise<Response> => {
   );
 };
 
-const validateResponse = (responseInputData: TResponseInput, survey: TSurvey) => {
-  // Validate response data against validation rules
-  const validationErrors = validateResponseData(
-    survey.blocks,
-    responseInputData.data,
-    responseInputData.language ?? "en",
-    survey.questions
-  );
-
-  if (validationErrors) {
-    return {
-      response: responses.badRequestResponse(
-        "Validation failed",
-        formatValidationErrorsForV1Api(validationErrors),
-        true
-      ),
-    };
-  }
-};
-
 export const POST = withV1ApiWrapper({
   handler: async ({ req, props }: { req: NextRequest; props: Context }) => {
     const params = await props.params;
@@ -145,11 +123,6 @@ export const POST = withV1ApiWrapper({
       };
     }
 
-    const validationResult = validateResponse(responseInputData, survey);
-    if (validationResult) {
-      return validationResult;
-    }
-
     let response: TResponseWithQuotaFull;
     try {
       const meta: TResponseInput["meta"] = {

apps/web/app/api/v1/client/og/route.tsx

@@ -1,4 +1,4 @@
-import { ImageResponse } from "next/og";
+import { ImageResponse } from "@vercel/og";
 import { NextRequest } from "next/server";
 
 export const GET = async (req: NextRequest) => {

apps/web/app/api/v1/integrations/notion/callback/route.ts

@@ -1,7 +1,7 @@
 import { NextRequest } from "next/server";
 import { TIntegrationNotionConfigData, TIntegrationNotionInput } from "@formbricks/types/integration/notion";
 import { responses } from "@/app/lib/api/response";
-import { TSessionAuthentication, withV1ApiWrapper } from "@/app/lib/api/with-api-logging";
+import { withV1ApiWrapper } from "@/app/lib/api/with-api-logging";
 import {
   ENCRYPTION_KEY,
   NOTION_OAUTH_CLIENT_ID,
@@ -10,17 +10,10 @@ import {
   WEBAPP_URL,
 } from "@/lib/constants";
 import { symmetricEncrypt } from "@/lib/crypto";
-import { hasUserEnvironmentAccess } from "@/lib/environment/auth";
 import { createOrUpdateIntegration, getIntegrationByType } from "@/lib/integration/service";
 
 export const GET = withV1ApiWrapper({
-  handler: async ({
-    req,
-    authentication,
-  }: {
-    req: NextRequest;
-    authentication: NonNullable<TSessionAuthentication>;
-  }) => {
+  handler: async ({ req }: { req: NextRequest }) => {
     const url = req.url;
     const queryParams = new URLSearchParams(url.split("?")[1]); // Split the URL and get the query parameters
     const environmentId = queryParams.get("state"); // Get the value of the 'state' parameter
@@ -33,13 +26,6 @@ export const GET = withV1ApiWrapper({
       };
     }
 
-    const canUserAccessEnvironment = await hasUserEnvironmentAccess(authentication.user.id, environmentId);
-    if (!canUserAccessEnvironment) {
-      return {
-        response: responses.unauthorizedResponse(),
-      };
-    }
-
     if (code && typeof code !== "string") {
       return {
         response: responses.badRequestResponse("`code` must be a string"),

apps/web/app/api/v1/integrations/slack/callback/route.ts

@@ -5,19 +5,12 @@ import {
   TIntegrationSlackCredential,
 } from "@formbricks/types/integration/slack";
 import { responses } from "@/app/lib/api/response";
-import { TSessionAuthentication, withV1ApiWrapper } from "@/app/lib/api/with-api-logging";
+import { withV1ApiWrapper } from "@/app/lib/api/with-api-logging";
 import { SLACK_CLIENT_ID, SLACK_CLIENT_SECRET, WEBAPP_URL } from "@/lib/constants";
-import { hasUserEnvironmentAccess } from "@/lib/environment/auth";
 import { createOrUpdateIntegration, getIntegrationByType } from "@/lib/integration/service";
 
 export const GET = withV1ApiWrapper({
-  handler: async ({
-    req,
-    authentication,
-  }: {
-    req: NextRequest;
-    authentication: NonNullable<TSessionAuthentication>;
-  }) => {
+  handler: async ({ req }: { req: NextRequest }) => {
     const url = req.url;
     const queryParams = new URLSearchParams(url.split("?")[1]); // Split the URL and get the query parameters
     const environmentId = queryParams.get("state"); // Get the value of the 'state' parameter
@@ -30,13 +23,6 @@ export const GET = withV1ApiWrapper({
       };
     }
 
-    const canUserAccessEnvironment = await hasUserEnvironmentAccess(authentication.user.id, environmentId);
-    if (!canUserAccessEnvironment) {
-      return {
-        response: responses.unauthorizedResponse(),
-      };
-    }
-
     if (code && typeof code !== "string") {
       return {
         response: responses.badRequestResponse("`code` must be a string"),

apps/web/app/api/v1/management/responses/[responseId]/route.ts

@@ -8,9 +8,8 @@ import { TApiAuditLog, TApiKeyAuthentication, withV1ApiWrapper } from "@/app/lib
 import { sendToPipeline } from "@/app/lib/pipelines";
 import { deleteResponse, getResponse } from "@/lib/response/service";
 import { getSurvey } from "@/lib/survey/service";
-import { formatValidationErrorsForV1Api, validateResponseData } from "@/modules/api/lib/validation";
 import { hasPermission } from "@/modules/organization/settings/api-keys/lib/utils";
-import { resolveStorageUrlsInObject, validateFileUploads } from "@/modules/storage/utils";
+import { validateFileUploads } from "@/modules/storage/utils";
 import { updateResponseWithQuotaEvaluation } from "./lib/response";
 
 async function fetchAndAuthorizeResponse(
@@ -57,10 +56,7 @@ export const GET = withV1ApiWrapper({
       }
 
       return {
-        response: responses.successResponse({
-          ...result.response,
-          data: resolveStorageUrlsInObject(result.response.data),
-        }),
+        response: responses.successResponse(result.response),
       };
     } catch (error) {
       return {
@@ -144,24 +140,6 @@ export const PUT = withV1ApiWrapper({
         };
       }
 
-      // Validate response data against validation rules
-      const validationErrors = validateResponseData(
-        result.survey.blocks,
-        responseUpdate.data,
-        responseUpdate.language ?? "en",
-        result.survey.questions
-      );
-
-      if (validationErrors) {
-        return {
-          response: responses.badRequestResponse(
-            "Validation failed",
-            formatValidationErrorsForV1Api(validationErrors),
-            true
-          ),
-        };
-      }
-
       const inputValidation = ZResponseUpdateInput.safeParse(responseUpdate);
       if (!inputValidation.success) {
         return {
@@ -192,7 +170,7 @@ export const PUT = withV1ApiWrapper({
       }
 
       return {
-        response: responses.successResponse({ ...updated, data: resolveStorageUrlsInObject(updated.data) }),
+        response: responses.successResponse(updated),
       };
     } catch (error) {
       return {

apps/web/app/api/v1/management/responses/route.ts

@@ -7,9 +7,8 @@ import { transformErrorToDetails } from "@/app/lib/api/validator";
 import { TApiAuditLog, TApiKeyAuthentication, withV1ApiWrapper } from "@/app/lib/api/with-api-logging";
 import { sendToPipeline } from "@/app/lib/pipelines";
 import { getSurvey } from "@/lib/survey/service";
-import { formatValidationErrorsForV1Api, validateResponseData } from "@/modules/api/lib/validation";
 import { hasPermission } from "@/modules/organization/settings/api-keys/lib/utils";
-import { resolveStorageUrlsInObject, validateFileUploads } from "@/modules/storage/utils";
+import { validateFileUploads } from "@/modules/storage/utils";
 import {
   createResponseWithQuotaEvaluation,
   getResponses,
@@ -54,9 +53,7 @@ export const GET = withV1ApiWrapper({
         allResponses.push(...environmentResponses);
       }
       return {
-        response: responses.successResponse(
-          allResponses.map((r) => ({ ...r, data: resolveStorageUrlsInObject(r.data) }))
-        ),
+        response: responses.successResponse(allResponses),
       };
     } catch (error) {
       if (error instanceof DatabaseError) {
@@ -152,24 +149,6 @@ export const POST = withV1ApiWrapper({
         };
       }
 
-      // Validate response data against validation rules
-      const validationErrors = validateResponseData(
-        surveyResult.survey.blocks,
-        responseInput.data,
-        responseInput.language ?? "en",
-        surveyResult.survey.questions
-      );
-
-      if (validationErrors) {
-        return {
-          response: responses.badRequestResponse(
-            "Validation failed",
-            formatValidationErrorsForV1Api(validationErrors),
-            true
-          ),
-        };
-      }
-
       if (responseInput.createdAt && !responseInput.updatedAt) {
         responseInput.updatedAt = responseInput.createdAt;
       }

apps/web/app/api/v1/management/surveys/[surveyId]/route.ts

@@ -16,7 +16,6 @@ import { TApiAuditLog, TApiKeyAuthentication, withV1ApiWrapper } from "@/app/lib
 import { getOrganizationByEnvironmentId } from "@/lib/organization/service";
 import { getSurvey, updateSurvey } from "@/lib/survey/service";
 import { hasPermission } from "@/modules/organization/settings/api-keys/lib/utils";
-import { resolveStorageUrlsInObject } from "@/modules/storage/utils";
 
 const fetchAndAuthorizeSurvey = async (
   surveyId: string,
@@ -59,18 +58,16 @@ export const GET = withV1ApiWrapper({
 
       if (shouldTransformToQuestions) {
         return {
-          response: responses.successResponse(
-            resolveStorageUrlsInObject({
-              ...result.survey,
-              questions: transformBlocksToQuestions(result.survey.blocks, result.survey.endings),
-              blocks: [],
-            })
-          ),
+          response: responses.successResponse({
+            ...result.survey,
+            questions: transformBlocksToQuestions(result.survey.blocks, result.survey.endings),
+            blocks: [],
+          }),
         };
       }
 
       return {
-        response: responses.successResponse(resolveStorageUrlsInObject(result.survey)),
+        response: responses.successResponse(result.survey),
       };
     } catch (error) {
       return {
@@ -205,12 +202,12 @@ export const PUT = withV1ApiWrapper({
           };
 
           return {
-            response: responses.successResponse(resolveStorageUrlsInObject(surveyWithQuestions)),
+            response: responses.successResponse(surveyWithQuestions),
           };
         }
 
         return {
-          response: responses.successResponse(resolveStorageUrlsInObject(updatedSurvey)),
+          response: responses.successResponse(updatedSurvey),
         };
       } catch (error) {
         return {

apps/web/app/api/v1/management/surveys/route.ts

@@ -14,7 +14,6 @@ import { TApiAuditLog, TApiKeyAuthentication, withV1ApiWrapper } from "@/app/lib
 import { getOrganizationByEnvironmentId } from "@/lib/organization/service";
 import { createSurvey } from "@/lib/survey/service";
 import { hasPermission } from "@/modules/organization/settings/api-keys/lib/utils";
-import { resolveStorageUrlsInObject } from "@/modules/storage/utils";
 import { getSurveys } from "./lib/surveys";
 
 export const GET = withV1ApiWrapper({
@@ -56,7 +55,7 @@ export const GET = withV1ApiWrapper({
       });
 
       return {
-        response: responses.successResponse(resolveStorageUrlsInObject(surveysWithQuestions)),
+        response: responses.successResponse(surveysWithQuestions),
       };
     } catch (error) {
       if (error instanceof DatabaseError) {

apps/web/app/api/v2/client/[environmentId]/contacts/[userId]/attributes/route.ts

@@ -0,0 +1,6 @@
+import {
+  OPTIONS,
+  PUT,
+} from "@/modules/ee/contacts/api/v1/client/[environmentId]/contacts/[userId]/attributes/route";
+
+export { OPTIONS, PUT };

apps/web/app/api/v2/client/[environmentId]/identify/contacts/[userId]/route.ts

@@ -0,0 +1,6 @@
+import {
+  GET,
+  OPTIONS,
+} from "@/modules/ee/contacts/api/v1/client/[environmentId]/identify/contacts/[userId]/route";
+
+export { GET, OPTIONS };

apps/web/app/api/v2/client/[environmentId]/responses/route.ts

@@ -11,7 +11,6 @@ import { sendToPipeline } from "@/app/lib/pipelines";
 import { getSurvey } from "@/lib/survey/service";
 import { getElementsFromBlocks } from "@/lib/survey/utils";
 import { getClientIpFromHeaders } from "@/lib/utils/client-ip";
-import { formatValidationErrorsForV1Api, validateResponseData } from "@/modules/api/lib/validation";
 import { validateOtherOptionLengthForMultipleChoice } from "@/modules/api/v2/lib/element";
 import { getIsContactsEnabled } from "@/modules/ee/license-check/lib/utils";
 import { createQuotaFullObject } from "@/modules/ee/quotas/lib/helpers";
@@ -107,22 +106,6 @@ export const POST = async (request: Request, context: Context): Promise<Response
     );
   }
 
-  // Validate response data against validation rules
-  const validationErrors = validateResponseData(
-    survey.blocks,
-    responseInputData.data,
-    responseInputData.language ?? "en",
-    survey.questions
-  );
-
-  if (validationErrors) {
-    return responses.badRequestResponse(
-      "Validation failed",
-      formatValidationErrorsForV1Api(validationErrors),
-      true
-    );
-  }
-
   let response: TResponseWithQuotaFull;
   try {
     const meta: TResponseInputV2["meta"] = {

apps/web/app/error.tsx

@@ -3,9 +3,8 @@
 // Error components must be Client components
 import * as Sentry from "@sentry/nextjs";
 import { TFunction } from "i18next";
-import { useEffect } from "react";
 import { useTranslation } from "react-i18next";
-import { type ClientErrorType, getClientErrorData, isExpectedError } from "@formbricks/types/errors";
+import { type ClientErrorType, getClientErrorData } from "@formbricks/types/errors";
 import { Button } from "@/modules/ui/components/button";
 import { ErrorComponent } from "@/modules/ui/components/error-component";
 
@@ -31,13 +30,11 @@ const ErrorBoundary = ({ error, reset }: { error: Error; reset: () => void }) =>
   const errorData = getClientErrorData(error);
   const { title, description } = getErrorMessages(errorData.type, t);
 
-  useEffect(() => {
-    if (process.env.NODE_ENV === "development") {
-      console.error(error.message);
-    } else if (!isExpectedError(error)) {
-      Sentry.captureException(error);
-    }
-  }, [error]);
+  if (process.env.NODE_ENV === "development") {
+    console.error(error.message);
+  } else {
+    Sentry.captureException(error);
+  }
 
   return (
     <div className="flex h-full w-full flex-col items-center justify-center">

apps/web/app/lib/api/with-api-logging.test.ts

@@ -68,6 +68,7 @@ vi.mock("@/app/middleware/endpoint-validator", async () => {
     isClientSideApiRoute: vi.fn().mockReturnValue({ isClientSideApi: false, isRateLimited: true }),
     isManagementApiRoute: vi.fn().mockReturnValue({ isManagementApi: false, authenticationMethod: "apiKey" }),
     isIntegrationRoute: vi.fn().mockReturnValue(false),
+    isSyncWithUserIdentificationEndpoint: vi.fn().mockReturnValue(null),
   };
 });
 
@@ -81,6 +82,7 @@ vi.mock("@/modules/core/rate-limit/rate-limit-configs", () => ({
     api: {
       client: { windowMs: 60000, max: 100 },
       v1: { windowMs: 60000, max: 1000 },
+      syncUserIdentification: { windowMs: 60000, max: 50 },
     },
   },
 }));
@@ -461,6 +463,45 @@ describe("withV1ApiWrapper", () => {
     expect(handler).not.toHaveBeenCalled();
   });
 
+  test("handles sync user identification rate limiting", async () => {
+    const { applyRateLimit, applyIPRateLimit } = await import("@/modules/core/rate-limit/helpers");
+    const {
+      isClientSideApiRoute,
+      isManagementApiRoute,
+      isIntegrationRoute,
+      isSyncWithUserIdentificationEndpoint,
+    } = await import("@/app/middleware/endpoint-validator");
+    const { authenticateRequest } = await import("@/app/api/v1/auth");
+
+    vi.mocked(isClientSideApiRoute).mockReturnValue({ isClientSideApi: true, isRateLimited: true });
+    vi.mocked(isManagementApiRoute).mockReturnValue({
+      isManagementApi: false,
+      authenticationMethod: AuthenticationMethod.None,
+    });
+    vi.mocked(isIntegrationRoute).mockReturnValue(false);
+    vi.mocked(isSyncWithUserIdentificationEndpoint).mockReturnValue({
+      userId: "user-123",
+      environmentId: "env-123",
+    });
+    vi.mocked(authenticateRequest).mockResolvedValue(null);
+    vi.mocked(applyIPRateLimit).mockResolvedValue(undefined);
+    const rateLimitError = new Error("Sync rate limit exceeded");
+    rateLimitError.message = "Sync rate limit exceeded";
+    vi.mocked(applyRateLimit).mockRejectedValue(rateLimitError);
+
+    const handler = vi.fn();
+    const req = createMockRequest({ url: "/api/v1/client/env-123/app/sync/user-123" });
+    const { withV1ApiWrapper } = await import("./with-api-logging");
+    const wrapped = withV1ApiWrapper({ handler });
+    const res = await wrapped(req, undefined);
+
+    expect(res.status).toBe(429);
+    expect(applyRateLimit).toHaveBeenCalledWith(
+      expect.objectContaining({ windowMs: 60000, max: 50 }),
+      "user-123"
+    );
+  });
+
   test("skips audit log creation when no action/targetType provided", async () => {
     const { queueAuditEvent: mockedQueueAuditEvent } = (await import(
       "@/modules/ee/audit-logs/lib/handler"

apps/web/app/lib/api/with-api-logging.ts

@@ -10,6 +10,7 @@ import {
   isClientSideApiRoute,
   isIntegrationRoute,
   isManagementApiRoute,
+  isSyncWithUserIdentificationEndpoint,
 } from "@/app/middleware/endpoint-validator";
 import { AUDIT_LOG_ENABLED, IS_PRODUCTION, SENTRY_DSN } from "@/lib/constants";
 import { authOptions } from "@/modules/auth/lib/authOptions";
@@ -47,16 +48,23 @@ enum ApiV1RouteTypeEnum {
 }
 
 /**
- * Apply client-side API rate limiting (IP-based)
+ * Apply client-side API rate limiting (IP-based or sync-specific)
  */
-const applyClientRateLimit = async (customRateLimitConfig?: TRateLimitConfig): Promise<void> => {
-  await applyIPRateLimit(customRateLimitConfig ?? rateLimitConfigs.api.client);
+const applyClientRateLimit = async (url: string, customRateLimitConfig?: TRateLimitConfig): Promise<void> => {
+  const syncEndpoint = isSyncWithUserIdentificationEndpoint(url);
+  if (syncEndpoint) {
+    const syncRateLimitConfig = rateLimitConfigs.api.syncUserIdentification;
+    await applyRateLimit(syncRateLimitConfig, syncEndpoint.userId);
+  } else {
+    await applyIPRateLimit(customRateLimitConfig ?? rateLimitConfigs.api.client);
+  }
 };
 
 /**
  * Handle rate limiting based on authentication and API type
  */
 const handleRateLimiting = async (
+  url: string,
   authentication: TApiV1Authentication,
   routeType: ApiV1RouteTypeEnum,
   customRateLimitConfig?: TRateLimitConfig
@@ -76,7 +84,7 @@ const handleRateLimiting = async (
     }
 
     if (routeType === ApiV1RouteTypeEnum.Client) {
-      await applyClientRateLimit(customRateLimitConfig);
+      await applyClientRateLimit(url, customRateLimitConfig);
     }
   } catch (error) {
     return responses.tooManyRequestsResponse(error.message);
@@ -247,6 +255,7 @@ const getRouteType = (
  * Features:
  * - Performs authentication once and passes result to handler
  * - Applies API key-based rate limiting with differentiated limits for client vs management APIs
+ * - Includes additional sync user identification rate limiting for client-side sync endpoints
  * - Sets userId and organizationId in audit log automatically when audit logging is enabled
  * - System and Sentry logs are always called for non-success responses
  * - Uses function overloads to provide type safety without requiring type guards
@@ -319,7 +328,12 @@ export const withV1ApiWrapper: {
 
     // === Rate Limiting ===
     if (isRateLimited) {
-      const rateLimitResponse = await handleRateLimiting(authentication, routeType, customRateLimitConfig);
+      const rateLimitResponse = await handleRateLimiting(
+        req.nextUrl.pathname,
+        authentication,
+        routeType,
+        customRateLimitConfig
+      );
       if (rateLimitResponse) return rateLimitResponse;
     }
 

apps/web/app/lib/survey-block-builder.test.ts

@@ -1,80 +0,0 @@
-import type { TFunction } from "i18next";
-import { describe, expect, test, vi } from "vitest";
-import { TSurveyElementTypeEnum } from "@formbricks/types/surveys/elements";
-import { createI18nString } from "@/lib/i18n/utils";
-import { buildBlock } from "./survey-block-builder";
-
-const mockT = vi.fn((key: string) => {
-  const translations: Record<string, string> = {
-    "common.next": "Next",
-    "common.back": "Back",
-    "": "",
-  };
-  return translations[key] || key;
-}) as unknown as TFunction;
-
-describe("survey-block-builder", () => {
-  describe("buildBlock", () => {
-    const mockElements = [
-      {
-        id: "element-1",
-        type: TSurveyElementTypeEnum.OpenText,
-        headline: createI18nString("Test Question", []),
-        required: false,
-        inputType: "text",
-        longAnswer: false,
-        charLimit: { enabled: false },
-      },
-    ];
-
-    test("should use getDefaultButtonLabel when buttonLabel is provided", () => {
-      const result = buildBlock({
-        name: "Test Block",
-        elements: mockElements,
-        buttonLabel: "Custom Next",
-        t: mockT,
-      });
-
-      expect(result.buttonLabel).toEqual({
-        default: "Custom Next",
-      });
-    });
-
-    test("should use createI18nString with empty translation when buttonLabel is not provided", () => {
-      const result = buildBlock({
-        name: "Test Block",
-        elements: mockElements,
-        t: mockT,
-      });
-
-      expect(result.buttonLabel).toEqual({
-        default: "",
-      });
-    });
-
-    test("should use getDefaultBackButtonLabel when backButtonLabel is provided", () => {
-      const result = buildBlock({
-        name: "Test Block",
-        elements: mockElements,
-        backButtonLabel: "Custom Back",
-        t: mockT,
-      });
-
-      expect(result.backButtonLabel).toEqual({
-        default: "Custom Back",
-      });
-    });
-
-    test("should use createI18nString with empty translation when backButtonLabel is not provided", () => {
-      const result = buildBlock({
-        name: "Test Block",
-        elements: mockElements,
-        t: mockT,
-      });
-
-      expect(result.backButtonLabel).toEqual({
-        default: "",
-      });
-    });
-  });
-});

apps/web/app/lib/survey-block-builder.ts

@@ -302,9 +302,7 @@ export const buildBlock = ({
     elements,
     logic,
     logicFallback,
-    buttonLabel: buttonLabel ? getDefaultButtonLabel(buttonLabel, t) : createI18nString(t(""), []),
-    backButtonLabel: backButtonLabel
-      ? getDefaultBackButtonLabel(backButtonLabel, t)
-      : createI18nString(t(""), []),
+    buttonLabel: buttonLabel ? getDefaultButtonLabel(buttonLabel, t) : undefined,
+    backButtonLabel: backButtonLabel ? getDefaultBackButtonLabel(backButtonLabel, t) : undefined,
   };
 };

apps/web/app/lib/templates.ts

@@ -4848,14 +4848,12 @@ export const previewSurvey = (projectName: string, t: TFunction): TSurvey => {
                 t("templates.preview_survey_question_2_choice_2_label"),
               ],
               headline: t("templates.preview_survey_question_2_headline"),
-              subheader: t("templates.preview_survey_question_2_subheader"),
               required: true,
               shuffleOption: "none",
             }),
             isDraft: true,
           },
         ],
-        buttonLabel: createI18nString(t("templates.next"), []),
         backButtonLabel: createI18nString(t("templates.preview_survey_question_2_back_button_label"), []),
       },
       {

apps/web/app/middleware/endpoint-validator.test.ts

@@ -8,6 +8,7 @@ import {
   isManagementApiRoute,
   isPublicDomainRoute,
   isRouteAllowedForDomain,
+  isSyncWithUserIdentificationEndpoint,
 } from "./endpoint-validator";
 
 describe("endpoint-validator", () => {
@@ -269,6 +270,58 @@ describe("endpoint-validator", () => {
     });
   });
 
+  describe("isSyncWithUserIdentificationEndpoint", () => {
+    test("should return environmentId and userId for valid sync URLs", () => {
+      const result1 = isSyncWithUserIdentificationEndpoint("/api/v1/client/env123/app/sync/user456");
+      expect(result1).toEqual({
+        environmentId: "env123",
+        userId: "user456",
+      });
+
+      const result2 = isSyncWithUserIdentificationEndpoint("/api/v1/client/abc-123/app/sync/xyz-789");
+      expect(result2).toEqual({
+        environmentId: "abc-123",
+        userId: "xyz-789",
+      });
+
+      const result3 = isSyncWithUserIdentificationEndpoint(
+        "/api/v1/client/env_123_test/app/sync/user_456_test"
+      );
+      expect(result3).toEqual({
+        environmentId: "env_123_test",
+        userId: "user_456_test",
+      });
+    });
+
+    test("should handle optional trailing slash", () => {
+      // Test both with and without trailing slash
+      const result1 = isSyncWithUserIdentificationEndpoint("/api/v1/client/env123/app/sync/user456");
+      expect(result1).toEqual({
+        environmentId: "env123",
+        userId: "user456",
+      });
+
+      const result2 = isSyncWithUserIdentificationEndpoint("/api/v1/client/env123/app/sync/user456/");
+      expect(result2).toEqual({
+        environmentId: "env123",
+        userId: "user456",
+      });
+    });
+
+    test("should return false for invalid sync URLs", () => {
+      expect(isSyncWithUserIdentificationEndpoint("/api/v1/client/env123/app/sync")).toBe(false);
+      expect(isSyncWithUserIdentificationEndpoint("/api/v1/client/env123/something")).toBe(false);
+      expect(isSyncWithUserIdentificationEndpoint("/api/something")).toBe(false);
+      expect(isSyncWithUserIdentificationEndpoint("/api/v1/client/env123/app/other/user456")).toBe(false);
+      expect(isSyncWithUserIdentificationEndpoint("/api/v2/client/env123/app/sync/user456")).toBe(false); // only v1 supported
+    });
+
+    test("should handle empty or malformed IDs", () => {
+      expect(isSyncWithUserIdentificationEndpoint("/api/v1/client//app/sync/user456")).toBe(false);
+      expect(isSyncWithUserIdentificationEndpoint("/api/v1/client/env123/app/sync/")).toBe(false);
+    });
+  });
+
   describe("isPublicDomainRoute", () => {
     test("should return true for health endpoint", () => {
       expect(isPublicDomainRoute("/health")).toBe(true);
@@ -529,6 +582,12 @@ describe("endpoint-validator", () => {
       test("should handle special characters in survey IDs", () => {
         expect(isPublicDomainRoute("/s/survey-123_test.v2")).toBe(true);
         expect(isPublicDomainRoute("/c/jwt.token.with.dots")).toBe(true);
+        expect(
+          isSyncWithUserIdentificationEndpoint("/api/v1/client/env-123_test/app/sync/user-456_test")
+        ).toEqual({
+          environmentId: "env-123_test",
+          userId: "user-456_test",
+        });
       });
     });
 
@@ -569,6 +628,15 @@ describe("endpoint-validator", () => {
         const longSurveyId = "a".repeat(1000);
         const longPath = `s/${longSurveyId}`;
         expect(isPublicDomainRoute(`/${longPath}`)).toBe(true);
+
+        const longEnvironmentId = "env" + "a".repeat(1000);
+        const longUserId = "user" + "b".repeat(1000);
+        expect(
+          isSyncWithUserIdentificationEndpoint(`/api/v1/client/${longEnvironmentId}/app/sync/${longUserId}`)
+        ).toEqual({
+          environmentId: longEnvironmentId,
+          userId: longUserId,
+        });
       });
 
       test("should handle empty and minimal inputs", () => {
@@ -583,6 +651,7 @@ describe("endpoint-validator", () => {
         });
         expect(isIntegrationRoute("")).toBe(false);
         expect(isAuthProtectedRoute("")).toBe(false);
+        expect(isSyncWithUserIdentificationEndpoint("")).toBe(false);
       });
     });
 

apps/web/app/middleware/endpoint-validator.ts

@@ -43,6 +43,14 @@ export const isAuthProtectedRoute = (url: string): boolean => {
   return protectedRoutes.some((route) => url.startsWith(route));
 };
 
+export const isSyncWithUserIdentificationEndpoint = (
+  url: string
+): { environmentId: string; userId: string } | false => {
+  const regex = /\/api\/v1\/client\/(?<environmentId>[^/]+)\/app\/sync\/(?<userId>[^/]+)/;
+  const match = url.match(regex);
+  return match ? { environmentId: match.groups!.environmentId, userId: match.groups!.userId } : false;
+};
+
 /**
  * Check if the route should be accessible on the public domain (PUBLIC_URL)
  * Uses whitelist approach - only explicitly allowed routes are accessible

apps/web/app/storage/[environmentId]/[accessType]/[fileName]/route.ts

@@ -8,7 +8,7 @@ import { authorizePrivateDownload } from "@/app/storage/[environmentId]/[accessT
 import { authOptions } from "@/modules/auth/lib/authOptions";
 import { applyRateLimit } from "@/modules/core/rate-limit/helpers";
 import { rateLimitConfigs } from "@/modules/core/rate-limit/rate-limit-configs";
-import { deleteFile, getFileStreamForDownload } from "@/modules/storage/service";
+import { deleteFile, getSignedUrlForDownload } from "@/modules/storage/service";
 import { getErrorResponseFromStorageError } from "@/modules/storage/utils";
 import { logFileDeletion } from "./lib/audit-logs";
 
@@ -39,25 +39,21 @@ export const GET = async (
     }
   }
 
-  // Stream the file directly
-  const streamResult = await getFileStreamForDownload(fileName, environmentId, accessType);
+  const signedUrlResult = await getSignedUrlForDownload(fileName, environmentId, accessType);
 
-  if (!streamResult.ok) {
-    const errorResponse = getErrorResponseFromStorageError(streamResult.error, { fileName });
+  if (!signedUrlResult.ok) {
+    const errorResponse = getErrorResponseFromStorageError(signedUrlResult.error, { fileName });
     return errorResponse;
   }
 
-  const { body, contentType, contentLength } = streamResult.data;
-
-  return new Response(body, {
-    status: 200,
+  return new Response(null, {
+    status: 302,
     headers: {
-      "Content-Type": contentType,
-      ...(contentLength > 0 && { "Content-Length": String(contentLength) }),
+      Location: signedUrlResult.data,
       "Cache-Control":
         accessType === "private"
           ? "no-store, no-cache, must-revalidate"
-          : "public, max-age=31536000, immutable",
+          : "public, max-age=300, s-maxage=300, stale-while-revalidate=300",
     },
   });
 };

apps/web/i18n.json

@@ -9,18 +9,17 @@
     "source": "en-US",
     "targets": [
       "de-DE",
-      "es-ES",
       "fr-FR",
-      "hu-HU",
       "ja-JP",
-      "nl-NL",
       "pt-BR",
       "pt-PT",
       "ro-RO",
-      "ru-RU",
-      "sv-SE",
       "zh-Hans-CN",
-      "zh-Hant-TW"
+      "zh-Hant-TW",
+      "nl-NL",
+      "es-ES",
+      "sv-SE",
+      "ru-RU"
     ]
   },
   "version": 1.8

apps/web/instrumentation-node.ts

@@ -1,205 +1,59 @@
-// OpenTelemetry instrumentation for Next.js - loaded via instrumentation.ts hook
-// Pattern based on: ee/src/opentelemetry.ts (license server)
-import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+// instrumentation-node.ts
 import { PrometheusExporter } from "@opentelemetry/exporter-prometheus";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { NodeSDK } from "@opentelemetry/sdk-node";
+import { HostMetrics } from "@opentelemetry/host-metrics";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
+import { RuntimeNodeInstrumentation } from "@opentelemetry/instrumentation-runtime-node";
 import {
-  AlwaysOffSampler,
-  AlwaysOnSampler,
-  BatchSpanProcessor,
-  ParentBasedSampler,
-  type Sampler,
-  TraceIdRatioBasedSampler,
-} from "@opentelemetry/sdk-trace-base";
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
-import { PrismaInstrumentation } from "@prisma/instrumentation";
+  detectResources,
+  envDetector,
+  hostDetector,
+  processDetector,
+  resourceFromAttributes,
+} from "@opentelemetry/resources";
+import { MeterProvider } from "@opentelemetry/sdk-metrics";
 import { logger } from "@formbricks/logger";
+import { env } from "@/lib/env";
 
-// --- Configuration from environment ---
-const serviceName = process.env.OTEL_SERVICE_NAME || "formbricks";
-const serviceVersion = process.env.npm_package_version || "0.0.0";
-const environment = process.env.ENVIRONMENT || process.env.NODE_ENV || "development";
-const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-const prometheusEnabled = process.env.PROMETHEUS_ENABLED === "1";
-const prometheusPort = process.env.PROMETHEUS_EXPORTER_PORT
-  ? Number.parseInt(process.env.PROMETHEUS_EXPORTER_PORT)
-  : 9464;
-
-// --- Configure OTLP exporters (conditional on endpoint being set) ---
-let traceExporter: OTLPTraceExporter | undefined;
-let otlpMetricExporter: OTLPMetricExporter | undefined;
-
-if (otlpEndpoint) {
-  try {
-    // OTLPTraceExporter reads OTEL_EXPORTER_OTLP_ENDPOINT from env
-    // and appends /v1/traces for HTTP transport
-    // Uses OTEL_EXPORTER_OTLP_HEADERS from env natively (W3C OTel format: key=value,key2=value2)
-    traceExporter = new OTLPTraceExporter();
-
-    // OTLPMetricExporter reads OTEL_EXPORTER_OTLP_ENDPOINT from env
-    // and appends /v1/metrics for HTTP transport
-    // Uses OTEL_EXPORTER_OTLP_HEADERS from env natively
-    otlpMetricExporter = new OTLPMetricExporter();
-  } catch (error) {
-    logger.error(error, "Failed to create OTLP exporters. Telemetry will not be exported.");
-  }
-}
-
-// --- Configure Prometheus exporter (pull-based metrics for ServiceMonitor) ---
-let prometheusExporter: PrometheusExporter | undefined;
-if (prometheusEnabled) {
-  prometheusExporter = new PrometheusExporter({
-    port: prometheusPort,
-    endpoint: "/metrics",
-    host: "0.0.0.0",
-  });
-}
-
-// --- Build metric readers array ---
-const metricReaders: (PeriodicExportingMetricReader | PrometheusExporter)[] = [];
-
-if (otlpMetricExporter) {
-  metricReaders.push(
-    new PeriodicExportingMetricReader({
-      exporter: otlpMetricExporter,
-      exportIntervalMillis: 60000, // Export every 60 seconds
-    })
-  );
-}
-
-if (prometheusExporter) {
-  metricReaders.push(prometheusExporter);
-}
-
-// --- Resource attributes ---
-const resourceAttributes: Record<string, string> = {
-  [ATTR_SERVICE_NAME]: serviceName,
-  [ATTR_SERVICE_VERSION]: serviceVersion,
-  "deployment.environment": environment,
-};
-
-// --- Configure sampler ---
-const samplerType = process.env.OTEL_TRACES_SAMPLER || "always_on";
-const parsedSamplerArg = process.env.OTEL_TRACES_SAMPLER_ARG
-  ? Number.parseFloat(process.env.OTEL_TRACES_SAMPLER_ARG)
-  : undefined;
-const samplerArg =
-  parsedSamplerArg !== undefined && !Number.isNaN(parsedSamplerArg) ? parsedSamplerArg : undefined;
-
-let sampler: Sampler;
-switch (samplerType) {
-  case "always_on":
-    sampler = new AlwaysOnSampler();
-    break;
-  case "always_off":
-    sampler = new AlwaysOffSampler();
-    break;
-  case "traceidratio":
-    sampler = new TraceIdRatioBasedSampler(samplerArg ?? 1);
-    break;
-  case "parentbased_traceidratio":
-    sampler = new ParentBasedSampler({
-      root: new TraceIdRatioBasedSampler(samplerArg ?? 1),
-    });
-    break;
-  case "parentbased_always_on":
-    sampler = new ParentBasedSampler({
-      root: new AlwaysOnSampler(),
-    });
-    break;
-  case "parentbased_always_off":
-    sampler = new ParentBasedSampler({
-      root: new AlwaysOffSampler(),
-    });
-    break;
-  default:
-    logger.warn(`Unknown sampler type: ${samplerType}. Using always_on.`);
-    sampler = new AlwaysOnSampler();
-}
-
-// --- Initialize NodeSDK ---
-const sdk = new NodeSDK({
-  sampler,
-  resource: resourceFromAttributes(resourceAttributes),
-  // When no OTLP endpoint is configured (e.g. Prometheus-only setups), pass an empty
-  // spanProcessors array to prevent the SDK from falling back to its default OTLP exporter
-  // which would attempt connections to localhost:4318 and cause noisy errors.
-  spanProcessors: traceExporter
-    ? [
-        new BatchSpanProcessor(traceExporter, {
-          maxQueueSize: 2048,
-          maxExportBatchSize: 512,
-          scheduledDelayMillis: 5000,
-          exportTimeoutMillis: 30000,
-        }),
-      ]
-    : [],
-  metricReaders: metricReaders.length > 0 ? metricReaders : undefined,
-  instrumentations: [
-    getNodeAutoInstrumentations({
-      // Disable noisy/unnecessary instrumentations
-      "@opentelemetry/instrumentation-fs": {
-        enabled: false,
-      },
-      "@opentelemetry/instrumentation-dns": {
-        enabled: false,
-      },
-      "@opentelemetry/instrumentation-net": {
-        enabled: false,
-      },
-      // Disable pg instrumentation - PrismaInstrumentation handles DB tracing
-      "@opentelemetry/instrumentation-pg": {
-        enabled: false,
-      },
-      "@opentelemetry/instrumentation-http": {
-        // Ignore health/metrics endpoints to reduce noise
-        ignoreIncomingRequestHook: (req) => {
-          const url = req.url || "";
-          return url === "/health" || url.startsWith("/metrics") || url === "/api/v2/health";
-        },
-      },
-      // Enable runtime metrics for Node.js process monitoring
-      "@opentelemetry/instrumentation-runtime-node": {
-        enabled: true,
-      },
-    }),
-    // Prisma instrumentation for database query tracing
-    new PrismaInstrumentation(),
-  ],
+const exporter = new PrometheusExporter({
+  port: env.PROMETHEUS_EXPORTER_PORT ? parseInt(env.PROMETHEUS_EXPORTER_PORT) : 9464,
+  endpoint: "/metrics",
+  host: "0.0.0.0", // Listen on all network interfaces
 });
 
-// Start the SDK
-sdk.start();
+const detectedResources = detectResources({
+  detectors: [envDetector, processDetector, hostDetector],
+});
 
-// --- Log initialization status ---
-const enabledFeatures: string[] = [];
-if (traceExporter) enabledFeatures.push("traces");
-if (otlpMetricExporter) enabledFeatures.push("otlp-metrics");
-if (prometheusExporter) enabledFeatures.push("prometheus-metrics");
+const customResources = resourceFromAttributes({});
 
-const samplerArgStr = process.env.OTEL_TRACES_SAMPLER_ARG || "";
-const samplerArgMsg = samplerArgStr ? `, samplerArg=${samplerArgStr}` : "";
+const resources = detectedResources.merge(customResources);
 
-if (enabledFeatures.length > 0) {
-  logger.info(
-    `OpenTelemetry initialized: service=${serviceName}, version=${serviceVersion}, environment=${environment}, exporters=${enabledFeatures.join("+")}, sampler=${samplerType}${samplerArgMsg}`
-  );
-} else {
-  logger.info(
-    `OpenTelemetry initialized (no exporters): service=${serviceName}, version=${serviceVersion}, environment=${environment}`
-  );
-}
+const meterProvider = new MeterProvider({
+  readers: [exporter],
+  resource: resources,
+});
 
-// --- Graceful shutdown ---
-// Run before other SIGTERM listeners (logger flush, etc.) so spans are drained first.
-process.prependListener("SIGTERM", async () => {
+const hostMetrics = new HostMetrics({
+  name: `otel-metrics`,
+  meterProvider,
+});
+
+registerInstrumentations({
+  meterProvider,
+  instrumentations: [new HttpInstrumentation(), new RuntimeNodeInstrumentation()],
+});
+
+hostMetrics.start();
+
+process.on("SIGTERM", async () => {
   try {
-    await sdk.shutdown();
+    // Stop collecting metrics or flush them if needed
+    await meterProvider.shutdown();
+    // Possibly close other instrumentation resources
   } catch (e) {
-    logger.error(e, "Error during OpenTelemetry shutdown");
+    logger.error(e, "Error during graceful shutdown");
+  } finally {
+    process.exit(0);
   }
 });

apps/web/instrumentation.ts

@@ -5,13 +5,10 @@ export const onRequestError = Sentry.captureRequestError;
 
 export const register = async () => {
   if (process.env.NEXT_RUNTIME === "nodejs") {
-    // Load OpenTelemetry instrumentation when Prometheus metrics or OTLP export is enabled
-    if (PROMETHEUS_ENABLED || process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+    if (PROMETHEUS_ENABLED) {
       await import("./instrumentation-node");
     }
   }
-  // Sentry init loads after OTEL to avoid TracerProvider conflicts
-  // Sentry tracing is disabled (tracesSampleRate: 0) -- SigNoz handles distributed tracing
   if (process.env.NEXT_RUNTIME === "nodejs" && IS_PRODUCTION && SENTRY_DSN) {
     await import("./sentry.server.config");
   }

apps/web/lib/constants.ts

@@ -165,20 +165,19 @@ export const MAX_ATTRIBUTE_CLASSES_PER_ENVIRONMENT = 150;
 
 export const DEFAULT_LOCALE = "en-US";
 export const AVAILABLE_LOCALES: TUserLocale[] = [
-  "de-DE",
   "en-US",
-  "es-ES",
-  "fr-FR",
-  "hu-HU",
-  "ja-JP",
-  "nl-NL",
+  "de-DE",
   "pt-BR",
+  "fr-FR",
+  "nl-NL",
+  "zh-Hant-TW",
   "pt-PT",
   "ro-RO",
-  "ru-RU",
-  "sv-SE",
+  "ja-JP",
   "zh-Hans-CN",
-  "zh-Hant-TW",
+  "es-ES",
+  "sv-SE",
+  "ru-RU",
 ];
 
 // Billing constants

apps/web/lib/crypto.test.ts

@@ -444,11 +444,11 @@ describe("Crypto Utils", () => {
       expect(() => symmetricDecrypt(corruptedPayload, testKey)).toThrow();
 
       // Verify logger.warn was called with the correct format (object first, message second)
+      expect(logger.warn).toHaveBeenCalledWith(
+        { err: expect.any(Error) },
+        "AES-GCM decryption failed; refusing to fall back to insecure CBC"
+      );
       expect(logger.warn).toHaveBeenCalledTimes(1);
-      const [firstArg, secondArg] = vi.mocked(logger.warn).mock.calls[0];
-      expect(firstArg).toHaveProperty("err");
-      expect(firstArg.err).toHaveProperty("message");
-      expect(secondArg).toBe("AES-GCM decryption failed; refusing to fall back to insecure CBC");
     });
 
     test("logs warning and throws when GCM decryption fails with corrupted encrypted data", () => {
@@ -472,11 +472,11 @@ describe("Crypto Utils", () => {
       expect(() => symmetricDecrypt(corruptedPayload, testKey)).toThrow();
 
       // Verify logger.warn was called
+      expect(logger.warn).toHaveBeenCalledWith(
+        { err: expect.any(Error) },
+        "AES-GCM decryption failed; refusing to fall back to insecure CBC"
+      );
       expect(logger.warn).toHaveBeenCalledTimes(1);
-      const [firstArg, secondArg] = vi.mocked(logger.warn).mock.calls[0];
-      expect(firstArg).toHaveProperty("err");
-      expect(firstArg.err).toHaveProperty("message");
-      expect(secondArg).toBe("AES-GCM decryption failed; refusing to fall back to insecure CBC");
     });
 
     test("logs warning and throws when GCM decryption fails with wrong key", () => {
@@ -496,11 +496,11 @@ describe("Crypto Utils", () => {
       expect(() => symmetricDecrypt(payload, wrongKey)).toThrow();
 
       // Verify logger.warn was called
+      expect(logger.warn).toHaveBeenCalledWith(
+        { err: expect.any(Error) },
+        "AES-GCM decryption failed; refusing to fall back to insecure CBC"
+      );
       expect(logger.warn).toHaveBeenCalledTimes(1);
-      const [firstArg, secondArg] = vi.mocked(logger.warn).mock.calls[0];
-      expect(firstArg).toHaveProperty("err");
-      expect(firstArg.err).toHaveProperty("message");
-      expect(secondArg).toBe("AES-GCM decryption failed; refusing to fall back to insecure CBC");
     });
   });
 });

apps/web/lib/env.ts

@@ -55,6 +55,7 @@ export const env = createEnv({
     OIDC_DISPLAY_NAME: z.string().optional(),
     OIDC_ISSUER: z.string().optional(),
     OIDC_SIGNING_ALGORITHM: z.string().optional(),
+    OPENTELEMETRY_LISTENER_URL: z.string().optional(),
     REDIS_URL:
       process.env.NODE_ENV === "test"
         ? z.string().optional()
@@ -173,6 +174,7 @@ export const env = createEnv({
     NEXTAUTH_URL: process.env.NEXTAUTH_URL,
     NEXTAUTH_SECRET: process.env.NEXTAUTH_SECRET,
     SENTRY_DSN: process.env.SENTRY_DSN,
+    OPENTELEMETRY_LISTENER_URL: process.env.OPENTELEMETRY_LISTENER_URL,
     NOTION_OAUTH_CLIENT_ID: process.env.NOTION_OAUTH_CLIENT_ID,
     NOTION_OAUTH_CLIENT_SECRET: process.env.NOTION_OAUTH_CLIENT_SECRET,
     OIDC_CLIENT_ID: process.env.OIDC_CLIENT_ID,

apps/web/lib/environment/service.ts

@@ -167,12 +167,6 @@ export const createEnvironment = async (
               description: "Your contact's last name",
               type: "default",
             },
-            {
-              key: "language",
-              name: "Language",
-              description: "The language preference of a contact",
-              type: "default",
-            },
           ],
         },
       },

apps/web/lib/i18n/utils.ts

@@ -88,7 +88,7 @@ export const getLanguageCode = (surveyLanguages: TSurveyLanguage[], languageCode
   return language?.default ? "default" : language?.language.code || "default";
 };
 
-export const iso639Identifiers = iso639Languages.map((language) => language.code);
+export const iso639Identifiers = iso639Languages.map((language) => language.alpha2);
 
 // Helper function to add language keys to a multi-language object (e.g. survey or question)
 // Iterates over the object recursively and adds empty strings for new language keys
@@ -126,12 +126,6 @@ export const addMultiLanguageLabels = (object: unknown, languageSymbols: string[
 };
 
 export const appLanguages = [
-  {
-    code: "de-DE",
-    label: {
-      "en-US": "German",
-    },
-  },
   {
     code: "en-US",
     label: {
@@ -139,9 +133,15 @@ export const appLanguages = [
     },
   },
   {
-    code: "es-ES",
+    code: "de-DE",
     label: {
-      "en-US": "Spanish",
+      "en-US": "German",
+    },
+  },
+  {
+    code: "pt-BR",
+    label: {
+      "en-US": "Portuguese (Brazil)",
     },
   },
   {
@@ -151,27 +151,9 @@ export const appLanguages = [
     },
   },
   {
-    code: "hu-HU",
+    code: "zh-Hant-TW",
     label: {
-      "en-US": "Hungarian",
-    },
-  },
-  {
-    code: "ja-JP",
-    label: {
-      "en-US": "Japanese",
-    },
-  },
-  {
-    code: "nl-NL",
-    label: {
-      "en-US": "Dutch",
-    },
-  },
-  {
-    code: "pt-BR",
-    label: {
-      "en-US": "Portuguese (Brazil)",
+      "en-US": "Chinese (Traditional)",
     },
   },
   {
@@ -187,15 +169,9 @@ export const appLanguages = [
     },
   },
   {
-    code: "ru-RU",
+    code: "ja-JP",
     label: {
-      "en-US": "Russian",
-    },
-  },
-  {
-    code: "sv-SE",
-    label: {
-      "en-US": "Swedish",
+      "en-US": "Japanese",
     },
   },
   {
@@ -205,9 +181,27 @@ export const appLanguages = [
     },
   },
   {
-    code: "zh-Hant-TW",
+    code: "nl-NL",
     label: {
-      "en-US": "Chinese (Traditional)",
+      "en-US": "Dutch",
+    },
+  },
+  {
+    code: "es-ES",
+    label: {
+      "en-US": "Spanish",
+    },
+  },
+  {
+    code: "sv-SE",
+    label: {
+      "en-US": "Swedish",
+    },
+  },
+  {
+    code: "ru-RU",
+    label: {
+      "en-US": "Russian",
     },
   },
 ];

apps/web/lib/project/service.test.ts

@@ -48,7 +48,7 @@ describe("Project Service", () => {
       },
       placement: WidgetPlacement.bottomRight,
       clickOutsideClose: true,
-      overlay: "none",
+      darkOverlay: false,
       environments: [],
       styling: {
         allowStyleOverwrite: true,
@@ -106,7 +106,7 @@ describe("Project Service", () => {
       },
       placement: WidgetPlacement.bottomRight,
       clickOutsideClose: true,
-      overlay: "none",
+      darkOverlay: false,
       environments: [],
       styling: {
         allowStyleOverwrite: true,
@@ -171,7 +171,7 @@ describe("Project Service", () => {
         },
         placement: WidgetPlacement.bottomRight,
         clickOutsideClose: true,
-        overlay: "none",
+        darkOverlay: false,
         environments: [],
         styling: {
           allowStyleOverwrite: true,
@@ -196,7 +196,7 @@ describe("Project Service", () => {
         },
         placement: WidgetPlacement.bottomRight,
         clickOutsideClose: true,
-        overlay: "none",
+        darkOverlay: false,
         environments: [],
         styling: {
           allowStyleOverwrite: true,
@@ -250,7 +250,7 @@ describe("Project Service", () => {
         },
         placement: WidgetPlacement.bottomRight,
         clickOutsideClose: true,
-        overlay: "none",
+        darkOverlay: false,
         environments: [],
         styling: {
           allowStyleOverwrite: true,
@@ -324,7 +324,7 @@ describe("Project Service", () => {
         },
         placement: WidgetPlacement.bottomRight,
         clickOutsideClose: true,
-        overlay: "none",
+        darkOverlay: false,
         environments: [],
         styling: {
           allowStyleOverwrite: true,
@@ -378,7 +378,7 @@ describe("Project Service", () => {
         },
         placement: WidgetPlacement.bottomRight,
         clickOutsideClose: true,
-        overlay: "none",
+        darkOverlay: false,
         environments: [],
         styling: {
           allowStyleOverwrite: true,
@@ -403,7 +403,7 @@ describe("Project Service", () => {
         },
         placement: WidgetPlacement.bottomRight,
         clickOutsideClose: true,
-        overlay: "none",
+        darkOverlay: false,
         environments: [],
         styling: {
           allowStyleOverwrite: true,
@@ -448,7 +448,7 @@ describe("Project Service", () => {
         },
         placement: WidgetPlacement.bottomRight,
         clickOutsideClose: true,
-        overlay: "none",
+        darkOverlay: false,
         environments: [],
         styling: {
           allowStyleOverwrite: true,

apps/web/lib/project/service.ts

@@ -22,7 +22,7 @@ const selectProject = {
   config: true,
   placement: true,
   clickOutsideClose: true,
-  overlay: true,
+  darkOverlay: true,
   environments: true,
   styling: true,
   logo: true,

apps/web/lib/response/service.ts

@@ -22,7 +22,6 @@ import { getElementsFromBlocks } from "@/lib/survey/utils";
 import { getIsQuotasEnabled } from "@/modules/ee/license-check/lib/utils";
 import { reduceQuotaLimits } from "@/modules/ee/quotas/lib/quotas";
 import { deleteFile } from "@/modules/storage/service";
-import { resolveStorageUrlsInObject } from "@/modules/storage/utils";
 import { getOrganizationIdFromEnvironmentId } from "@/modules/survey/lib/organization";
 import { getOrganizationBilling } from "@/modules/survey/lib/survey";
 import { ITEMS_PER_PAGE } from "../constants";
@@ -409,10 +408,9 @@ export const getResponseDownloadFile = async (
     if (survey.isVerifyEmailEnabled) {
       headers.push("Verified Email");
     }
-    const resolvedResponses = responses.map((r) => ({ ...r, data: resolveStorageUrlsInObject(r.data) }));
     const jsonData = getResponsesJson(
       survey,
-      resolvedResponses,
+      responses,
       elements,
       userAttributes,
       hiddenFields,

apps/web/lib/styling/constants.ts

@@ -1,6 +1,5 @@
 // https://github.com/airbnb/javascript/#naming--uppercase
 import { TProjectStyling } from "@formbricks/types/project";
-import { isLight, mixColor } from "@/lib/utils/colors";
 
 export const COLOR_DEFAULTS = {
   brandColor: "#64748b",
@@ -12,210 +11,32 @@ export const COLOR_DEFAULTS = {
   highlightBorderColor: "#64748b",
 } as const;
 
-const DEFAULT_BRAND_COLOR = "#64748b";
-
-/**
- * Derives a complete set of suggested color values from a single brand color.
- *
- * Used by the project-level "Suggest Colors" button **and** to build
- * `STYLE_DEFAULTS` so that a fresh install always has colours that are
- * visually cohesive with the default brand.
- *
- * The returned object is a flat map of form-field paths to values so it
- * can be spread directly into form defaults or applied via `form.setValue`.
- */
-export const getSuggestedColors = (brandColor: string = DEFAULT_BRAND_COLOR) => {
-  // Question / dark text: brand darkened with black (visible brand tint)
-  const questionColor = mixColor(brandColor, "#000000", 0.35);
-  // Input / option background: white with noticeable brand tint
-  const inputBg = mixColor(brandColor, "#ffffff", 0.92);
-  // Input border: visible brand-tinted border
-  const inputBorder = mixColor(brandColor, "#ffffff", 0.6);
-  // Card tones
-  const cardBg = mixColor(brandColor, "#ffffff", 0.97);
-  const cardBorder = mixColor(brandColor, "#ffffff", 0.8);
-  // Page background
-  const pageBg = mixColor(brandColor, "#ffffff", 0.855);
-
-  return {
-    // General
-    "brandColor.light": brandColor,
-    "questionColor.light": questionColor,
-
-    // Headlines & Descriptions — use questionColor to match the legacy behaviour
-    // where all text elements derived their color from questionColor.
-    "elementHeadlineColor.light": questionColor,
-    "elementDescriptionColor.light": questionColor,
-    "elementUpperLabelColor.light": questionColor,
-
-    // Buttons — use the brand color so the button matches the user's intent.
-    "buttonBgColor.light": brandColor,
-    "buttonTextColor.light": isLight(brandColor) ? "#0f172a" : "#ffffff",
-
-    // Inputs
-    "inputColor.light": inputBg,
-    "inputBorderColor.light": inputBorder,
-    "inputTextColor.light": questionColor,
-
-    // Options (Radio / Checkbox)
-    "optionBgColor.light": inputBg,
-    "optionLabelColor.light": questionColor,
-
-    // Card
-    "cardBackgroundColor.light": cardBg,
-    "cardBorderColor.light": cardBorder,
-
-    // Highlight / Focus
-    "highlightBorderColor.light": mixColor(brandColor, "#ffffff", 0.25),
-
-    // Progress Bar — indicator uses the brand color; track is a lighter tint.
-    "progressIndicatorBgColor.light": brandColor,
-    "progressTrackBgColor.light": mixColor(brandColor, "#ffffff", 0.8),
-
-    // Background
-    background: { bg: pageBg, bgType: "color" as const, brightness: 100 },
-  };
-};
-
-// Pre-compute colors derived from the default brand color.
-const _colors = getSuggestedColors(DEFAULT_BRAND_COLOR);
-
-/**
- * Single source of truth for every styling default.
- *
- * Color values are derived from the default brand color (#64748b) via
- * `getSuggestedColors()`.  Non-color values (dimensions, weights, sizes)
- * are hardcoded here and must be kept in sync with globals.css.
- *
- * Used everywhere: form defaults, preview rendering, email templates,
- * and as the reset target for "Restore defaults".
- */
-export const STYLE_DEFAULTS: TProjectStyling = {
+export const defaultStyling: TProjectStyling = {
   allowStyleOverwrite: true,
-  brandColor: { light: _colors["brandColor.light"] },
-  questionColor: { light: _colors["questionColor.light"] },
-  inputColor: { light: _colors["inputColor.light"] },
-  inputBorderColor: { light: _colors["inputBorderColor.light"] },
-  cardBackgroundColor: { light: _colors["cardBackgroundColor.light"] },
-  cardBorderColor: { light: _colors["cardBorderColor.light"] },
+  brandColor: {
+    light: COLOR_DEFAULTS.brandColor,
+  },
+  questionColor: {
+    light: COLOR_DEFAULTS.questionColor,
+  },
+  inputColor: {
+    light: COLOR_DEFAULTS.inputColor,
+  },
+  inputBorderColor: {
+    light: COLOR_DEFAULTS.inputBorderColor,
+  },
+  cardBackgroundColor: {
+    light: COLOR_DEFAULTS.cardBackgroundColor,
+  },
+  cardBorderColor: {
+    light: COLOR_DEFAULTS.cardBorderColor,
+  },
   isLogoHidden: false,
-  highlightBorderColor: { light: _colors["highlightBorderColor.light"] },
+  highlightBorderColor: undefined,
   isDarkModeEnabled: false,
   roundness: 8,
-  cardArrangement: { linkSurveys: "simple", appSurveys: "simple" },
-
-  // Headlines & Descriptions
-  elementHeadlineColor: { light: _colors["elementHeadlineColor.light"] },
-  elementHeadlineFontSize: 16,
-  elementHeadlineFontWeight: 600,
-  elementDescriptionColor: { light: _colors["elementDescriptionColor.light"] },
-  elementDescriptionFontSize: 14,
-  elementDescriptionFontWeight: 400,
-  elementUpperLabelColor: { light: _colors["elementUpperLabelColor.light"] },
-  elementUpperLabelFontSize: 12,
-  elementUpperLabelFontWeight: 400,
-
-  // Inputs
-  inputTextColor: { light: _colors["inputTextColor.light"] },
-  inputBorderRadius: 8,
-  inputHeight: 20,
-  inputFontSize: 14,
-  inputPaddingX: 8,
-  inputPaddingY: 8,
-  inputPlaceholderOpacity: 0.5,
-  inputShadow: "0 1px 2px 0 rgb(0 0 0 / 0.05)",
-
-  // Buttons
-  buttonBgColor: { light: _colors["buttonBgColor.light"] },
-  buttonTextColor: { light: _colors["buttonTextColor.light"] },
-  buttonBorderRadius: 8,
-  buttonHeight: "auto",
-  buttonFontSize: 16,
-  buttonFontWeight: 500,
-  buttonPaddingX: 12,
-  buttonPaddingY: 12,
-
-  // Options
-  optionBgColor: { light: _colors["optionBgColor.light"] },
-  optionLabelColor: { light: _colors["optionLabelColor.light"] },
-  optionBorderRadius: 8,
-  optionPaddingX: 16,
-  optionPaddingY: 16,
-  optionFontSize: 14,
-
-  // Progress Bar
-  progressTrackHeight: 8,
-  progressTrackBgColor: { light: _colors["progressTrackBgColor.light"] },
-  progressIndicatorBgColor: { light: _colors["progressIndicatorBgColor.light"] },
-};
-
-/**
- * Fills in new v4.7 color fields from legacy v4.6 fields when they are missing.
- *
- * v4.6 stored: brandColor, questionColor, inputColor, inputBorderColor.
- * v4.7 adds: elementHeadlineColor, buttonBgColor, optionBgColor, etc.
- *
- * When loading v4.6 data the new fields are absent. Without this helper the
- * form would fall back to STYLE_DEFAULTS (derived from the *default* brand
- * colour), causing a visible mismatch.  This function derives the new fields
- * from the actually-saved legacy fields so the preview and form stay coherent.
- *
- * Only sets a field when the legacy source exists AND the new field is absent.
- */
-export const deriveNewFieldsFromLegacy = (saved: Record<string, unknown>): Record<string, unknown> => {
-  const light = (key: string): string | undefined =>
-    (saved[key] as { light?: string } | null | undefined)?.light;
-
-  const q = light("questionColor");
-  const b = light("brandColor");
-  const i = light("inputColor");
-
-  return {
-    ...(q && !saved.elementHeadlineColor && { elementHeadlineColor: { light: q } }),
-    ...(q && !saved.elementDescriptionColor && { elementDescriptionColor: { light: q } }),
-    ...(q && !saved.elementUpperLabelColor && { elementUpperLabelColor: { light: q } }),
-    ...(q && !saved.inputTextColor && { inputTextColor: { light: q } }),
-    ...(q && !saved.optionLabelColor && { optionLabelColor: { light: q } }),
-    ...(b && !saved.buttonBgColor && { buttonBgColor: { light: b } }),
-    ...(b && !saved.buttonTextColor && { buttonTextColor: { light: isLight(b) ? "#0f172a" : "#ffffff" } }),
-    ...(i && !saved.optionBgColor && { optionBgColor: { light: i } }),
-    ...(b && !saved.progressIndicatorBgColor && { progressIndicatorBgColor: { light: b } }),
-    ...(b &&
-      !saved.progressTrackBgColor && { progressTrackBgColor: { light: mixColor(b, "#ffffff", 0.8) } }),
-  };
-};
-
-/**
- * Builds a complete TProjectStyling object from a single brand color.
- *
- * Uses STYLE_DEFAULTS for all non-color properties (dimensions, weights, etc.)
- * and derives every color from the given brand color via getSuggestedColors().
- *
- * Useful when only a brand color is known (e.g. onboarding) and a fully
- * coherent styling object is needed for both preview rendering and persistence.
- */
-export const buildStylingFromBrandColor = (brandColor: string = DEFAULT_BRAND_COLOR): TProjectStyling => {
-  const colors = getSuggestedColors(brandColor);
-
-  return {
-    ...STYLE_DEFAULTS,
-    brandColor: { light: colors["brandColor.light"] },
-    questionColor: { light: colors["questionColor.light"] },
-    elementHeadlineColor: { light: colors["elementHeadlineColor.light"] },
-    elementDescriptionColor: { light: colors["elementDescriptionColor.light"] },
-    elementUpperLabelColor: { light: colors["elementUpperLabelColor.light"] },
-    buttonBgColor: { light: colors["buttonBgColor.light"] },
-    buttonTextColor: { light: colors["buttonTextColor.light"] },
-    inputColor: { light: colors["inputColor.light"] },
-    inputBorderColor: { light: colors["inputBorderColor.light"] },
-    inputTextColor: { light: colors["inputTextColor.light"] },
-    optionBgColor: { light: colors["optionBgColor.light"] },
-    optionLabelColor: { light: colors["optionLabelColor.light"] },
-    cardBackgroundColor: { light: colors["cardBackgroundColor.light"] },
-    cardBorderColor: { light: colors["cardBorderColor.light"] },
-    highlightBorderColor: { light: colors["highlightBorderColor.light"] },
-    progressIndicatorBgColor: { light: colors["progressIndicatorBgColor.light"] },
-    progressTrackBgColor: { light: colors["progressTrackBgColor.light"] },
-    background: colors.background,
-  };
+  cardArrangement: {
+    linkSurveys: "straight",
+    appSurveys: "straight",
+  },
 };

apps/web/lib/survey/__mock__/survey.mock.ts

@@ -85,7 +85,7 @@ export const mockProject: TProject = {
   inAppSurveyBranding: false,
   placement: "bottomRight",
   clickOutsideClose: false,
-  overlay: "none",
+  darkOverlay: false,
   environments: [],
   languages: [],
   config: {
@@ -168,7 +168,6 @@ export const mockContactAttributeKey: TContactAttributeKey = {
   type: "custom",
   description: "mock action class",
   isUnique: false,
-  dataType: "string",
   ...commonMockProperties,
 };
 

apps/web/lib/time.test.ts

@@ -141,68 +141,5 @@ describe("Time Utilities", () => {
       expect(convertDatesInObject("string")).toBe("string");
       expect(convertDatesInObject(123)).toBe(123);
     });
-
-    test("should not convert dates in ignored keys when keysToIgnore is provided", () => {
-      const keysToIgnore = new Set(["contactAttributes", "variables", "data", "meta"]);
-      const input = {
-        createdAt: "2024-03-20T15:30:00",
-        contactAttributes: {
-          createdAt: "2024-03-20T16:30:00",
-          email: "test@example.com",
-        },
-      };
-
-      const result = convertDatesInObject(input, keysToIgnore);
-      expect(result.createdAt).toBeInstanceOf(Date);
-      expect(result.contactAttributes.createdAt).toBe("2024-03-20T16:30:00");
-      expect(result.contactAttributes.email).toBe("test@example.com");
-    });
-
-    test("should not convert dates in variables when keysToIgnore is provided", () => {
-      const keysToIgnore = new Set(["contactAttributes", "variables", "data", "meta"]);
-      const input = {
-        updatedAt: "2024-03-20T15:30:00",
-        variables: {
-          createdAt: "2024-03-20T16:30:00",
-          userId: "123",
-        },
-      };
-
-      const result = convertDatesInObject(input, keysToIgnore);
-      expect(result.updatedAt).toBeInstanceOf(Date);
-      expect(result.variables.createdAt).toBe("2024-03-20T16:30:00");
-      expect(result.variables.userId).toBe("123");
-    });
-
-    test("should not convert dates in data or meta when keysToIgnore is provided", () => {
-      const keysToIgnore = new Set(["contactAttributes", "variables", "data", "meta"]);
-      const input = {
-        createdAt: "2024-03-20T15:30:00",
-        data: {
-          createdAt: "2024-03-20T16:30:00",
-        },
-        meta: {
-          updatedAt: "2024-03-20T17:30:00",
-        },
-      };
-
-      const result = convertDatesInObject(input, keysToIgnore);
-      expect(result.createdAt).toBeInstanceOf(Date);
-      expect(result.data.createdAt).toBe("2024-03-20T16:30:00");
-      expect(result.meta.updatedAt).toBe("2024-03-20T17:30:00");
-    });
-
-    test("should recurse into all keys when keysToIgnore is not provided", () => {
-      const input = {
-        createdAt: "2024-03-20T15:30:00",
-        contactAttributes: {
-          createdAt: "2024-03-20T16:30:00",
-        },
-      };
-
-      const result = convertDatesInObject(input);
-      expect(result.createdAt).toBeInstanceOf(Date);
-      expect(result.contactAttributes.createdAt).toBeInstanceOf(Date);
-    });
   });
 });

apps/web/lib/time.ts

@@ -1,5 +1,5 @@
 import { formatDistance, intlFormat } from "date-fns";
-import { de, enUS, es, fr, hu, ja, nl, pt, ptBR, ro, ru, sv, zhCN, zhTW } from "date-fns/locale";
+import { de, enUS, es, fr, ja, nl, pt, ptBR, ro, ru, sv, zhCN, zhTW } from "date-fns/locale";
 import { TUserLocale } from "@formbricks/types/user";
 
 export const convertDateString = (dateString: string | null) => {
@@ -87,30 +87,28 @@ const getLocaleForTimeSince = (locale: TUserLocale) => {
       return de;
     case "en-US":
       return enUS;
-    case "es-ES":
-      return es;
-    case "fr-FR":
-      return fr;
-    case "hu-HU":
-      return hu;
-    case "ja-JP":
-      return ja;
-    case "nl-NL":
-      return nl;
     case "pt-BR":
       return ptBR;
+    case "fr-FR":
+      return fr;
+    case "nl-NL":
+      return nl;
+    case "sv-SE":
+      return sv;
+    case "zh-Hant-TW":
+      return zhTW;
     case "pt-PT":
       return pt;
     case "ro-RO":
       return ro;
-    case "ru-RU":
-      return ru;
-    case "sv-SE":
-      return sv;
+    case "ja-JP":
+      return ja;
     case "zh-Hans-CN":
       return zhCN;
-    case "zh-Hant-TW":
-      return zhTW;
+    case "es-ES":
+      return es;
+    case "ru-RU":
+      return ru;
   }
 };
 
@@ -151,20 +149,16 @@ export const getTodaysDateTimeFormatted = (seperator: string) => {
   return [formattedDate, formattedTime].join(seperator);
 };
 
-export const convertDatesInObject = <T>(obj: T, keysToIgnore?: Set<string>): T => {
+export const convertDatesInObject = <T>(obj: T): T => {
   if (obj === null || typeof obj !== "object") {
     return obj; // Return if obj is not an object
   }
   if (Array.isArray(obj)) {
     // Handle arrays by mapping each element through the function
-    return obj.map((item) => convertDatesInObject(item, keysToIgnore)) as unknown as T;
+    return obj.map((item) => convertDatesInObject(item)) as unknown as T;
   }
-  const newObj: Record<string, unknown> = {};
+  const newObj: any = {};
   for (const key in obj) {
-    if (keysToIgnore?.has(key)) {
-      newObj[key] = obj[key];
-      continue;
-    }
     if (
       (key === "createdAt" || key === "updatedAt") &&
       typeof obj[key] === "string" &&
@@ -172,10 +166,10 @@ export const convertDatesInObject = <T>(obj: T, keysToIgnore?: Set<string>): T =
     ) {
       newObj[key] = new Date(obj[key] as unknown as string);
     } else if (typeof obj[key] === "object" && obj[key] !== null) {
-      newObj[key] = convertDatesInObject(obj[key], keysToIgnore);
+      newObj[key] = convertDatesInObject(obj[key]);
     } else {
       newObj[key] = obj[key];
     }
   }
-  return newObj as T;
+  return newObj;
 };

apps/web/lib/utils/action-client/index.test.ts

@@ -1,261 +0,0 @@
-import * as Sentry from "@sentry/nextjs";
-import { getServerSession } from "next-auth";
-import { DEFAULT_SERVER_ERROR_MESSAGE } from "next-safe-action";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import {
-  AuthenticationError,
-  AuthorizationError,
-  EXPECTED_ERROR_NAMES,
-  InvalidInputError,
-  OperationNotAllowedError,
-  ResourceNotFoundError,
-  TooManyRequestsError,
-  UnknownError,
-  ValidationError,
-  isExpectedError,
-} from "@formbricks/types/errors";
-
-// Mock Sentry
-vi.mock("@sentry/nextjs", () => ({
-  captureException: vi.fn(),
-}));
-
-// Mock logger — use plain functions for chained calls so vi.resetAllMocks() doesn't break them
-vi.mock("@formbricks/logger", () => ({
-  logger: {
-    withContext: () => ({ error: vi.fn() }),
-    warn: vi.fn(),
-  },
-}));
-
-// Mock next-auth
-vi.mock("next-auth", () => ({
-  getServerSession: vi.fn(),
-}));
-
-// Mock authOptions
-vi.mock("@/modules/auth/lib/authOptions", () => ({
-  authOptions: {},
-}));
-
-// Mock user service
-vi.mock("@/lib/user/service", () => ({
-  getUser: vi.fn(),
-}));
-
-// Mock client IP
-vi.mock("@/lib/utils/client-ip", () => ({
-  getClientIpFromHeaders: vi.fn(),
-}));
-
-// Mock constants
-vi.mock("@/lib/constants", () => ({
-  AUDIT_LOG_ENABLED: false,
-  AUDIT_LOG_GET_USER_IP: false,
-}));
-
-// Mock audit log types
-vi.mock("@/modules/ee/audit-logs/types/audit-log", () => ({
-  UNKNOWN_DATA: "unknown",
-}));
-
-// ── shared helper tests (pure logic, no action client needed) ──────────
-
-describe("isExpectedError (shared helper)", () => {
-  test("EXPECTED_ERROR_NAMES contains exactly the right error names", () => {
-    const expected = [
-      "ResourceNotFoundError",
-      "AuthorizationError",
-      "InvalidInputError",
-      "ValidationError",
-      "AuthenticationError",
-      "OperationNotAllowedError",
-      "TooManyRequestsError",
-    ];
-
-    expect(EXPECTED_ERROR_NAMES.size).toBe(expected.length);
-    for (const name of expected) {
-      expect(EXPECTED_ERROR_NAMES.has(name)).toBe(true);
-    }
-  });
-
-  test.each([
-    { ErrorClass: AuthorizationError, args: ["Not authorized"] },
-    { ErrorClass: AuthenticationError, args: ["Not authenticated"] },
-    { ErrorClass: TooManyRequestsError, args: ["Rate limit exceeded"] },
-    { ErrorClass: ResourceNotFoundError, args: ["Survey", "123"] },
-    { ErrorClass: InvalidInputError, args: ["Invalid input"] },
-    { ErrorClass: ValidationError, args: ["Invalid data"] },
-    { ErrorClass: OperationNotAllowedError, args: ["Not allowed"] },
-  ])("returns true for $ErrorClass.name", ({ ErrorClass, args }) => {
-    const error = new (ErrorClass as any)(...args);
-    expect(isExpectedError(error)).toBe(true);
-  });
-
-  test("returns true for serialised errors that only have a matching name", () => {
-    const serialisedError = new Error("Auth failed");
-    serialisedError.name = "AuthorizationError";
-    expect(isExpectedError(serialisedError)).toBe(true);
-  });
-
-  test.each([
-    { error: new Error("Something broke"), label: "Error" },
-    { error: new TypeError("Cannot read properties"), label: "TypeError" },
-    { error: new RangeError("Maximum call stack"), label: "RangeError" },
-    { error: new UnknownError("Unknown"), label: "UnknownError" },
-  ])("returns false for $label", ({ error }) => {
-    expect(isExpectedError(error)).toBe(false);
-  });
-});
-
-// ── integration tests against the real actionClient / authenticatedActionClient ──
-
-describe("actionClient handleServerError", () => {
-  // Lazily import so mocks are in place first
-  let actionClient: (typeof import("./index"))["actionClient"];
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    const mod = await import("./index");
-    actionClient = mod.actionClient;
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  // Helper: create and execute an action that throws the given error
-  const executeThrowingAction = async (error: Error) => {
-    const action = actionClient.action(async () => {
-      throw error;
-    });
-    return action();
-  };
-
-  describe("expected errors should NOT be reported to Sentry", () => {
-    test("AuthorizationError returns its message and is not sent to Sentry", async () => {
-      const result = await executeThrowingAction(new AuthorizationError("Not authorized"));
-      expect(result?.serverError).toBe("Not authorized");
-      expect(Sentry.captureException).not.toHaveBeenCalled();
-    });
-
-    test("AuthenticationError returns its message and is not sent to Sentry", async () => {
-      const result = await executeThrowingAction(new AuthenticationError("Not authenticated"));
-      expect(result?.serverError).toBe("Not authenticated");
-      expect(Sentry.captureException).not.toHaveBeenCalled();
-    });
-
-    test("TooManyRequestsError returns its message and is not sent to Sentry", async () => {
-      const result = await executeThrowingAction(new TooManyRequestsError("Rate limit exceeded"));
-      expect(result?.serverError).toBe("Rate limit exceeded");
-      expect(Sentry.captureException).not.toHaveBeenCalled();
-    });
-
-    test("ResourceNotFoundError returns its message and is not sent to Sentry", async () => {
-      const result = await executeThrowingAction(new ResourceNotFoundError("Survey", "123"));
-      expect(result?.serverError).toContain("Survey");
-      expect(Sentry.captureException).not.toHaveBeenCalled();
-    });
-
-    test("InvalidInputError returns its message and is not sent to Sentry", async () => {
-      const result = await executeThrowingAction(new InvalidInputError("Invalid input"));
-      expect(result?.serverError).toBe("Invalid input");
-      expect(Sentry.captureException).not.toHaveBeenCalled();
-    });
-
-    test("ValidationError returns its message and is not sent to Sentry", async () => {
-      const result = await executeThrowingAction(new ValidationError("Invalid data"));
-      expect(result?.serverError).toBe("Invalid data");
-      expect(Sentry.captureException).not.toHaveBeenCalled();
-    });
-
-    test("OperationNotAllowedError returns its message and is not sent to Sentry", async () => {
-      const result = await executeThrowingAction(new OperationNotAllowedError("Not allowed"));
-      expect(result?.serverError).toBe("Not allowed");
-      expect(Sentry.captureException).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("unexpected errors SHOULD be reported to Sentry", () => {
-    test("generic Error is sent to Sentry and returns default message", async () => {
-      const error = new Error("Something broke");
-      const result = await executeThrowingAction(error);
-      expect(result?.serverError).toBe(DEFAULT_SERVER_ERROR_MESSAGE);
-      expect(Sentry.captureException).toHaveBeenCalledWith(
-        error,
-        expect.objectContaining({ extra: expect.any(Object) })
-      );
-    });
-
-    test("TypeError is sent to Sentry and returns default message", async () => {
-      const error = new TypeError("Cannot read properties of undefined");
-      const result = await executeThrowingAction(error);
-      expect(result?.serverError).toBe(DEFAULT_SERVER_ERROR_MESSAGE);
-      expect(Sentry.captureException).toHaveBeenCalledWith(
-        error,
-        expect.objectContaining({ extra: expect.any(Object) })
-      );
-    });
-
-    test("UnknownError is sent to Sentry (not an expected business-logic error)", async () => {
-      const error = new UnknownError("Unknown error");
-      const result = await executeThrowingAction(error);
-      expect(result?.serverError).toBe(DEFAULT_SERVER_ERROR_MESSAGE);
-      expect(Sentry.captureException).toHaveBeenCalledWith(
-        error,
-        expect.objectContaining({ extra: expect.any(Object) })
-      );
-    });
-  });
-});
-
-describe("authenticatedActionClient", () => {
-  let authenticatedActionClient: (typeof import("./index"))["authenticatedActionClient"];
-  let getUser: (typeof import("@/lib/user/service"))["getUser"];
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    const mod = await import("./index");
-    authenticatedActionClient = mod.authenticatedActionClient;
-    const userService = await import("@/lib/user/service");
-    getUser = userService.getUser;
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  test("throws AuthenticationError when there is no session", async () => {
-    vi.mocked(getServerSession).mockResolvedValue(null);
-
-    const action = authenticatedActionClient.action(async () => "ok");
-    const result = await action();
-
-    // handleServerError catches AuthenticationError and returns its message
-    expect(result?.serverError).toBe("Not authenticated");
-    expect(Sentry.captureException).not.toHaveBeenCalled();
-  });
-
-  test("throws AuthorizationError when user is not found", async () => {
-    vi.mocked(getServerSession).mockResolvedValue({ user: { id: "user-1" } });
-    vi.mocked(getUser).mockResolvedValue(null as any);
-
-    const action = authenticatedActionClient.action(async () => "ok");
-    const result = await action();
-
-    expect(result?.serverError).toBe("User not found");
-    expect(Sentry.captureException).not.toHaveBeenCalled();
-  });
-
-  test("executes action successfully when session and user exist", async () => {
-    vi.mocked(getServerSession).mockResolvedValue({ user: { id: "user-1" } });
-    vi.mocked(getUser).mockResolvedValue({ id: "user-1", name: "Test" } as any);
-
-    const action = authenticatedActionClient.action(async () => "success");
-    const result = await action();
-
-    expect(result?.data).toBe("success");
-    expect(result?.serverError).toBeUndefined();
-    expect(Sentry.captureException).not.toHaveBeenCalled();
-  });
-});

apps/web/lib/utils/action-client/index.ts

@@ -3,7 +3,15 @@ import { getServerSession } from "next-auth";
 import { DEFAULT_SERVER_ERROR_MESSAGE, createSafeActionClient } from "next-safe-action";
 import { v4 as uuidv4 } from "uuid";
 import { logger } from "@formbricks/logger";
-import { AuthenticationError, AuthorizationError, isExpectedError } from "@formbricks/types/errors";
+import {
+  AuthenticationError,
+  AuthorizationError,
+  InvalidInputError,
+  OperationNotAllowedError,
+  ResourceNotFoundError,
+  TooManyRequestsError,
+  UnknownError,
+} from "@formbricks/types/errors";
 import { AUDIT_LOG_ENABLED, AUDIT_LOG_GET_USER_IP } from "@/lib/constants";
 import { getUser } from "@/lib/user/service";
 import { getClientIpFromHeaders } from "@/lib/utils/client-ip";
@@ -14,18 +22,24 @@ import { ActionClientCtx } from "./types/context";
 export const actionClient = createSafeActionClient({
   handleServerError(e, utils) {
     const eventId = (utils.ctx as Record<string, any>)?.auditLoggingCtx?.eventId ?? undefined; // keep explicit fallback
-
-    if (isExpectedError(e)) {
-      return e.message;
-    }
-
-    // Only capture unexpected errors to Sentry
     Sentry.captureException(e, {
       extra: {
         eventId,
       },
     });
 
+    if (
+      e instanceof ResourceNotFoundError ||
+      e instanceof AuthorizationError ||
+      e instanceof InvalidInputError ||
+      e instanceof UnknownError ||
+      e instanceof AuthenticationError ||
+      e instanceof OperationNotAllowedError ||
+      e instanceof TooManyRequestsError
+    ) {
+      return e.message;
+    }
+
     // eslint-disable-next-line no-console -- This error needs to be logged for debugging server-side errors
     logger.withContext({ eventId }).error(e, "SERVER ERROR");
     return DEFAULT_SERVER_ERROR_MESSAGE;

apps/web/lib/utils/safe-identifier.ts

@@ -11,16 +11,3 @@ export const isSafeIdentifier = (value: string): boolean => {
   // Can only contain lowercase letters, numbers, and underscores
   return /^[a-z0-9_]+$/.test(value);
 };
-
-/**
- * Converts a snake_case string to Title Case for display as a label.
- * Example: "job_description" -> "Job Description"
- *          "api_key" -> "Api Key"
- *          "signup_date" -> "Signup Date"
- */
-export const formatSnakeCaseToTitleCase = (key: string): string => {
-  return key
-    .split("_")
-    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-    .join(" ");
-};

apps/web/lib/utils/validate.ts

@@ -12,18 +12,11 @@ export function validateInputs<T extends ValidationPair<any>[]>(
   for (const [value, schema] of pairs) {
     const inputValidation = schema.safeParse(value);
     if (!inputValidation.success) {
-      const zodDetails = inputValidation.error.issues
-        .map((issue) => {
-          const path = issue?.path?.join(".") ?? "";
-          return `${path}${issue.message}`;
-        })
-        .join("; ");
-
       logger.error(
         inputValidation.error,
         `Validation failed for ${JSON.stringify(value).substring(0, 100)} and ${JSON.stringify(schema)}`
       );
-      throw new ValidationError(`Validation failed: ${zodDetails}`);
+      throw new ValidationError("Validation failed");
     }
     parsedData.push(inputValidation.data);
   }

apps/web/lingodotdev/server.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import { getLocale } from "@/lingodotdev/language";
 import { getTranslate } from "./server";
 
@@ -11,10 +11,6 @@ vi.mock("@/lingodotdev/shared", () => ({
 }));
 
 describe("lingodotdev server", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
   test("should get translate", async () => {
     vi.mocked(getLocale).mockResolvedValue("en-US");
     const translate = await getTranslate();
@@ -26,16 +22,4 @@ describe("lingodotdev server", () => {
     const translate = await getTranslate();
     expect(translate).toBeDefined();
   });
-
-  test("should use provided locale instead of calling getLocale", async () => {
-    const translate = await getTranslate("de-DE");
-    expect(getLocale).not.toHaveBeenCalled();
-    expect(translate).toBeDefined();
-  });
-
-  test("should call getLocale when locale is not provided", async () => {
-    vi.mocked(getLocale).mockResolvedValue("fr-FR");
-    await getTranslate();
-    expect(getLocale).toHaveBeenCalled();
-  });
 });

apps/web/lingodotdev/server.ts

@@ -2,7 +2,6 @@ import { createInstance } from "i18next";
 import ICU from "i18next-icu";
 import resourcesToBackend from "i18next-resources-to-backend";
 import { initReactI18next } from "react-i18next/initReactI18next";
-import { TUserLocale } from "@formbricks/types/user";
 import { DEFAULT_LOCALE } from "@/lib/constants";
 import { getLocale } from "@/lingodotdev/language";
 
@@ -22,9 +21,9 @@ const initI18next = async (lng: string) => {
   return i18nInstance;
 };
 
-export async function getTranslate(locale?: TUserLocale) {
-  const resolvedLocale = locale ?? (await getLocale());
+export async function getTranslate() {
+  const locale = await getLocale();
 
-  const i18nextInstance = await initI18next(resolvedLocale);
-  return i18nextInstance.getFixedT(resolvedLocale);
+  const i18nextInstance = await initI18next(locale);
+  return i18nextInstance.getFixedT(locale);
 }

apps/web/locales/de-DE.json

@@ -188,7 +188,6 @@
     "customer_success": "Kundenerfolg",
     "dark_overlay": "Dunkle Überlagerung",
     "date": "Datum",
-    "days": "Tage",
     "default": "Standard",
     "delete": "Löschen",
     "description": "Beschreibung",
@@ -244,6 +243,7 @@
     "imprint": "Impressum",
     "in_progress": "Im Gange",
     "inactive_surveys": "Inaktive Umfragen",
+    "input_type": "Eingabetyp",
     "integration": "Integration",
     "integrations": "Integrationen",
     "invalid_date": "Ungültiges Datum",
@@ -255,7 +255,6 @@
     "label": "Bezeichnung",
     "language": "Sprache",
     "learn_more": "Mehr erfahren",
-    "license_expired": "License Expired",
     "light_overlay": "Helle Überlagerung",
     "limits_reached": "Limits erreicht",
     "link": "Link",
@@ -268,15 +267,16 @@
     "look_and_feel": "Darstellung",
     "manage": "Verwalten",
     "marketing": "Marketing",
+    "maximum": "Maximal",
     "member": "Mitglied",
     "members": "Mitglieder",
     "members_and_teams": "Mitglieder & Teams",
     "membership_not_found": "Mitgliedschaft nicht gefunden",
     "metadata": "Metadaten",
+    "minimum": "Minimum",
     "mobile_overlay_app_works_best_on_desktop": "Formbricks funktioniert am besten auf einem größeren Bildschirm. Um Umfragen zu verwalten oder zu erstellen, wechsle zu einem anderen Gerät.",
     "mobile_overlay_surveys_look_good": "Keine Sorge – deine Umfragen sehen auf jedem Gerät und jeder Bildschirmgröße großartig aus!",
     "mobile_overlay_title": "Oops, Bildschirm zu klein erkannt!",
-    "months": "Monate",
     "move_down": "Nach unten bewegen",
     "move_up": "Nach oben bewegen",
     "multiple_languages": "Mehrsprachigkeit",
@@ -287,7 +287,6 @@
     "no_background_image_found": "Kein Hintergrundbild gefunden.",
     "no_code": "No Code",
     "no_files_uploaded": "Keine Dateien hochgeladen",
-    "no_overlay": "Kein Overlay",
     "no_quotas_found": "Keine Kontingente gefunden",
     "no_result_found": "Kein Ergebnis gefunden",
     "no_results": "Keine Ergebnisse",
@@ -314,7 +313,6 @@
     "organization_teams_not_found": "Organisations-Teams nicht gefunden",
     "other": "Andere",
     "others": "Andere",
-    "overlay_color": "Overlay-Farbe",
     "overview": "Überblick",
     "password": "Passwort",
     "paused": "Pausiert",
@@ -328,7 +326,7 @@
     "placeholder": "Platzhalter",
     "please_select_at_least_one_survey": "Bitte wähle mindestens eine Umfrage aus",
     "please_select_at_least_one_trigger": "Bitte wähle mindestens einen Auslöser aus",
-    "please_upgrade_your_plan": "Bitte aktualisieren Sie Ihren Plan",
+    "please_upgrade_your_plan": "Bitte upgrade deinen Plan.",
     "preview": "Vorschau",
     "preview_survey": "Umfragevorschau",
     "privacy": "Datenschutz",
@@ -354,7 +352,6 @@
     "request_trial_license": "Testlizenz anfordern",
     "reset_to_default": "Auf Standard zurücksetzen",
     "response": "Antwort",
-    "response_id": "Antwort-ID",
     "responses": "Antworten",
     "restart": "Neustart",
     "role": "Rolle",
@@ -395,7 +392,6 @@
     "status": "Status",
     "step_by_step_manual": "Schritt-für-Schritt-Anleitung",
     "storage_not_configured": "Dateispeicher nicht eingerichtet, Uploads werden wahrscheinlich fehlschlagen",
-    "string": "Text",
     "styling": "Styling",
     "submit": "Abschicken",
     "summary": "Zusammenfassung",
@@ -451,7 +447,6 @@
     "website_and_app_connection": "Website & App Verbindung",
     "website_app_survey": "Website- & App-Umfrage",
     "website_survey": "Website-Umfrage",
-    "weeks": "Wochen",
     "welcome_card": "Willkommenskarte",
     "workspace_configuration": "Projektkonfiguration",
     "workspace_created_successfully": "Projekt erfolgreich erstellt",
@@ -462,15 +457,13 @@
     "workspace_not_found": "Projekt nicht gefunden",
     "workspace_permission_not_found": "Projektberechtigung nicht gefunden",
     "workspaces": "Projekte",
-    "years": "Jahre",
     "you": "Du",
     "you_are_downgraded_to_the_community_edition": "Du wurdest auf die Community Edition herabgestuft.",
     "you_are_not_authorized_to_perform_this_action": "Du bist nicht berechtigt, diese Aktion durchzuführen.",
     "you_have_reached_your_limit_of_workspace_limit": "Sie haben Ihr Limit von {projectLimit} Workspaces erreicht.",
     "you_have_reached_your_monthly_miu_limit_of": "Du hast dein monatliches MIU-Limit erreicht",
     "you_have_reached_your_monthly_response_limit_of": "Du hast dein monatliches Antwortlimit erreicht",
-    "you_will_be_downgraded_to_the_community_edition_on_date": "Du wirst am {date} auf die Community Edition herabgestuft.",
-    "your_license_has_expired_please_renew": "Your enterprise license has expired. Please renew it to continue using enterprise features."
+    "you_will_be_downgraded_to_the_community_edition_on_date": "Du wirst am {date} auf die Community Edition herabgestuft."
   },
   "emails": {
     "accept": "Annehmen",
@@ -634,12 +627,6 @@
       "attribute_updated_successfully": "Attribut erfolgreich aktualisiert",
       "attribute_value": "Wert",
       "attribute_value_placeholder": "Attributwert",
-      "attributes_msg_attribute_limit_exceeded": "Es konnten {count} neue Attribute nicht erstellt werden, da dies das maximale Limit von {limit} Attributklassen überschreiten würde. Bestehende Attribute wurden erfolgreich aktualisiert.",
-      "attributes_msg_attribute_type_validation_error": "{error} (Attribut '{key}' hat dataType: {dataType})",
-      "attributes_msg_email_already_exists": "Die E-Mail existiert bereits für diese Umgebung und wurde nicht aktualisiert.",
-      "attributes_msg_email_or_userid_required": "Entweder E-Mail oder userId ist erforderlich. Die bestehenden Werte wurden beibehalten.",
-      "attributes_msg_new_attribute_created": "Neues Attribut '{key}' mit Typ '{dataType}' erstellt",
-      "attributes_msg_userid_already_exists": "Die userId existiert bereits für diese Umgebung und wurde nicht aktualisiert.",
       "contact_deleted_successfully": "Kontakt erfolgreich gelöscht",
       "contact_not_found": "Kein solcher Kontakt gefunden",
       "contacts_table_refresh": "Kontakte aktualisieren",
@@ -648,11 +635,6 @@
       "create_key": "Schlüssel erstellen",
       "create_new_attribute": "Neues Attribut erstellen",
       "create_new_attribute_description": "Erstellen Sie ein neues Attribut für Segmentierungszwecke.",
-      "custom_attributes": "Benutzerdefinierte Attribute",
-      "data_type": "Datentyp",
-      "data_type_cannot_be_changed": "Der Datentyp kann nach der Erstellung nicht mehr geändert werden",
-      "data_type_description": "Wähle aus, wie dieses Attribut gespeichert und gefiltert werden soll",
-      "date_value_required": "Ein Datumswert ist erforderlich. Verwende die Löschen-Schaltfläche, um dieses Attribut zu entfernen, wenn du kein Datum festlegen möchtest.",
       "delete_attribute_confirmation": "{value, plural, one {Dadurch wird das ausgewählte Attribut gelöscht. Alle mit diesem Attribut verknüpften Kontaktdaten gehen verloren.} other {Dadurch werden die ausgewählten Attribute gelöscht. Alle mit diesen Attributen verknüpften Kontaktdaten gehen verloren.}}",
       "delete_contact_confirmation": "Dies wird alle Umfrageantworten und Kontaktattribute löschen, die mit diesem Kontakt verbunden sind. Jegliche zielgerichtete Kommunikation und Personalisierung basierend auf den Daten dieses Kontakts gehen verloren.",
       "delete_contact_confirmation_with_quotas": "{value, plural, one {Dies wird alle Umfrageantworten und Kontaktattribute löschen, die mit diesem Kontakt verbunden sind. Jegliche zielgerichtete Kommunikation und Personalisierung basierend auf den Daten dieses Kontakts gehen verloren. Wenn dieser Kontakt Antworten hat, die zu den Umfragequoten zählen, werden die Quotenstände reduziert, aber die Quotenlimits bleiben unverändert.} other {Dies wird alle Umfrageantworten und Kontaktattribute löschen, die mit diesen Kontakten verbunden sind. Jegliche zielgerichtete Kommunikation und Personalisierung basierend auf den Daten dieses Kontakts gehen verloren. Wenn diesen Kontakten Antworten haben, die zu den Umfragequoten zählen, werden die Quotenstände reduziert, aber die Quotenlimits bleiben unverändert.}}",
@@ -660,18 +642,13 @@
       "edit_attribute_description": "Aktualisieren Sie die Bezeichnung und Beschreibung für dieses Attribut.",
       "edit_attribute_values": "Attribute bearbeiten",
       "edit_attribute_values_description": "Ändern Sie die Werte für bestimmte Attribute dieses Kontakts.",
-      "edit_attributes": "Attribute bearbeiten",
       "edit_attributes_success": "Kontaktattribute erfolgreich aktualisiert",
       "generate_personal_link": "Persönlichen Link generieren",
       "generate_personal_link_description": "Wähle eine veröffentlichte Umfrage aus, um einen personalisierten Link für diesen Kontakt zu generieren.",
-      "invalid_csv_column_names": "Ungültige CSV-Spaltennamen: {columns}. Spaltennamen, die zu neuen Attributen werden, dürfen nur Kleinbuchstaben, Zahlen und Unterstriche enthalten und müssen mit einem Buchstaben beginnen.",
-      "invalid_date_format": "Ungültiges Datumsformat. Bitte verwende ein gültiges Datum.",
-      "invalid_number_format": "Ungültiges Zahlenformat. Bitte gib eine gültige Zahl ein.",
       "no_published_link_surveys_available": "Keine veröffentlichten Link-Umfragen verfügbar. Bitte veröffentliche zuerst eine Link-Umfrage.",
       "no_published_surveys": "Keine veröffentlichten Umfragen",
       "no_responses_found": "Keine Antworten gefunden",
       "not_provided": "Nicht angegeben",
-      "number_value_required": "Zahlenwert ist erforderlich. Verwende die Löschen-Schaltfläche, um dieses Attribut zu entfernen.",
       "personal_link_generated": "Persönlicher Link erfolgreich generiert",
       "personal_link_generated_but_clipboard_failed": "Persönlicher Link wurde generiert, konnte aber nicht in die Zwischenablage kopiert werden: {url}",
       "personal_survey_link": "Link zur persönlichen Umfrage",
@@ -680,22 +657,13 @@
       "search_contact": "Kontakt suchen",
       "select_a_survey": "Wähle eine Umfrage aus",
       "select_attribute": "Attribut auswählen",
-      "select_attribute_key": "Attributschlüssel auswählen",
-      "system_attributes": "Systemattribute",
       "unlock_contacts_description": "Verwalte Kontakte und sende gezielte Umfragen",
       "unlock_contacts_title": "Kontakte mit einem höheren Plan freischalten",
-      "upload_contacts_error_attribute_type_mismatch": "Attribut \"{key}\" ist als \"{dataType}\" definiert, aber die CSV-Datei enthält ungültige Werte: {values}",
-      "upload_contacts_error_duplicate_mappings": "Doppelte Zuordnungen für folgende Attribute gefunden: {attributes}",
-      "upload_contacts_error_file_too_large": "Dateigröße überschreitet das maximale Limit von 800KB",
-      "upload_contacts_error_generic": "Beim Hochladen der Kontakte ist ein Fehler aufgetreten. Bitte versuche es später erneut.",
-      "upload_contacts_error_invalid_file_type": "Bitte lade eine CSV-Datei hoch",
-      "upload_contacts_error_no_valid_contacts": "Die hochgeladene CSV-Datei enthält keine gültigen Kontakte. Bitte schaue dir die Beispiel-CSV-Datei für das richtige Format an.",
-      "upload_contacts_modal_attribute_header": "Formbricks-Attribut",
       "upload_contacts_modal_attributes_description": "Ordne die Spalten in deiner CSV den Attributen in Formbricks zu.",
       "upload_contacts_modal_attributes_new": "Neues Attribut",
       "upload_contacts_modal_attributes_search_or_add": "Attribut suchen oder hinzufügen",
+      "upload_contacts_modal_attributes_should_be_mapped_to": "sollte zugeordnet werden zu",
       "upload_contacts_modal_attributes_title": "Attribute",
-      "upload_contacts_modal_csv_column_header": "CSV-Spalte",
       "upload_contacts_modal_description": "Lade eine CSV hoch, um Kontakte mit Attributen schnell zu importieren",
       "upload_contacts_modal_download_example_csv": "Beispiel-CSV herunterladen",
       "upload_contacts_modal_duplicates_description": "Wie sollen wir vorgehen, wenn ein Kontakt bereits existiert?",
@@ -876,40 +844,6 @@
       "no_attributes_yet": "Noch keine Attribute",
       "no_filters_yet": "Es gibt noch keine Filter",
       "no_segments_yet": "Du hast momentan keine gespeicherten Segmente.",
-      "operator_contains": "enthält",
-      "operator_does_not_contain": "enthält nicht",
-      "operator_ends_with": "endet mit",
-      "operator_is_after": "ist nach",
-      "operator_is_before": "ist vor",
-      "operator_is_between": "ist zwischen",
-      "operator_is_newer_than": "ist neuer als",
-      "operator_is_not_set": "ist nicht festgelegt",
-      "operator_is_older_than": "ist älter als",
-      "operator_is_same_day": "ist am selben Tag",
-      "operator_is_set": "ist festgelegt",
-      "operator_starts_with": "fängt an mit",
-      "operator_title_contains": "Enthält",
-      "operator_title_does_not_contain": "Enthält nicht",
-      "operator_title_ends_with": "Endet mit",
-      "operator_title_equals": "Gleich",
-      "operator_title_greater_equal": "Größer als oder gleich",
-      "operator_title_greater_than": "Größer als",
-      "operator_title_is_after": "Ist nach",
-      "operator_title_is_before": "Ist vor",
-      "operator_title_is_between": "Ist zwischen",
-      "operator_title_is_newer_than": "Ist neuer als",
-      "operator_title_is_not_set": "Ist nicht festgelegt",
-      "operator_title_is_older_than": "Ist älter als",
-      "operator_title_is_same_day": "Ist am selben Tag",
-      "operator_title_is_set": "Ist festgelegt",
-      "operator_title_less_equal": "Kleiner oder gleich",
-      "operator_title_less_than": "Kleiner als",
-      "operator_title_not_equals": "Ist nicht gleich",
-      "operator_title_starts_with": "Fängt an mit",
-      "operator_title_user_is_in": "Nutzer ist in",
-      "operator_title_user_is_not_in": "Nutzer ist nicht in",
-      "operator_user_is_in": "Nutzer ist in",
-      "operator_user_is_not_in": "Nutzer ist nicht in",
       "person_and_attributes": "Person & Attribute",
       "phone": "Handy",
       "please_remove_the_segment_from_these_surveys_in_order_to_delete_it": "Bitte entferne das Segment aus diesen Umfragen, um es zu löschen.",
@@ -934,7 +868,6 @@
       "user_targeting_is_currently_only_available_when": "Benutzerzielgruppen sind derzeit nur verfügbar, wenn",
       "value_cannot_be_empty": "Wert darf nicht leer sein.",
       "value_must_be_a_number": "Wert muss eine Zahl sein.",
-      "value_must_be_positive": "Wert muss eine positive Zahl sein.",
       "view_filters": "Filter anzeigen",
       "where": "Wo",
       "with_the_formbricks_sdk": "mit dem Formbricks SDK"
@@ -1021,32 +954,19 @@
         "enterprise_features": "Unternehmensfunktionen",
         "get_an_enterprise_license_to_get_access_to_all_features": "Hol dir eine Enterprise-Lizenz, um Zugriff auf alle Funktionen zu erhalten.",
         "keep_full_control_over_your_data_privacy_and_security": "Behalte die volle Kontrolle über deine Daten, Privatsphäre und Sicherheit.",
-        "license_invalid_description": "Der Lizenzschlüssel in deiner ENTERPRISE_LICENSE_KEY-Umgebungsvariable ist nicht gültig. Bitte überprüfe auf Tippfehler oder fordere einen neuen Schlüssel an.",
-        "license_status": "Lizenzstatus",
-        "license_status_active": "Aktiv",
-        "license_status_description": "Status deiner Enterprise-Lizenz.",
-        "license_status_expired": "Abgelaufen",
-        "license_status_invalid": "Ungültige Lizenz",
-        "license_status_unreachable": "Nicht erreichbar",
-        "license_unreachable_grace_period": "Der Lizenzserver ist nicht erreichbar. Deine Enterprise-Funktionen bleiben während einer 3-tägigen Kulanzfrist bis zum {gracePeriodEnd} aktiv.",
         "no_call_needed_no_strings_attached_request_a_free_30_day_trial_license_to_test_all_features_by_filling_out_this_form": "Ganz unkompliziert: Fordere eine kostenlose 30-Tage-Testlizenz an, um alle Funktionen zu testen, indem Du dieses Formular ausfüllst:",
         "no_credit_card_no_sales_call_just_test_it": "Keine Kreditkarte. Kein Verkaufsgespräch. Einfach testen :)",
         "on_request": "Auf Anfrage",
         "organization_roles": "Organisationsrollen (Admin, Editor, Entwickler, etc.)",
         "questions_please_reach_out_to": "Fragen? Bitte melde Dich bei",
-        "recheck_license": "Lizenz erneut prüfen",
-        "recheck_license_failed": "Lizenzprüfung fehlgeschlagen. Der Lizenzserver ist möglicherweise nicht erreichbar.",
-        "recheck_license_invalid": "Der Lizenzschlüssel ist ungültig. Bitte überprüfe deinen ENTERPRISE_LICENSE_KEY.",
-        "recheck_license_success": "Lizenzprüfung erfolgreich",
-        "recheck_license_unreachable": "Lizenzserver ist nicht erreichbar. Bitte versuche es später erneut.",
-        "rechecking": "Wird erneut geprüft...",
         "request_30_day_trial_license": "30-Tage-Testlizenz anfordern",
         "saml_sso": "SAML-SSO",
         "service_level_agreement": "Service-Level-Vereinbarung",
         "soc2_hipaa_iso_27001_compliance_check": "SOC2-, HIPAA- und ISO 27001-Konformitätsprüfung",
         "sso": "SSO (Google, Microsoft, OpenID Connect)",
         "teams": "Teams & Zugriffskontrolle (Lesen, Lesen & Schreiben, Verwalten)",
-        "unlock_the_full_power_of_formbricks_free_for_30_days": "Schalte die volle Power von Formbricks frei. 30 Tage kostenlos."
+        "unlock_the_full_power_of_formbricks_free_for_30_days": "Schalte die volle Power von Formbricks frei. 30 Tage kostenlos.",
+        "your_enterprise_license_is_active_all_features_unlocked": "Deine Unternehmenslizenz ist aktiv. Alle Funktionen freigeschaltet."
       },
       "general": {
         "bulk_invite_warning_description": "Bitte beachte, dass im Free-Plan alle Organisationsmitglieder automatisch die Rolle \"Owner\" zugewiesen bekommen, unabhängig von der im CSV-File angegebenen Rolle.",
@@ -1070,7 +990,7 @@
         "from_your_organization": "von deiner Organisation",
         "invitation_sent_once_more": "Einladung nochmal gesendet.",
         "invite_deleted_successfully": "Einladung erfolgreich gelöscht",
-        "invite_expires_on": "Einladung läuft ab am {date}",
+        "invited_on": "Eingeladen am {date}",
         "invites_failed": "Einladungen fehlgeschlagen",
         "leave_organization": "Organisation verlassen",
         "leave_organization_description": "Du wirst diese Organisation verlassen und den Zugriff auf alle Umfragen und Antworten verlieren. Du kannst nur wieder beitreten, wenn Du erneut eingeladen wirst.",
@@ -1183,6 +1103,8 @@
         "please_fill_all_workspace_fields": "Bitte füllen Sie alle Felder aus, um einen neuen Workspace hinzuzufügen.",
         "read": "Lesen",
         "read_write": "Lesen & Schreiben",
+        "select_member": "Mitglied auswählen",
+        "select_workspace": "Workspace auswählen",
         "team_admin": "Team-Admin",
         "team_created_successfully": "Team erfolgreich erstellt.",
         "team_deleted_successfully": "Team erfolgreich gelöscht.",
@@ -1232,6 +1154,7 @@
         "add_fallback_placeholder": "Platzhalter hinzufügen, falls kein Wert zur Verfügung steht.",
         "add_hidden_field_id": "Verstecktes Feld ID hinzufügen",
         "add_highlight_border": "Rahmen hinzufügen",
+        "add_highlight_border_description": "Füge deiner Umfragekarte einen äußeren Rahmen hinzu.",
         "add_logic": "Logik hinzufügen",
         "add_none_of_the_above": "Füge \"Keine der oben genannten Optionen\" hinzu",
         "add_option": "Option hinzufügen",
@@ -1249,6 +1172,7 @@
         "adjust_survey_closed_message_description": "Ändere die Nachricht, die Besucher sehen, wenn die Umfrage geschlossen ist.",
         "adjust_the_theme_in_the": "Passe das Thema an in den",
         "all_other_answers_will_continue_to": "Alle anderen Antworten werden weiterhin",
+        "allow_file_type": "Dateityp begrenzen",
         "allow_multi_select": "Mehrfachauswahl erlauben",
         "allow_multiple_files": "Mehrere Dateien zulassen",
         "allow_users_to_select_more_than_one_image": "Erlaube Nutzern, mehr als ein Bild auszuwählen",
@@ -1270,7 +1194,6 @@
         "block_duplicated": "Block dupliziert.",
         "bold": "Fett",
         "brand_color": "Markenfarbe",
-        "brand_color_description": "Wird auf Buttons, Links und Hervorhebungen angewendet.",
         "brightness": "Helligkeit",
         "bulk_edit": "Massenbearbeitung",
         "bulk_edit_description": "Bearbeiten Sie alle Optionen unten, eine pro Zeile. Leere Zeilen werden übersprungen und Duplikate entfernt.",
@@ -1288,9 +1211,7 @@
         "capture_new_action": "Neue Aktion erfassen",
         "card_arrangement_for_survey_type_derived": "Kartenanordnung für {surveyTypeDerived} Umfragen",
         "card_background_color": "Hintergrundfarbe der Karte",
-        "card_background_color_description": "Füllt den Bereich der Umfragekarte.",
         "card_border_color": "Farbe des Kartenrandes",
-        "card_border_color_description": "Umrandet die Umfragekarte.",
         "card_styling": "Kartengestaltung",
         "casual": "Lässig",
         "caution_edit_duplicate": "Duplizieren & bearbeiten",
@@ -1301,14 +1222,24 @@
         "caution_explanation_responses_are_safe": "Ältere und neuere Antworten vermischen sich, was zu irreführenden Datensummen führen kann.",
         "caution_recommendation": "Dies kann im Umfrageübersicht zu Dateninkonsistenzen führen. Wir empfehlen stattdessen, die Umfrage zu duplizieren.",
         "caution_text": "Änderungen werden zu Inkonsistenzen führen",
+        "centered_modal_overlay_color": "Zentrierte modale Überlagerungsfarbe",
         "change_anyway": "Trotzdem ändern",
         "change_background": "Hintergrund ändern",
         "change_question_type": "Fragetyp ändern",
         "change_survey_type": "Die Änderung des Umfragetypen kann vorhandenen Zugriff beeinträchtigen",
+        "change_the_background_color_of_the_card": "Hintergrundfarbe der Karte ändern.",
+        "change_the_background_color_of_the_input_fields": "Hintergrundfarbe der Eingabefelder ändern.",
         "change_the_background_to_a_color_image_or_animation": "Hintergrund zu einer Farbe, einem Bild oder einer Animation ändern.",
+        "change_the_border_color_of_the_card": "Randfarbe der Karte ändern.",
+        "change_the_border_color_of_the_input_fields": "Randfarbe der Eingabefelder ändern.",
+        "change_the_border_radius_of_the_card_and_the_inputs": "Radius der Ränder der Karte und der Eingabefelder ändern.",
+        "change_the_brand_color_of_the_survey": "Markenfarbe der Umfrage ändern.",
         "change_the_placement_of_this_survey": "Platzierung dieser Umfrage ändern.",
+        "change_the_question_color_of_the_survey": "Fragefarbe der Umfrage ändern.",
         "changes_saved": "Änderungen gespeichert.",
         "changing_survey_type_will_remove_existing_distribution_channels": "\"Das Ändern des Umfragetypen beeinflusst, wie er geteilt werden kann. Wenn Teilnehmer bereits Zugriffslinks für den aktuellen Typ haben, könnten sie das Zugriffsrecht nach dem Wechsel verlieren.\"",
+        "character_limit_toggle_description": "Begrenzen Sie, wie kurz oder lang eine Antwort sein kann.",
+        "character_limit_toggle_title": "Fügen Sie Zeichenbeschränkungen hinzu",
         "checkbox_label": "Checkbox-Beschriftung",
         "choose_the_actions_which_trigger_the_survey": "Aktionen auswählen, die die Umfrage auslösen.",
         "choose_the_first_question_on_your_block": "Wählen sie die erste frage in ihrem block",
@@ -1328,6 +1259,7 @@
         "contact_fields": "Kontaktfelder",
         "contains": "enthält",
         "continue_to_settings": "Weiter zu den Einstellungen",
+        "control_which_file_types_can_be_uploaded": "Steuere, welche Dateitypen hochgeladen werden können.",
         "convert_to_multiple_choice": "In Multiple-Choice umwandeln",
         "convert_to_single_choice": "In Einzelauswahl umwandeln",
         "country": "Land",
@@ -1340,13 +1272,11 @@
         "darken_or_lighten_background_of_your_choice": "Hintergrund deiner Wahl abdunkeln oder aufhellen.",
         "date_format": "Datumsformat",
         "days_before_showing_this_survey_again": "oder mehr Tage müssen zwischen der zuletzt angezeigten Umfrage und der Anzeige dieser Umfrage vergehen.",
-        "delete_anyways": "Trotzdem löschen",
         "delete_block": "Block löschen",
         "delete_choice": "Auswahl löschen",
         "disable_the_visibility_of_survey_progress": "Deaktiviere die Sichtbarkeit des Umfragefortschritts.",
         "display_an_estimate_of_completion_time_for_survey": "Zeige eine Schätzung der Fertigstellungszeit für die Umfrage an",
         "display_number_of_responses_for_survey": "Anzahl der Antworten für Umfrage anzeigen",
-        "display_type": "Anzeigetyp",
         "divide": "Teilen /",
         "does_not_contain": "Enthält nicht",
         "does_not_end_with": "Endet nicht mit",
@@ -1354,7 +1284,6 @@
         "does_not_include_all_of": "Enthält nicht alle von",
         "does_not_include_one_of": "Enthält nicht eines von",
         "does_not_start_with": "Fängt nicht an mit",
-        "dropdown": "Dropdown",
         "duplicate_block": "Block duplizieren",
         "duplicate_question": "Frage duplizieren",
         "edit_link": "Bearbeitungslink",
@@ -1446,7 +1375,8 @@
         "hide_progress_bar": "Fortschrittsbalken ausblenden",
         "hide_question_settings": "Frageeinstellungen ausblenden",
         "hostname": "Hostname",
-        "if_you_need_more_please": "Wenn Sie mehr benötigen, bitte",
+        "how_funky_do_you_want_your_cards_in_survey_type_derived_surveys": "Wie funky sollen deine Karten in {surveyTypeDerived} Umfragen sein",
+        "if_you_need_more_please": "Wenn Du mehr brauchst, bitte",
         "if_you_really_want_that_answer_ask_until_you_get_it": "Weiterhin anzeigen, wenn ausgelöst, bis eine Antwort abgegeben wird.",
         "ignore_global_waiting_time": "Abkühlphase ignorieren",
         "ignore_global_waiting_time_description": "Diese Umfrage kann angezeigt werden, wenn ihre Bedingungen erfüllt sind, auch wenn kürzlich eine andere Umfrage angezeigt wurde.",
@@ -1456,9 +1386,7 @@
         "initial_value": "Anfangswert",
         "inner_text": "Innerer Text",
         "input_border_color": "Randfarbe des Eingabefelds",
-        "input_border_color_description": "Umrandet Texteingaben und Textbereiche.",
         "input_color": "Farbe des Eingabefelds",
-        "input_color_description": "Füllt das Innere von Texteingaben.",
         "insert_link": "Link einfügen",
         "invalid_targeting": "Ungültiges Targeting: Bitte überprüfe deine Zielgruppenfilter",
         "invalid_video_url_warning": "Bitte gib eine gültige YouTube-, Vimeo- oder Loom-URL ein. Andere Video-Plattformen werden derzeit nicht unterstützt.",
@@ -1485,10 +1413,10 @@
         "key": "Schlüssel",
         "last_name": "Nachname",
         "let_people_upload_up_to_25_files_at_the_same_time": "Erlaube bis zu 25 Dateien gleichzeitig hochzuladen.",
-        "limit_the_maximum_file_size": "Begrenzen Sie die maximale Dateigröße für Uploads.",
-        "limit_upload_file_size_to": "Upload-Dateigröße begrenzen auf",
+        "limit_file_types": "Dateitypen einschränken",
+        "limit_the_maximum_file_size": "Maximale Dateigröße begrenzen",
+        "limit_upload_file_size_to": "Maximale Dateigröße für Uploads",
         "link_survey_description": "Teile einen Link zu einer Umfrageseite oder bette ihn in eine Webseite oder E-Mail ein.",
-        "list": "Liste",
         "load_segment": "Segment laden",
         "logic_error_warning": "Änderungen werden zu Logikfehlern führen",
         "logic_error_warning_text": "Das Ändern des Fragetypen entfernt die Logikbedingungen von dieser Frage",
@@ -1499,8 +1427,8 @@
         "manage_languages": "Sprachen verwalten",
         "matrix_all_fields": "Alle Felder",
         "matrix_rows": "Zeilen",
-        "max_file_size": "Maximale Dateigröße",
-        "max_file_size_limit_is": "Die maximale Dateigrößenbeschränkung beträgt",
+        "max_file_size": "Max. Dateigröße",
+        "max_file_size_limit_is": "Max. Dateigröße ist",
         "move_question_to_block": "Frage in Block verschieben",
         "multiply": "Multiplizieren *",
         "needed_for_self_hosted_cal_com_instance": "Benötigt für eine selbstgehostete Cal.com-Instanz",
@@ -1532,6 +1460,7 @@
         "picture_idx": "Bild {idx}",
         "pin_can_only_contain_numbers": "PIN darf nur Zahlen enthalten.",
         "pin_must_be_a_four_digit_number": "Die PIN muss eine vierstellige Zahl sein.",
+        "please_enter_a_file_extension": "Bitte gib eine Dateierweiterung ein.",
         "please_enter_a_valid_url": "Bitte geben Sie eine gültige URL ein (z. B. https://beispiel.de)",
         "please_set_a_survey_trigger": "Bitte richte einen Umfrage-Trigger ein",
         "please_specify": "Bitte angeben",
@@ -1542,12 +1471,12 @@
         "protect_survey_with_pin_description": "Nur Benutzer, die die PIN haben, können auf die Umfrage zugreifen.",
         "publish": "Veröffentlichen",
         "question": "Frage",
+        "question_color": "Fragefarbe",
         "question_deleted": "Frage gelöscht.",
         "question_duplicated": "Frage dupliziert.",
         "question_id_updated": "Frage-ID aktualisiert",
-        "question_used_in_logic_warning_text": "Elemente aus diesem Block werden in einer Logikregel verwendet. Möchten Sie ihn wirklich löschen?",
-        "question_used_in_logic_warning_title": "Logikinkonsistenz",
-        "question_used_in_quota": "Diese Frage wird in der “{quotaName}” Quote verwendet",
+        "question_used_in_logic": "Diese Frage wird in der Logik der Frage {questionIndex} verwendet.",
+        "question_used_in_quota": "Diese Frage wird in der \"{quotaName}\" Quote verwendet",
         "question_used_in_recall": "Diese Frage wird in Frage {questionIndex} abgerufen.",
         "question_used_in_recall_ending_card": "Diese Frage wird in der Abschlusskarte abgerufen.",
         "quotas": {
@@ -1603,7 +1532,6 @@
         "response_limits_redirections_and_more": "Antwort Limits, Weiterleitungen und mehr.",
         "response_options": "Antwortoptionen",
         "roundness": "Rundheit",
-        "roundness_description": "Steuert, wie abgerundet die Kartenecken sind.",
         "row_used_in_logic_error": "Diese Zeile wird in der Logik der Frage {questionIndex} verwendet. Bitte entferne sie zuerst aus der Logik.",
         "rows": "Zeilen",
         "save_and_close": "Speichern & Schließen",
@@ -1611,7 +1539,6 @@
         "search_for_images": "Nach Bildern suchen",
         "seconds_after_trigger_the_survey_will_be_closed_if_no_response": "Sekunden nach dem Auslösen wird die Umfrage geschlossen, wenn keine Antwort erfolgt.",
         "seconds_before_showing_the_survey": "Sekunden, bevor die Umfrage angezeigt wird.",
-        "select_field": "Feld auswählen",
         "select_or_type_value": "Auswählen oder Wert eingeben",
         "select_ordering": "Anordnung auswählen",
         "select_saved_action": "Gespeicherte Aktion auswählen",
@@ -1645,6 +1572,7 @@
         "styling_set_to_theme_styles": "Styling auf Themenstile eingestellt",
         "subheading": "Zwischenüberschrift",
         "subtract": "Subtrahieren -",
+        "suggest_colors": "Farben vorschlagen",
         "survey_completed_heading": "Umfrage abgeschlossen",
         "survey_completed_subheading": "Diese kostenlose und quelloffene Umfrage wurde geschlossen",
         "survey_display_settings": "Einstellungen zur Anzeige der Umfrage",
@@ -1658,6 +1586,8 @@
         "the_survey_will_be_shown_once_even_if_person_doesnt_respond": "Einmal anzeigen, auch wenn sie nicht antworten.",
         "then": "dann",
         "this_action_will_remove_all_the_translations_from_this_survey": "Diese Aktion entfernt alle Übersetzungen aus dieser Umfrage.",
+        "this_extension_is_already_added": "Diese Erweiterung ist bereits hinzugefügt.",
+        "this_file_type_is_not_supported": "Dieser Dateityp wird nicht unterstützt.",
         "three_points": "3 Punkte",
         "times": "Zeiten",
         "to_keep_the_placement_over_all_surveys_consistent_you_can": "Um die Platzierung über alle Umfragen hinweg konsistent zu halten, kannst du",
@@ -1678,51 +1608,8 @@
         "upper_label": "Oberes Label",
         "url_filters": "URL-Filter",
         "url_not_supported": "URL nicht unterstützt",
-        "validation": {
-          "add_validation_rule": "Validierungsregel hinzufügen",
-          "answer_all_rows": "Alle Zeilen beantworten",
-          "characters": "Zeichen",
-          "contains": "enthält",
-          "delete_validation_rule": "Validierungsregel löschen",
-          "does_not_contain": "enthält nicht",
-          "email": "Ist gültige E-Mail",
-          "end_date": "Enddatum",
-          "file_extension_is": "Dateierweiterung ist",
-          "file_extension_is_not": "Dateierweiterung ist nicht",
-          "is": "ist",
-          "is_between": "ist zwischen",
-          "is_earlier_than": "ist früher als",
-          "is_greater_than": "ist größer als",
-          "is_later_than": "ist später als",
-          "is_less_than": "ist weniger als",
-          "is_not": "ist nicht",
-          "is_not_between": "ist nicht zwischen",
-          "kb": "KB",
-          "max_length": "Höchstens",
-          "max_selections": "Höchstens",
-          "max_value": "Höchstens",
-          "mb": "MB",
-          "min_length": "Mindestens",
-          "min_selections": "Mindestens",
-          "min_value": "Mindestens",
-          "minimum_options_ranked": "Mindestanzahl bewerteter Optionen",
-          "minimum_rows_answered": "Mindestanzahl beantworteter Zeilen",
-          "options_selected": "Optionen ausgewählt",
-          "pattern": "Entspricht Regex-Muster",
-          "phone": "Ist gültige Telefonnummer",
-          "rank_all_options": "Alle Optionen bewerten",
-          "select_file_extensions": "Dateierweiterungen auswählen...",
-          "select_option": "Option auswählen",
-          "start_date": "Startdatum",
-          "url": "Ist gültige URL"
-        },
-        "validation_logic_and": "Alle sind wahr",
-        "validation_logic_or": "mindestens eine ist wahr",
-        "validation_rules": "Validierungsregeln",
-        "validation_rules_description": "Nur Antworten akzeptieren, die die folgenden Kriterien erfüllen",
         "variable_is_used_in_logic_of_question_please_remove_it_from_logic_first": "{variable} wird in der Logik der Frage {questionIndex} verwendet. Bitte entferne es zuerst aus der Logik.",
-        "variable_is_used_in_quota_please_remove_it_from_quota_first": "Variable “{variableName}” wird in der “{quotaName}” Quote verwendet",
-        "variable_name_conflicts_with_hidden_field": "Der Variablenname steht im Konflikt mit einer vorhandenen Hidden-Field-ID.",
+        "variable_is_used_in_quota_please_remove_it_from_quota_first": "Variable \"{variableName}\" wird in der \"{quotaName}\" Quote verwendet",
         "variable_name_is_already_taken_please_choose_another": "Variablenname ist bereits vergeben, bitte wähle einen anderen.",
         "variable_name_must_start_with_a_letter": "Variablenname muss mit einem Buchstaben beginnen.",
         "variable_used_in_recall": "Variable \"{variable}\" wird in Frage {questionIndex} abgerufen.",
@@ -2128,71 +2015,9 @@
       "look": {
         "add_background_color": "Hintergrundfarbe hinzufügen",
         "add_background_color_description": "Füge dem Logo-Container eine Hintergrundfarbe hinzu.",
-        "advanced_styling_field_border_radius": "Rahmenradius",
-        "advanced_styling_field_button_bg": "Button-Hintergrund",
-        "advanced_styling_field_button_bg_description": "Füllt den Weiter-/Absenden-Button.",
-        "advanced_styling_field_button_border_radius_description": "Rundet die Button-Ecken ab.",
-        "advanced_styling_field_button_font_size_description": "Skaliert den Text der Button-Beschriftung.",
-        "advanced_styling_field_button_font_weight_description": "Macht den Button-Text heller oder fetter.",
-        "advanced_styling_field_button_height_description": "Steuert die Button-Höhe.",
-        "advanced_styling_field_button_padding_x_description": "Fügt links und rechts Abstand hinzu.",
-        "advanced_styling_field_button_padding_y_description": "Fügt oben und unten Abstand hinzu.",
-        "advanced_styling_field_button_text": "Button-Text",
-        "advanced_styling_field_button_text_description": "Färbt die Beschriftung innerhalb von Buttons.",
-        "advanced_styling_field_description_color": "Beschreibungsfarbe",
-        "advanced_styling_field_description_color_description": "Färbt den Text unterhalb jeder Überschrift.",
-        "advanced_styling_field_description_size": "Schriftgröße der Beschreibung",
-        "advanced_styling_field_description_size_description": "Skaliert den Beschreibungstext.",
-        "advanced_styling_field_description_weight": "Schriftstärke der Beschreibung",
-        "advanced_styling_field_description_weight_description": "Macht den Beschreibungstext heller oder fetter.",
-        "advanced_styling_field_font_size": "Schriftgröße",
-        "advanced_styling_field_font_weight": "Schriftstärke",
-        "advanced_styling_field_headline_color": "Überschriftsfarbe",
-        "advanced_styling_field_headline_color_description": "Färbt den Hauptfragetext.",
-        "advanced_styling_field_headline_size": "Schriftgröße der Überschrift",
-        "advanced_styling_field_headline_size_description": "Skaliert den Überschriftentext.",
-        "advanced_styling_field_headline_weight": "Schriftstärke der Überschrift",
-        "advanced_styling_field_headline_weight_description": "Macht den Überschriftentext heller oder fetter.",
-        "advanced_styling_field_height": "Mindesthöhe",
-        "advanced_styling_field_indicator_bg": "Indikator-Hintergrund",
-        "advanced_styling_field_indicator_bg_description": "Färbt den gefüllten Teil des Balkens.",
-        "advanced_styling_field_input_border_radius_description": "Rundet die Eingabeecken ab.",
-        "advanced_styling_field_input_font_size_description": "Skaliert den eingegebenen Text in Eingabefeldern.",
-        "advanced_styling_field_input_height_description": "Legt die Mindesthöhe des Eingabefelds fest.",
-        "advanced_styling_field_input_padding_x_description": "Fügt links und rechts Abstand hinzu.",
-        "advanced_styling_field_input_padding_y_description": "Fügt oben und unten Abstand hinzu.",
-        "advanced_styling_field_input_placeholder_opacity_description": "Blendet den Platzhaltertext aus.",
-        "advanced_styling_field_input_shadow_description": "Fügt einen Schlagschatten um Eingabefelder hinzu.",
-        "advanced_styling_field_input_text": "Eingabetext",
-        "advanced_styling_field_input_text_description": "Färbt den eingegebenen Text in Eingabefeldern.",
-        "advanced_styling_field_option_bg": "Hintergrund",
-        "advanced_styling_field_option_bg_description": "Füllt die Optionselemente.",
-        "advanced_styling_field_option_border_radius_description": "Rundet die Ecken der Optionen ab.",
-        "advanced_styling_field_option_font_size_description": "Skaliert den Text der Optionsbeschriftung.",
-        "advanced_styling_field_option_label": "Label-Farbe",
-        "advanced_styling_field_option_label_description": "Färbt den Text der Optionsbeschriftung.",
-        "advanced_styling_field_option_padding_x_description": "Fügt links und rechts Abstand hinzu.",
-        "advanced_styling_field_option_padding_y_description": "Fügt oben und unten Abstand hinzu.",
-        "advanced_styling_field_padding_x": "Innenabstand X",
-        "advanced_styling_field_padding_y": "Innenabstand Y",
-        "advanced_styling_field_placeholder_opacity": "Platzhalter-Deckkraft",
-        "advanced_styling_field_shadow": "Schatten",
-        "advanced_styling_field_track_bg": "Track-Hintergrund",
-        "advanced_styling_field_track_bg_description": "Färbt den nicht ausgefüllten Teil des Balkens.",
-        "advanced_styling_field_track_height": "Track-Höhe",
-        "advanced_styling_field_track_height_description": "Steuert die Dicke des Fortschrittsbalkens.",
-        "advanced_styling_field_upper_label_color": "Farbe des oberen Labels",
-        "advanced_styling_field_upper_label_color_description": "Färbt die kleine Beschriftung über Eingabefeldern.",
-        "advanced_styling_field_upper_label_size": "Schriftgröße des oberen Labels",
-        "advanced_styling_field_upper_label_size_description": "Skaliert die kleine Beschriftung über Eingabefeldern.",
-        "advanced_styling_field_upper_label_weight": "Schriftstärke des oberen Labels",
-        "advanced_styling_field_upper_label_weight_description": "Macht die Beschriftung leichter oder fetter.",
-        "advanced_styling_section_buttons": "Buttons",
-        "advanced_styling_section_headlines": "Überschriften & Beschreibungen",
-        "advanced_styling_section_inputs": "Eingabefelder",
-        "advanced_styling_section_options": "Optionen (Radio/Checkbox)",
         "app_survey_placement": "Platzierung der App-Umfrage",
         "app_survey_placement_settings_description": "Ändere, wo Umfragen in deiner Web-App oder Website angezeigt werden.",
+        "centered_modal_overlay_color": "Zentrierte modale Überlagerungsfarbe",
         "email_customization": "E-Mail-Anpassung",
         "email_customization_description": "Ändere das Aussehen und die Gestaltung von E-Mails, die Formbricks in deinem Namen versendet.",
         "enable_custom_styling": "Benutzerdefiniertes Styling aktivieren",
@@ -2203,9 +2028,6 @@
         "formbricks_branding_hidden": "Formbricks-Branding ist ausgeblendet.",
         "formbricks_branding_settings_description": "Wir freuen uns über deine Unterstützung, haben aber Verständnis, wenn du es ausschaltest.",
         "formbricks_branding_shown": "Formbricks-Branding wird angezeigt.",
-        "generate_theme_btn": "Generieren",
-        "generate_theme_confirmation": "Möchtest du ein passendes Farbschema basierend auf deiner Markenfarbe generieren? Dies überschreibt deine aktuellen Farbeinstellungen.",
-        "generate_theme_header": "Farbschema generieren?",
         "logo_removed_successfully": "Logo erfolgreich entfernt",
         "logo_settings_description": "Lade dein Firmenlogo hoch, um Umfragen und Link-Vorschauen zu branden.",
         "logo_updated_successfully": "Logo erfolgreich aktualisiert",
@@ -2220,8 +2042,6 @@
         "show_formbricks_branding_in": "Formbricks-Branding in {type}-Umfragen anzeigen",
         "show_powered_by_formbricks": "\"Powered by Formbricks\"-Signatur anzeigen",
         "styling_updated_successfully": "Styling erfolgreich aktualisiert",
-        "suggest_colors": "Farben vorschlagen",
-        "suggested_colors_applied_please_save": "Vorgeschlagene Farben erfolgreich generiert. Drücke \"Speichern\", um die Änderungen zu übernehmen.",
         "theme": "Theme",
         "theme_settings_description": "Erstelle ein Style-Theme für alle Umfragen. Du kannst für jede Umfrage individuelles Styling aktivieren."
       },
@@ -2985,7 +2805,6 @@
     "preview_survey_question_2_choice_1_label": "Ja, halte mich auf dem Laufenden.",
     "preview_survey_question_2_choice_2_label": "Nein, danke!",
     "preview_survey_question_2_headline": "Möchtest Du auf dem Laufenden bleiben?",
-    "preview_survey_question_2_subheader": "Dies ist eine Beispielbeschreibung.",
     "preview_survey_welcome_card_headline": "Willkommen!",
     "prioritize_features_description": "Identifiziere die Funktionen, die deine Nutzer am meisten und am wenigsten brauchen.",
     "prioritize_features_name": "Funktionen priorisieren",

apps/web/locales/es-ES.json

@@ -188,7 +188,6 @@
     "customer_success": "Éxito del cliente",
     "dark_overlay": "Superposición oscura",
     "date": "Fecha",
-    "days": "días",
     "default": "Predeterminado",
     "delete": "Eliminar",
     "description": "Descripción",
@@ -244,6 +243,7 @@
     "imprint": "Aviso legal",
     "in_progress": "En progreso",
     "inactive_surveys": "Encuestas inactivas",
+    "input_type": "Tipo de entrada",
     "integration": "integración",
     "integrations": "Integraciones",
     "invalid_date": "Fecha no válida",
@@ -255,7 +255,6 @@
     "label": "Etiqueta",
     "language": "Idioma",
     "learn_more": "Saber más",
-    "license_expired": "License Expired",
     "light_overlay": "Superposición clara",
     "limits_reached": "Límites alcanzados",
     "link": "Enlace",
@@ -268,15 +267,16 @@
     "look_and_feel": "Apariencia",
     "manage": "Gestionar",
     "marketing": "Marketing",
+    "maximum": "Máximo",
     "member": "Miembro",
     "members": "Miembros",
     "members_and_teams": "Miembros y equipos",
     "membership_not_found": "Membresía no encontrada",
     "metadata": "Metadatos",
+    "minimum": "Mínimo",
     "mobile_overlay_app_works_best_on_desktop": "Formbricks funciona mejor en una pantalla más grande. Para gestionar o crear encuestas, cambia a otro dispositivo.",
     "mobile_overlay_surveys_look_good": "No te preocupes – ¡tus encuestas se ven geniales en todos los dispositivos y tamaños de pantalla!",
     "mobile_overlay_title": "¡Ups, pantalla pequeña detectada!",
-    "months": "meses",
     "move_down": "Mover hacia abajo",
     "move_up": "Mover hacia arriba",
     "multiple_languages": "Múltiples idiomas",
@@ -287,7 +287,6 @@
     "no_background_image_found": "No se encontró imagen de fondo.",
     "no_code": "Sin código",
     "no_files_uploaded": "No se subieron archivos",
-    "no_overlay": "Sin superposición",
     "no_quotas_found": "No se encontraron cuotas",
     "no_result_found": "No se encontró resultado",
     "no_results": "Sin resultados",
@@ -314,7 +313,6 @@
     "organization_teams_not_found": "Equipos de la organización no encontrados",
     "other": "Otro",
     "others": "Otros",
-    "overlay_color": "Color de superposición",
     "overview": "Resumen",
     "password": "Contraseña",
     "paused": "Pausado",
@@ -328,7 +326,7 @@
     "placeholder": "Marcador de posición",
     "please_select_at_least_one_survey": "Por favor, selecciona al menos una encuesta",
     "please_select_at_least_one_trigger": "Por favor, selecciona al menos un disparador",
-    "please_upgrade_your_plan": "Por favor, actualiza tu plan",
+    "please_upgrade_your_plan": "Por favor, actualiza tu plan.",
     "preview": "Vista previa",
     "preview_survey": "Vista previa de la encuesta",
     "privacy": "Política de privacidad",
@@ -354,7 +352,6 @@
     "request_trial_license": "Solicitar licencia de prueba",
     "reset_to_default": "Restablecer a valores predeterminados",
     "response": "Respuesta",
-    "response_id": "ID de respuesta",
     "responses": "Respuestas",
     "restart": "Reiniciar",
     "role": "Rol",
@@ -395,7 +392,6 @@
     "status": "Estado",
     "step_by_step_manual": "Manual paso a paso",
     "storage_not_configured": "Almacenamiento de archivos no configurado, es probable que fallen las subidas",
-    "string": "Texto",
     "styling": "Estilo",
     "submit": "Enviar",
     "summary": "Resumen",
@@ -451,7 +447,6 @@
     "website_and_app_connection": "Conexión de sitio web y aplicación",
     "website_app_survey": "Encuesta de sitio web y aplicación",
     "website_survey": "Encuesta de sitio web",
-    "weeks": "semanas",
     "welcome_card": "Tarjeta de bienvenida",
     "workspace_configuration": "Configuración del proyecto",
     "workspace_created_successfully": "Proyecto creado correctamente",
@@ -462,15 +457,13 @@
     "workspace_not_found": "Proyecto no encontrado",
     "workspace_permission_not_found": "Permiso del proyecto no encontrado",
     "workspaces": "Proyectos",
-    "years": "años",
     "you": "Tú",
     "you_are_downgraded_to_the_community_edition": "Has sido degradado a la edición Community.",
     "you_are_not_authorized_to_perform_this_action": "No tienes autorización para realizar esta acción.",
     "you_have_reached_your_limit_of_workspace_limit": "Has alcanzado tu límite de {projectLimit} espacios de trabajo.",
     "you_have_reached_your_monthly_miu_limit_of": "Has alcanzado tu límite mensual de MIU de",
     "you_have_reached_your_monthly_response_limit_of": "Has alcanzado tu límite mensual de respuestas de",
-    "you_will_be_downgraded_to_the_community_edition_on_date": "Serás degradado a la edición Community el {date}.",
-    "your_license_has_expired_please_renew": "Your enterprise license has expired. Please renew it to continue using enterprise features."
+    "you_will_be_downgraded_to_the_community_edition_on_date": "Serás degradado a la edición Community el {date}."
   },
   "emails": {
     "accept": "Aceptar",
@@ -634,12 +627,6 @@
       "attribute_updated_successfully": "Atributo actualizado con éxito",
       "attribute_value": "Valor",
       "attribute_value_placeholder": "Valor del atributo",
-      "attributes_msg_attribute_limit_exceeded": "No se pudieron crear {count} atributo(s) nuevo(s) ya que se excedería el límite máximo de {limit} clases de atributos. Los atributos existentes se actualizaron correctamente.",
-      "attributes_msg_attribute_type_validation_error": "{error} (el atributo '{key}' tiene dataType: {dataType})",
-      "attributes_msg_email_already_exists": "El email ya existe para este entorno y no se actualizó.",
-      "attributes_msg_email_or_userid_required": "Se requiere email o userId. Se conservaron los valores existentes.",
-      "attributes_msg_new_attribute_created": "Se creó el atributo nuevo '{key}' con tipo '{dataType}'",
-      "attributes_msg_userid_already_exists": "El userId ya existe para este entorno y no se actualizó.",
       "contact_deleted_successfully": "Contacto eliminado correctamente",
       "contact_not_found": "No se ha encontrado dicho contacto",
       "contacts_table_refresh": "Actualizar contactos",
@@ -648,11 +635,6 @@
       "create_key": "Crear clave",
       "create_new_attribute": "Crear atributo nuevo",
       "create_new_attribute_description": "Crea un atributo nuevo para fines de segmentación.",
-      "custom_attributes": "Atributos personalizados",
-      "data_type": "Tipo de dato",
-      "data_type_cannot_be_changed": "El tipo de dato no se puede cambiar después de la creación",
-      "data_type_description": "Elige cómo debe almacenarse y filtrarse este atributo",
-      "date_value_required": "Se requiere un valor de fecha. Usa el botón de eliminar para quitar este atributo si no quieres establecer una fecha.",
       "delete_attribute_confirmation": "{value, plural, one {Esto eliminará el atributo seleccionado. Se perderán todos los datos de contacto asociados con este atributo.} other {Esto eliminará los atributos seleccionados. Se perderán todos los datos de contacto asociados con estos atributos.}}",
       "delete_contact_confirmation": "Esto eliminará todas las respuestas de encuestas y atributos de contacto asociados con este contacto. Cualquier segmentación y personalización basada en los datos de este contacto se perderá.",
       "delete_contact_confirmation_with_quotas": "{value, plural, one {Esto eliminará todas las respuestas de encuestas y atributos de contacto asociados con este contacto. Cualquier segmentación y personalización basada en los datos de este contacto se perderá. Si este contacto tiene respuestas que cuentan para las cuotas de encuesta, los recuentos de cuota se reducirán pero los límites de cuota permanecerán sin cambios.} other {Esto eliminará todas las respuestas de encuestas y atributos de contacto asociados con estos contactos. Cualquier segmentación y personalización basada en los datos de estos contactos se perderá. Si estos contactos tienen respuestas que cuentan para las cuotas de encuesta, los recuentos de cuota se reducirán pero los límites de cuota permanecerán sin cambios.}}",
@@ -660,18 +642,13 @@
       "edit_attribute_description": "Actualiza la etiqueta y la descripción de este atributo.",
       "edit_attribute_values": "Editar atributos",
       "edit_attribute_values_description": "Cambia los valores de atributos específicos para este contacto.",
-      "edit_attributes": "Editar atributos",
       "edit_attributes_success": "Atributos del contacto actualizados correctamente",
       "generate_personal_link": "Generar enlace personal",
       "generate_personal_link_description": "Selecciona una encuesta publicada para generar un enlace personalizado para este contacto.",
-      "invalid_csv_column_names": "Nombre(s) de columna CSV no válido(s): {columns}. Los nombres de columna que se convertirán en nuevos atributos solo deben contener letras minúsculas, números y guiones bajos, y deben comenzar con una letra.",
-      "invalid_date_format": "Formato de fecha no válido. Por favor, usa una fecha válida.",
-      "invalid_number_format": "Formato de número no válido. Por favor, introduce un número válido.",
       "no_published_link_surveys_available": "No hay encuestas de enlace publicadas disponibles. Por favor, publica primero una encuesta de enlace.",
       "no_published_surveys": "No hay encuestas publicadas",
       "no_responses_found": "No se encontraron respuestas",
       "not_provided": "No proporcionado",
-      "number_value_required": "Se requiere un valor numérico. Usa el botón de eliminar para quitar este atributo.",
       "personal_link_generated": "Enlace personal generado correctamente",
       "personal_link_generated_but_clipboard_failed": "Enlace personal generado pero falló al copiar al portapapeles: {url}",
       "personal_survey_link": "Enlace personal de encuesta",
@@ -680,22 +657,13 @@
       "search_contact": "Buscar contacto",
       "select_a_survey": "Selecciona una encuesta",
       "select_attribute": "Seleccionar atributo",
-      "select_attribute_key": "Seleccionar clave de atributo",
-      "system_attributes": "Atributos del sistema",
       "unlock_contacts_description": "Gestiona contactos y envía encuestas dirigidas",
       "unlock_contacts_title": "Desbloquea contactos con un plan superior",
-      "upload_contacts_error_attribute_type_mismatch": "El atributo \"{key}\" está tipado como \"{dataType}\" pero el CSV contiene valores no válidos: {values}",
-      "upload_contacts_error_duplicate_mappings": "Se encontraron mapeos duplicados para los siguientes atributos: {attributes}",
-      "upload_contacts_error_file_too_large": "El tamaño del archivo supera el límite máximo de 800 KB",
-      "upload_contacts_error_generic": "Se produjo un error al cargar los contactos. Por favor, inténtalo de nuevo más tarde.",
-      "upload_contacts_error_invalid_file_type": "Por favor, carga un archivo CSV",
-      "upload_contacts_error_no_valid_contacts": "El archivo CSV cargado no contiene ningún contacto válido, por favor consulta el archivo CSV de ejemplo para ver el formato correcto.",
-      "upload_contacts_modal_attribute_header": "Atributo de Formbricks",
       "upload_contacts_modal_attributes_description": "Asigna las columnas de tu CSV a los atributos en Formbricks.",
       "upload_contacts_modal_attributes_new": "Nuevo atributo",
       "upload_contacts_modal_attributes_search_or_add": "Buscar o añadir atributo",
+      "upload_contacts_modal_attributes_should_be_mapped_to": "debe asignarse a",
       "upload_contacts_modal_attributes_title": "Atributos",
-      "upload_contacts_modal_csv_column_header": "Columna CSV",
       "upload_contacts_modal_description": "Sube un CSV para importar rápidamente contactos con atributos",
       "upload_contacts_modal_download_example_csv": "Descargar CSV de ejemplo",
       "upload_contacts_modal_duplicates_description": "¿Cómo deberíamos manejar si un contacto ya existe en tus contactos?",
@@ -876,40 +844,6 @@
       "no_attributes_yet": "¡Aún no hay atributos!",
       "no_filters_yet": "¡Aún no hay filtros!",
       "no_segments_yet": "Actualmente no tienes segmentos guardados.",
-      "operator_contains": "contiene",
-      "operator_does_not_contain": "no contiene",
-      "operator_ends_with": "termina con",
-      "operator_is_after": "es después de",
-      "operator_is_before": "es antes de",
-      "operator_is_between": "está entre",
-      "operator_is_newer_than": "es más reciente que",
-      "operator_is_not_set": "no está establecido",
-      "operator_is_older_than": "es más antiguo que",
-      "operator_is_same_day": "es el mismo día",
-      "operator_is_set": "está establecido",
-      "operator_starts_with": "comienza con",
-      "operator_title_contains": "Contiene",
-      "operator_title_does_not_contain": "No contiene",
-      "operator_title_ends_with": "Termina con",
-      "operator_title_equals": "Es igual a",
-      "operator_title_greater_equal": "Mayor o igual que",
-      "operator_title_greater_than": "Mayor que",
-      "operator_title_is_after": "Es después de",
-      "operator_title_is_before": "Es antes de",
-      "operator_title_is_between": "Está entre",
-      "operator_title_is_newer_than": "Es más reciente que",
-      "operator_title_is_not_set": "No está establecido",
-      "operator_title_is_older_than": "Es más antiguo que",
-      "operator_title_is_same_day": "Es el mismo día",
-      "operator_title_is_set": "Está establecido",
-      "operator_title_less_equal": "Menor o igual que",
-      "operator_title_less_than": "Menor que",
-      "operator_title_not_equals": "No es igual a",
-      "operator_title_starts_with": "Comienza con",
-      "operator_title_user_is_in": "El usuario está en",
-      "operator_title_user_is_not_in": "El usuario no está en",
-      "operator_user_is_in": "El usuario está en",
-      "operator_user_is_not_in": "El usuario no está en",
       "person_and_attributes": "Persona y atributos",
       "phone": "Teléfono",
       "please_remove_the_segment_from_these_surveys_in_order_to_delete_it": "Por favor, elimina el segmento de estas encuestas para poder borrarlo.",
@@ -934,7 +868,6 @@
       "user_targeting_is_currently_only_available_when": "La segmentación de usuarios actualmente solo está disponible cuando",
       "value_cannot_be_empty": "El valor no puede estar vacío.",
       "value_must_be_a_number": "El valor debe ser un número.",
-      "value_must_be_positive": "El valor debe ser un número positivo.",
       "view_filters": "Ver filtros",
       "where": "Donde",
       "with_the_formbricks_sdk": "con el SDK de Formbricks"
@@ -1021,32 +954,19 @@
         "enterprise_features": "Características empresariales",
         "get_an_enterprise_license_to_get_access_to_all_features": "Obtén una licencia empresarial para acceder a todas las características.",
         "keep_full_control_over_your_data_privacy_and_security": "Mantén el control total sobre la privacidad y seguridad de tus datos.",
-        "license_invalid_description": "La clave de licencia en tu variable de entorno ENTERPRISE_LICENSE_KEY no es válida. Por favor, comprueba si hay errores tipográficos o solicita una clave nueva.",
-        "license_status": "Estado de la licencia",
-        "license_status_active": "Activa",
-        "license_status_description": "Estado de tu licencia enterprise.",
-        "license_status_expired": "Caducada",
-        "license_status_invalid": "Licencia no válida",
-        "license_status_unreachable": "Inaccesible",
-        "license_unreachable_grace_period": "No se puede acceder al servidor de licencias. Tus funciones empresariales permanecen activas durante un período de gracia de 3 días que finaliza el {gracePeriodEnd}.",
         "no_call_needed_no_strings_attached_request_a_free_30_day_trial_license_to_test_all_features_by_filling_out_this_form": "Sin necesidad de llamadas, sin compromisos: solicita una licencia de prueba gratuita de 30 días para probar todas las características rellenando este formulario:",
         "no_credit_card_no_sales_call_just_test_it": "Sin tarjeta de crédito. Sin llamada de ventas. Solo pruébalo :)",
         "on_request": "Bajo petición",
         "organization_roles": "Roles de organización (administrador, editor, desarrollador, etc.)",
         "questions_please_reach_out_to": "¿Preguntas? Por favor, contacta con",
-        "recheck_license": "Volver a comprobar licencia",
-        "recheck_license_failed": "Error al comprobar la licencia. Es posible que el servidor de licencias no esté disponible.",
-        "recheck_license_invalid": "La clave de licencia no es válida. Por favor, verifica tu ENTERPRISE_LICENSE_KEY.",
-        "recheck_license_success": "Comprobación de licencia correcta",
-        "recheck_license_unreachable": "El servidor de licencias no está disponible. Inténtalo de nuevo más tarde.",
-        "rechecking": "Comprobando...",
         "request_30_day_trial_license": "Solicitar licencia de prueba de 30 días",
         "saml_sso": "SAML SSO",
         "service_level_agreement": "Acuerdo de nivel de servicio",
         "soc2_hipaa_iso_27001_compliance_check": "Verificación de cumplimiento SOC2, HIPAA, ISO 27001",
         "sso": "SSO (Google, Microsoft, OpenID Connect)",
         "teams": "Equipos y roles de acceso (lectura, lectura y escritura, gestión)",
-        "unlock_the_full_power_of_formbricks_free_for_30_days": "Desbloquea todo el potencial de Formbricks. Gratis durante 30 días."
+        "unlock_the_full_power_of_formbricks_free_for_30_days": "Desbloquea todo el potencial de Formbricks. Gratis durante 30 días.",
+        "your_enterprise_license_is_active_all_features_unlocked": "Tu licencia empresarial está activa. Todas las características desbloqueadas."
       },
       "general": {
         "bulk_invite_warning_description": "En el plan gratuito, a todos los miembros de la organización se les asigna siempre el rol de \"Propietario\".",
@@ -1070,7 +990,7 @@
         "from_your_organization": "de tu organización",
         "invitation_sent_once_more": "Invitación enviada una vez más.",
         "invite_deleted_successfully": "Invitación eliminada correctamente",
-        "invite_expires_on": "La invitación expira el {date}",
+        "invited_on": "Invitado el {date}",
         "invites_failed": "Las invitaciones fallaron",
         "leave_organization": "Abandonar organización",
         "leave_organization_description": "Abandonarás esta organización y perderás acceso a todas las encuestas y respuestas. Solo podrás volver a unirte si te invitan de nuevo.",
@@ -1183,6 +1103,8 @@
         "please_fill_all_workspace_fields": "Por favor, rellena todos los campos para añadir un proyecto nuevo.",
         "read": "Lectura",
         "read_write": "Lectura y escritura",
+        "select_member": "Seleccionar miembro",
+        "select_workspace": "Seleccionar proyecto",
         "team_admin": "Administrador de equipo",
         "team_created_successfully": "Equipo creado con éxito.",
         "team_deleted_successfully": "Equipo eliminado correctamente.",
@@ -1232,6 +1154,7 @@
         "add_fallback_placeholder": "Añadir un marcador de posición para mostrar si no hay valor que recuperar.",
         "add_hidden_field_id": "Añadir ID de campo oculto",
         "add_highlight_border": "Añadir borde destacado",
+        "add_highlight_border_description": "Añadir un borde exterior a tu tarjeta de encuesta.",
         "add_logic": "Añadir lógica",
         "add_none_of_the_above": "Añadir \"Ninguna de las anteriores\"",
         "add_option": "Añadir opción",
@@ -1249,6 +1172,7 @@
         "adjust_survey_closed_message_description": "Cambiar el mensaje que ven los visitantes cuando la encuesta está cerrada.",
         "adjust_the_theme_in_the": "Ajustar el tema en el",
         "all_other_answers_will_continue_to": "Todas las demás respuestas continuarán",
+        "allow_file_type": "Permitir tipo de archivo",
         "allow_multi_select": "Permitir selección múltiple",
         "allow_multiple_files": "Permitir múltiples archivos",
         "allow_users_to_select_more_than_one_image": "Permitir a los usuarios seleccionar más de una imagen",
@@ -1270,7 +1194,6 @@
         "block_duplicated": "Bloque duplicado.",
         "bold": "Negrita",
         "brand_color": "Color de marca",
-        "brand_color_description": "Se aplica a botones, enlaces y resaltados.",
         "brightness": "Brillo",
         "bulk_edit": "Edición masiva",
         "bulk_edit_description": "Edita todas las opciones a continuación, una por línea. Las líneas vacías se omitirán y los duplicados se eliminarán.",
@@ -1288,9 +1211,7 @@
         "capture_new_action": "Capturar nueva acción",
         "card_arrangement_for_survey_type_derived": "Disposición de tarjetas para encuestas de tipo {surveyTypeDerived}",
         "card_background_color": "Color de fondo de la tarjeta",
-        "card_background_color_description": "Rellena el área de la tarjeta de encuesta.",
         "card_border_color": "Color del borde de la tarjeta",
-        "card_border_color_description": "Delinea la tarjeta de encuesta.",
         "card_styling": "Estilo de la tarjeta",
         "casual": "Informal",
         "caution_edit_duplicate": "Duplicar y editar",
@@ -1301,14 +1222,24 @@
         "caution_explanation_responses_are_safe": "Las respuestas antiguas y nuevas se mezclan, lo que puede llevar a resúmenes de datos engañosos.",
         "caution_recommendation": "Esto puede causar inconsistencias de datos en el resumen de la encuesta. Recomendamos duplicar la encuesta en su lugar.",
         "caution_text": "Los cambios provocarán inconsistencias",
+        "centered_modal_overlay_color": "Color de superposición del modal centrado",
         "change_anyway": "Cambiar de todos modos",
         "change_background": "Cambiar fondo",
         "change_question_type": "Cambiar tipo de pregunta",
         "change_survey_type": "Cambiar el tipo de encuesta afecta al acceso existente",
+        "change_the_background_color_of_the_card": "Cambiar el color de fondo de la tarjeta.",
+        "change_the_background_color_of_the_input_fields": "Cambiar el color de fondo de los campos de entrada.",
         "change_the_background_to_a_color_image_or_animation": "Cambiar el fondo a un color, imagen o animación.",
+        "change_the_border_color_of_the_card": "Cambiar el color del borde de la tarjeta.",
+        "change_the_border_color_of_the_input_fields": "Cambiar el color del borde de los campos de entrada.",
+        "change_the_border_radius_of_the_card_and_the_inputs": "Cambiar el radio del borde de la tarjeta y las entradas.",
+        "change_the_brand_color_of_the_survey": "Cambiar el color de marca de la encuesta.",
         "change_the_placement_of_this_survey": "Cambiar la ubicación de esta encuesta.",
+        "change_the_question_color_of_the_survey": "Cambiar el color de las preguntas de la encuesta.",
         "changes_saved": "Cambios guardados.",
         "changing_survey_type_will_remove_existing_distribution_channels": "Cambiar el tipo de encuesta afectará a cómo se puede compartir. Si los encuestados ya tienen enlaces de acceso para el tipo actual, podrían perder el acceso después del cambio.",
+        "character_limit_toggle_description": "Limitar lo corta o larga que puede ser una respuesta.",
+        "character_limit_toggle_title": "Añadir límites de caracteres",
         "checkbox_label": "Etiqueta de casilla de verificación",
         "choose_the_actions_which_trigger_the_survey": "Elige las acciones que activan la encuesta.",
         "choose_the_first_question_on_your_block": "Elige la primera pregunta en tu bloque",
@@ -1328,6 +1259,7 @@
         "contact_fields": "Campos de contacto",
         "contains": "Contiene",
         "continue_to_settings": "Continuar a ajustes",
+        "control_which_file_types_can_be_uploaded": "Controla qué tipos de archivos se pueden subir.",
         "convert_to_multiple_choice": "Convertir a selección múltiple",
         "convert_to_single_choice": "Convertir a selección única",
         "country": "País",
@@ -1340,13 +1272,11 @@
         "darken_or_lighten_background_of_your_choice": "Oscurece o aclara el fondo de tu elección.",
         "date_format": "Formato de fecha",
         "days_before_showing_this_survey_again": "o más días deben transcurrir entre la última encuesta mostrada y la visualización de esta encuesta.",
-        "delete_anyways": "Eliminar de todos modos",
         "delete_block": "Eliminar bloque",
         "delete_choice": "Eliminar opción",
         "disable_the_visibility_of_survey_progress": "Desactivar la visibilidad del progreso de la encuesta.",
         "display_an_estimate_of_completion_time_for_survey": "Mostrar una estimación del tiempo de finalización de la encuesta",
         "display_number_of_responses_for_survey": "Mostrar número de respuestas para la encuesta",
-        "display_type": "Tipo de visualización",
         "divide": "Dividir /",
         "does_not_contain": "No contiene",
         "does_not_end_with": "No termina con",
@@ -1354,7 +1284,6 @@
         "does_not_include_all_of": "No incluye todos los",
         "does_not_include_one_of": "No incluye uno de",
         "does_not_start_with": "No comienza con",
-        "dropdown": "Desplegable",
         "duplicate_block": "Duplicar bloque",
         "duplicate_question": "Duplicar pregunta",
         "edit_link": "Editar enlace",
@@ -1446,6 +1375,7 @@
         "hide_progress_bar": "Ocultar barra de progreso",
         "hide_question_settings": "Ocultar ajustes de la pregunta",
         "hostname": "Nombre de host",
+        "how_funky_do_you_want_your_cards_in_survey_type_derived_surveys": "¿Cuánto estilo quieres darle a tus tarjetas en las encuestas de tipo {surveyTypeDerived}?",
         "if_you_need_more_please": "Si necesitas más, por favor",
         "if_you_really_want_that_answer_ask_until_you_get_it": "Seguir mostrando cuando se active hasta que se envíe una respuesta.",
         "ignore_global_waiting_time": "Ignorar periodo de espera",
@@ -1456,9 +1386,7 @@
         "initial_value": "Valor inicial",
         "inner_text": "Texto interior",
         "input_border_color": "Color del borde de entrada",
-        "input_border_color_description": "Delinea los campos de texto y áreas de texto.",
         "input_color": "Color de entrada",
-        "input_color_description": "Rellena el interior de los campos de texto.",
         "insert_link": "Insertar enlace",
         "invalid_targeting": "Segmentación no válida: por favor, comprueba tus filtros de audiencia",
         "invalid_video_url_warning": "Por favor, introduce una URL válida de YouTube, Vimeo o Loom. Actualmente no admitimos otros proveedores de alojamiento de vídeos.",
@@ -1485,10 +1413,10 @@
         "key": "Clave",
         "last_name": "Apellido",
         "let_people_upload_up_to_25_files_at_the_same_time": "Permitir que las personas suban hasta 25 archivos al mismo tiempo.",
-        "limit_the_maximum_file_size": "Limita el tamaño máximo de archivo para las subidas.",
-        "limit_upload_file_size_to": "Limitar el tamaño de archivo de subida a",
+        "limit_file_types": "Limitar tipos de archivo",
+        "limit_the_maximum_file_size": "Limitar el tamaño máximo de archivo",
+        "limit_upload_file_size_to": "Limitar tamaño de subida de archivos a",
         "link_survey_description": "Comparte un enlace a una página de encuesta o incrústala en una página web o correo electrónico.",
-        "list": "Lista",
         "load_segment": "Cargar segmento",
         "logic_error_warning": "El cambio causará errores lógicos",
         "logic_error_warning_text": "Cambiar el tipo de pregunta eliminará las condiciones lógicas de esta pregunta",
@@ -1532,6 +1460,7 @@
         "picture_idx": "Imagen {idx}",
         "pin_can_only_contain_numbers": "El PIN solo puede contener números.",
         "pin_must_be_a_four_digit_number": "El PIN debe ser un número de cuatro dígitos.",
+        "please_enter_a_file_extension": "Por favor, introduce una extensión de archivo.",
         "please_enter_a_valid_url": "Por favor, introduce una URL válida (p. ej., https://example.com)",
         "please_set_a_survey_trigger": "Establece un disparador de encuesta",
         "please_specify": "Por favor, especifica",
@@ -1542,12 +1471,12 @@
         "protect_survey_with_pin_description": "Solo los usuarios que tengan el PIN pueden acceder a la encuesta.",
         "publish": "Publicar",
         "question": "Pregunta",
+        "question_color": "Color de la pregunta",
         "question_deleted": "Pregunta eliminada.",
         "question_duplicated": "Pregunta duplicada.",
         "question_id_updated": "ID de pregunta actualizado",
-        "question_used_in_logic_warning_text": "Los elementos de este bloque se usan en una regla de lógica, ¿estás seguro de que quieres eliminarlo?",
-        "question_used_in_logic_warning_title": "Inconsistencia de lógica",
-        "question_used_in_quota": "Esta pregunta se está utilizando en la cuota “{quotaName}”",
+        "question_used_in_logic": "Esta pregunta se utiliza en la lógica de la pregunta {questionIndex}.",
+        "question_used_in_quota": "Esta pregunta se está utilizando en la cuota \"{quotaName}\"",
         "question_used_in_recall": "Esta pregunta se está recordando en la pregunta {questionIndex}.",
         "question_used_in_recall_ending_card": "Esta pregunta se está recordando en la Tarjeta Final",
         "quotas": {
@@ -1603,7 +1532,6 @@
         "response_limits_redirections_and_more": "Límites de respuestas, redirecciones y más.",
         "response_options": "Opciones de respuesta",
         "roundness": "Redondez",
-        "roundness_description": "Controla qué tan redondeadas están las esquinas de la tarjeta.",
         "row_used_in_logic_error": "Esta fila se utiliza en la lógica de la pregunta {questionIndex}. Por favor, elimínala de la lógica primero.",
         "rows": "Filas",
         "save_and_close": "Guardar y cerrar",
@@ -1611,7 +1539,6 @@
         "search_for_images": "Buscar imágenes",
         "seconds_after_trigger_the_survey_will_be_closed_if_no_response": "segundos después de activarse, la encuesta se cerrará si no hay respuesta",
         "seconds_before_showing_the_survey": "segundos antes de mostrar la encuesta.",
-        "select_field": "Seleccionar campo",
         "select_or_type_value": "Selecciona o escribe un valor",
         "select_ordering": "Seleccionar ordenación",
         "select_saved_action": "Seleccionar acción guardada",
@@ -1645,6 +1572,7 @@
         "styling_set_to_theme_styles": "Estilo configurado según los estilos del tema",
         "subheading": "Subtítulo",
         "subtract": "Restar -",
+        "suggest_colors": "Sugerir colores",
         "survey_completed_heading": "Encuesta completada",
         "survey_completed_subheading": "Esta encuesta gratuita y de código abierto ha sido cerrada",
         "survey_display_settings": "Ajustes de visualización de la encuesta",
@@ -1658,6 +1586,8 @@
         "the_survey_will_be_shown_once_even_if_person_doesnt_respond": "Mostrar una sola vez, incluso si no responden.",
         "then": "Entonces",
         "this_action_will_remove_all_the_translations_from_this_survey": "Esta acción eliminará todas las traducciones de esta encuesta.",
+        "this_extension_is_already_added": "Esta extensión ya está añadida.",
+        "this_file_type_is_not_supported": "Este tipo de archivo no es compatible.",
         "three_points": "3 puntos",
         "times": "veces",
         "to_keep_the_placement_over_all_surveys_consistent_you_can": "Para mantener la ubicación coherente en todas las encuestas, puedes",
@@ -1678,51 +1608,8 @@
         "upper_label": "Etiqueta superior",
         "url_filters": "Filtros de URL",
         "url_not_supported": "URL no compatible",
-        "validation": {
-          "add_validation_rule": "Añadir regla de validación",
-          "answer_all_rows": "Responde todas las filas",
-          "characters": "Caracteres",
-          "contains": "Contiene",
-          "delete_validation_rule": "Eliminar regla de validación",
-          "does_not_contain": "No contiene",
-          "email": "Es un correo electrónico válido",
-          "end_date": "Fecha de finalización",
-          "file_extension_is": "La extensión del archivo es",
-          "file_extension_is_not": "La extensión del archivo no es",
-          "is": "Es",
-          "is_between": "Está entre",
-          "is_earlier_than": "Es anterior a",
-          "is_greater_than": "Es mayor que",
-          "is_later_than": "Es posterior a",
-          "is_less_than": "Es menor que",
-          "is_not": "No es",
-          "is_not_between": "No está entre",
-          "kb": "KB",
-          "max_length": "Como máximo",
-          "max_selections": "Como máximo",
-          "max_value": "Como máximo",
-          "mb": "MB",
-          "min_length": "Al menos",
-          "min_selections": "Al menos",
-          "min_value": "Al menos",
-          "minimum_options_ranked": "Opciones mínimas clasificadas",
-          "minimum_rows_answered": "Filas mínimas respondidas",
-          "options_selected": "Opciones seleccionadas",
-          "pattern": "Coincide con el patrón regex",
-          "phone": "Es un teléfono válido",
-          "rank_all_options": "Clasificar todas las opciones",
-          "select_file_extensions": "Selecciona extensiones de archivo...",
-          "select_option": "Seleccionar opción",
-          "start_date": "Fecha de inicio",
-          "url": "Es una URL válida"
-        },
-        "validation_logic_and": "Todas son verdaderas",
-        "validation_logic_or": "alguna es verdadera",
-        "validation_rules": "Reglas de validación",
-        "validation_rules_description": "Solo aceptar respuestas que cumplan los siguientes criterios",
         "variable_is_used_in_logic_of_question_please_remove_it_from_logic_first": "{variable} se usa en la lógica de la pregunta {questionIndex}. Por favor, elimínala primero de la lógica.",
-        "variable_is_used_in_quota_please_remove_it_from_quota_first": "La variable “{variableName}” se está utilizando en la cuota “{quotaName}”",
-        "variable_name_conflicts_with_hidden_field": "El nombre de la variable entra en conflicto con un ID de campo oculto existente.",
+        "variable_is_used_in_quota_please_remove_it_from_quota_first": "La variable \"{variableName}\" se está utilizando en la cuota \"{quotaName}\"",
         "variable_name_is_already_taken_please_choose_another": "El nombre de la variable ya está en uso, por favor elige otro.",
         "variable_name_must_start_with_a_letter": "El nombre de la variable debe comenzar con una letra.",
         "variable_used_in_recall": "La variable \"{variable}\" se está recuperando en la pregunta {questionIndex}.",
@@ -2128,71 +2015,9 @@
       "look": {
         "add_background_color": "Añadir color de fondo",
         "add_background_color_description": "Añade un color de fondo al contenedor del logotipo.",
-        "advanced_styling_field_border_radius": "Radio del borde",
-        "advanced_styling_field_button_bg": "Fondo del botón",
-        "advanced_styling_field_button_bg_description": "Rellena el botón siguiente / enviar.",
-        "advanced_styling_field_button_border_radius_description": "Redondea las esquinas del botón.",
-        "advanced_styling_field_button_font_size_description": "Escala el texto de la etiqueta del botón.",
-        "advanced_styling_field_button_font_weight_description": "Hace el texto del botón más ligero o más grueso.",
-        "advanced_styling_field_button_height_description": "Controla la altura del botón.",
-        "advanced_styling_field_button_padding_x_description": "Añade espacio a la izquierda y a la derecha.",
-        "advanced_styling_field_button_padding_y_description": "Añade espacio arriba y abajo.",
-        "advanced_styling_field_button_text": "Texto del botón",
-        "advanced_styling_field_button_text_description": "Colorea la etiqueta dentro de los botones.",
-        "advanced_styling_field_description_color": "Color de la descripción",
-        "advanced_styling_field_description_color_description": "Colorea el texto debajo de cada titular.",
-        "advanced_styling_field_description_size": "Tamaño de fuente de la descripción",
-        "advanced_styling_field_description_size_description": "Escala el texto de la descripción.",
-        "advanced_styling_field_description_weight": "Grosor de fuente de la descripción",
-        "advanced_styling_field_description_weight_description": "Hace el texto de la descripción más ligero o más grueso.",
-        "advanced_styling_field_font_size": "Tamaño de fuente",
-        "advanced_styling_field_font_weight": "Grosor de fuente",
-        "advanced_styling_field_headline_color": "Color del titular",
-        "advanced_styling_field_headline_color_description": "Colorea el texto principal de la pregunta.",
-        "advanced_styling_field_headline_size": "Tamaño de fuente del titular",
-        "advanced_styling_field_headline_size_description": "Escala el texto del titular.",
-        "advanced_styling_field_headline_weight": "Grosor de fuente del titular",
-        "advanced_styling_field_headline_weight_description": "Hace el texto del titular más ligero o más grueso.",
-        "advanced_styling_field_height": "Altura mínima",
-        "advanced_styling_field_indicator_bg": "Fondo del indicador",
-        "advanced_styling_field_indicator_bg_description": "Colorea la porción rellena de la barra.",
-        "advanced_styling_field_input_border_radius_description": "Redondea las esquinas del campo.",
-        "advanced_styling_field_input_font_size_description": "Escala el texto escrito en los campos.",
-        "advanced_styling_field_input_height_description": "Controla la altura mínima del campo de entrada.",
-        "advanced_styling_field_input_padding_x_description": "Añade espacio a la izquierda y a la derecha.",
-        "advanced_styling_field_input_padding_y_description": "Añade espacio en la parte superior e inferior.",
-        "advanced_styling_field_input_placeholder_opacity_description": "Atenúa el texto de sugerencia del marcador de posición.",
-        "advanced_styling_field_input_shadow_description": "Añade una sombra alrededor de los campos de entrada.",
-        "advanced_styling_field_input_text": "Texto de entrada",
-        "advanced_styling_field_input_text_description": "Colorea el texto escrito en los campos de entrada.",
-        "advanced_styling_field_option_bg": "Fondo",
-        "advanced_styling_field_option_bg_description": "Rellena los elementos de opción.",
-        "advanced_styling_field_option_border_radius_description": "Redondea las esquinas de las opciones.",
-        "advanced_styling_field_option_font_size_description": "Escala el texto de la etiqueta de opción.",
-        "advanced_styling_field_option_label": "Color de la etiqueta",
-        "advanced_styling_field_option_label_description": "Colorea el texto de la etiqueta de opción.",
-        "advanced_styling_field_option_padding_x_description": "Añade espacio a la izquierda y a la derecha.",
-        "advanced_styling_field_option_padding_y_description": "Añade espacio en la parte superior e inferior.",
-        "advanced_styling_field_padding_x": "Relleno X",
-        "advanced_styling_field_padding_y": "Relleno Y",
-        "advanced_styling_field_placeholder_opacity": "Opacidad del marcador de posición",
-        "advanced_styling_field_shadow": "Sombra",
-        "advanced_styling_field_track_bg": "Fondo de la pista",
-        "advanced_styling_field_track_bg_description": "Colorea la parte no rellenada de la barra.",
-        "advanced_styling_field_track_height": "Altura de la pista",
-        "advanced_styling_field_track_height_description": "Controla el grosor de la barra de progreso.",
-        "advanced_styling_field_upper_label_color": "Color de la etiqueta del titular",
-        "advanced_styling_field_upper_label_color_description": "Colorea la etiqueta pequeña sobre los campos de entrada.",
-        "advanced_styling_field_upper_label_size": "Tamaño de fuente de la etiqueta del titular",
-        "advanced_styling_field_upper_label_size_description": "Escala la etiqueta pequeña sobre los campos de entrada.",
-        "advanced_styling_field_upper_label_weight": "Grosor de fuente de la etiqueta del titular",
-        "advanced_styling_field_upper_label_weight_description": "Hace que la etiqueta sea más ligera o más gruesa.",
-        "advanced_styling_section_buttons": "Botones",
-        "advanced_styling_section_headlines": "Títulos y descripciones",
-        "advanced_styling_section_inputs": "Campos de entrada",
-        "advanced_styling_section_options": "Opciones (radio/casilla de verificación)",
         "app_survey_placement": "Ubicación de encuesta de aplicación",
         "app_survey_placement_settings_description": "Cambia dónde se mostrarán las encuestas en tu aplicación web o sitio web.",
+        "centered_modal_overlay_color": "Color de superposición del modal centrado",
         "email_customization": "Personalización de correo electrónico",
         "email_customization_description": "Cambia el aspecto de los correos electrónicos que Formbricks envía en tu nombre.",
         "enable_custom_styling": "Habilitar estilo personalizado",
@@ -2203,9 +2028,6 @@
         "formbricks_branding_hidden": "La marca de Formbricks está oculta.",
         "formbricks_branding_settings_description": "Nos encanta tu apoyo, pero lo entendemos si lo desactivas.",
         "formbricks_branding_shown": "La marca de Formbricks se muestra.",
-        "generate_theme_btn": "Generar",
-        "generate_theme_confirmation": "¿Te gustaría generar un tema de colores que combine con el color de tu marca? Esto sobrescribirá tu configuración de colores actual.",
-        "generate_theme_header": "¿Generar tema de colores?",
         "logo_removed_successfully": "Logotipo eliminado correctamente",
         "logo_settings_description": "Sube el logotipo de tu empresa para personalizar las encuestas y las vistas previas de enlaces.",
         "logo_updated_successfully": "Logotipo actualizado correctamente",
@@ -2220,8 +2042,6 @@
         "show_formbricks_branding_in": "Mostrar marca de Formbricks en encuestas de {type}",
         "show_powered_by_formbricks": "Mostrar firma 'Powered by Formbricks'",
         "styling_updated_successfully": "Estilo actualizado correctamente",
-        "suggest_colors": "Sugerir colores",
-        "suggested_colors_applied_please_save": "Colores sugeridos generados correctamente. Pulsa \"Guardar\" para conservar los cambios.",
         "theme": "Tema",
         "theme_settings_description": "Crea un tema de estilo para todas las encuestas. Puedes activar el estilo personalizado para cada encuesta."
       },
@@ -2985,7 +2805,6 @@
     "preview_survey_question_2_choice_1_label": "Sí, mantenme informado.",
     "preview_survey_question_2_choice_2_label": "¡No, gracias!",
     "preview_survey_question_2_headline": "¿Quieres estar al tanto?",
-    "preview_survey_question_2_subheader": "Esta es una descripción de ejemplo.",
     "preview_survey_welcome_card_headline": "¡Bienvenido!",
     "prioritize_features_description": "Identifica las funciones que tus usuarios necesitan más y menos.",
     "prioritize_features_name": "Priorizar funciones",

apps/web/locales/fr-FR.json

@@ -188,7 +188,6 @@
     "customer_success": "Succès Client",
     "dark_overlay": "Foncée",
     "date": "Date",
-    "days": "jours",
     "default": "Par défaut",
     "delete": "Supprimer",
     "description": "Description",
@@ -244,6 +243,7 @@
     "imprint": "Empreinte",
     "in_progress": "En cours",
     "inactive_surveys": "Sondages inactifs",
+    "input_type": "Type d'entrée",
     "integration": "intégration",
     "integrations": "Intégrations",
     "invalid_date": "Date invalide",
@@ -255,7 +255,6 @@
     "label": "Étiquette",
     "language": "Langue",
     "learn_more": "En savoir plus",
-    "license_expired": "License Expired",
     "light_overlay": "Claire",
     "limits_reached": "Limites atteints",
     "link": "Lien",
@@ -268,15 +267,16 @@
     "look_and_feel": "Apparence",
     "manage": "Gérer",
     "marketing": "Marketing",
+    "maximum": "Max",
     "member": "Membre",
     "members": "Membres",
     "members_and_teams": "Membres & Équipes",
     "membership_not_found": "Abonnement non trouvé",
     "metadata": "Métadonnées",
+    "minimum": "Min",
     "mobile_overlay_app_works_best_on_desktop": "Formbricks fonctionne mieux sur un écran plus grand. Pour gérer ou créer des sondages, passez à un autre appareil.",
     "mobile_overlay_surveys_look_good": "Ne t'inquiète pas – tes enquêtes sont superbes sur tous les appareils et tailles d'écran!",
     "mobile_overlay_title": "Oups, écran minuscule détecté!",
-    "months": "mois",
     "move_down": "Déplacer vers le bas",
     "move_up": "Déplacer vers le haut",
     "multiple_languages": "Plusieurs langues",
@@ -287,7 +287,6 @@
     "no_background_image_found": "Aucune image de fond trouvée.",
     "no_code": "Sans code",
     "no_files_uploaded": "Aucun fichier n'a été téléchargé.",
-    "no_overlay": "Aucune superposition",
     "no_quotas_found": "Aucun quota trouvé",
     "no_result_found": "Aucun résultat trouvé",
     "no_results": "Aucun résultat",
@@ -314,7 +313,6 @@
     "organization_teams_not_found": "Équipes d'organisation non trouvées",
     "other": "Autre",
     "others": "Autres",
-    "overlay_color": "Couleur de superposition",
     "overview": "Aperçu",
     "password": "Mot de passe",
     "paused": "En pause",
@@ -328,7 +326,7 @@
     "placeholder": "Remplaçant",
     "please_select_at_least_one_survey": "Veuillez sélectionner au moins une enquête.",
     "please_select_at_least_one_trigger": "Veuillez sélectionner au moins un déclencheur.",
-    "please_upgrade_your_plan": "Veuillez mettre à niveau votre plan",
+    "please_upgrade_your_plan": "Veuillez mettre à niveau votre plan.",
     "preview": "Aperçu",
     "preview_survey": "Aperçu de l'enquête",
     "privacy": "Politique de confidentialité",
@@ -354,7 +352,6 @@
     "request_trial_license": "Demander une licence d'essai",
     "reset_to_default": "Réinitialiser par défaut",
     "response": "Réponse",
-    "response_id": "ID de réponse",
     "responses": "Réponses",
     "restart": "Recommencer",
     "role": "Rôle",
@@ -395,7 +392,6 @@
     "status": "Statut",
     "step_by_step_manual": "Manuel étape par étape",
     "storage_not_configured": "Stockage de fichiers non configuré, les téléchargements risquent d'échouer",
-    "string": "Texte",
     "styling": "Style",
     "submit": "Soumettre",
     "summary": "Résumé",
@@ -451,7 +447,6 @@
     "website_and_app_connection": "Connexion de sites Web et d'applications",
     "website_app_survey": "Sondage sur le site Web et l'application",
     "website_survey": "Sondage de site web",
-    "weeks": "semaines",
     "welcome_card": "Carte de bienvenue",
     "workspace_configuration": "Configuration du projet",
     "workspace_created_successfully": "Projet créé avec succès",
@@ -462,15 +457,13 @@
     "workspace_not_found": "Projet introuvable",
     "workspace_permission_not_found": "Permission du projet introuvable",
     "workspaces": "Projets",
-    "years": "années",
     "you": "Vous",
     "you_are_downgraded_to_the_community_edition": "Vous êtes rétrogradé à l'édition communautaire.",
     "you_are_not_authorized_to_perform_this_action": "Vous n'êtes pas autorisé à effectuer cette action.",
     "you_have_reached_your_limit_of_workspace_limit": "Vous avez atteint votre limite de {projectLimit} espaces de travail.",
     "you_have_reached_your_monthly_miu_limit_of": "Vous avez atteint votre limite mensuelle de MIU de",
     "you_have_reached_your_monthly_response_limit_of": "Vous avez atteint votre limite de réponses mensuelle de",
-    "you_will_be_downgraded_to_the_community_edition_on_date": "Vous serez rétrogradé à l'édition communautaire le {date}.",
-    "your_license_has_expired_please_renew": "Your enterprise license has expired. Please renew it to continue using enterprise features."
+    "you_will_be_downgraded_to_the_community_edition_on_date": "Vous serez rétrogradé à l'édition communautaire le {date}."
   },
   "emails": {
     "accept": "Accepter",
@@ -634,12 +627,6 @@
       "attribute_updated_successfully": "Attribut mis à jour avec succès",
       "attribute_value": "Valeur",
       "attribute_value_placeholder": "Valeur d'attribut",
-      "attributes_msg_attribute_limit_exceeded": "Impossible de créer {count, plural, one {# nouvel attribut} other {# nouveaux attributs}} car cela dépasserait la limite maximale de {limit} classes d'attributs. Les attributs existants ont été mis à jour avec succès.",
-      "attributes_msg_attribute_type_validation_error": "{error} (l'attribut « {key} » a le type de données : {dataType})",
-      "attributes_msg_email_already_exists": "L'adresse e-mail existe déjà pour cet environnement et n'a pas été mise à jour.",
-      "attributes_msg_email_or_userid_required": "L'adresse e-mail ou l'identifiant utilisateur est requis. Les valeurs existantes ont été conservées.",
-      "attributes_msg_new_attribute_created": "Nouvel attribut « {key} » créé avec le type « {dataType} »",
-      "attributes_msg_userid_already_exists": "L'identifiant utilisateur existe déjà pour cet environnement et n'a pas été mis à jour.",
       "contact_deleted_successfully": "Contact supprimé avec succès",
       "contact_not_found": "Aucun contact trouvé",
       "contacts_table_refresh": "Actualiser les contacts",
@@ -648,11 +635,6 @@
       "create_key": "Créer une clé",
       "create_new_attribute": "Créer un nouvel attribut",
       "create_new_attribute_description": "Créez un nouvel attribut à des fins de segmentation.",
-      "custom_attributes": "Attributs personnalisés",
-      "data_type": "Type de données",
-      "data_type_cannot_be_changed": "Le type de données ne peut pas être modifié après la création",
-      "data_type_description": "Choisis comment cet attribut doit être stocké et filtré",
-      "date_value_required": "Une valeur de date est requise. Utilise le bouton supprimer pour retirer cet attribut si tu ne veux pas définir de date.",
       "delete_attribute_confirmation": "{value, plural, one {Cela supprimera l'attribut sélectionné. Toutes les données de contact associées à cet attribut seront perdues.} other {Cela supprimera les attributs sélectionnés. Toutes les données de contact associées à ces attributs seront perdues.}}",
       "delete_contact_confirmation": "Cela supprimera toutes les réponses aux enquêtes et les attributs de contact associés à ce contact. Toute la personnalisation et le ciblage basés sur les données de ce contact seront perdus.",
       "delete_contact_confirmation_with_quotas": "{value, plural, other {Cela supprimera toutes les réponses aux enquêtes et les attributs de contact associés à ce contact. Toute la personnalisation et le ciblage basés sur les données de ce contact seront perdus. Si ce contact a des réponses qui comptent dans les quotas de l'enquête, les comptes de quotas seront réduits mais les limites de quota resteront inchangées.}}",
@@ -660,18 +642,13 @@
       "edit_attribute_description": "Mettez à jour l'étiquette et la description de cet attribut.",
       "edit_attribute_values": "Modifier les attributs",
       "edit_attribute_values_description": "Modifiez les valeurs d'attributs spécifiques pour ce contact.",
-      "edit_attributes": "Modifier les attributs",
       "edit_attributes_success": "Attributs du contact mis à jour avec succès",
       "generate_personal_link": "Générer un lien personnel",
       "generate_personal_link_description": "Sélectionnez une enquête publiée pour générer un lien personnalisé pour ce contact.",
-      "invalid_csv_column_names": "Nom(s) de colonne CSV invalide(s) : {columns}. Les noms de colonnes qui deviendront de nouveaux attributs ne doivent contenir que des lettres minuscules, des chiffres et des underscores, et doivent commencer par une lettre.",
-      "invalid_date_format": "Format de date invalide. Merci d'utiliser une date valide.",
-      "invalid_number_format": "Format de nombre invalide. Veuillez saisir un nombre valide.",
       "no_published_link_surveys_available": "Aucune enquête par lien publiée n'est disponible. Veuillez d'abord publier une enquête par lien.",
       "no_published_surveys": "Aucune enquête publiée",
       "no_responses_found": "Aucune réponse trouvée",
       "not_provided": "Non fourni",
-      "number_value_required": "La valeur numérique est requise. Utilisez le bouton supprimer pour retirer cet attribut.",
       "personal_link_generated": "Lien personnel généré avec succès",
       "personal_link_generated_but_clipboard_failed": "Lien personnel généré mais échec de la copie dans le presse-papiers : {url}",
       "personal_survey_link": "Lien vers le sondage personnel",
@@ -680,22 +657,13 @@
       "search_contact": "Rechercher un contact",
       "select_a_survey": "Sélectionner une enquête",
       "select_attribute": "Sélectionner un attribut",
-      "select_attribute_key": "Sélectionner une clé d'attribut",
-      "system_attributes": "Attributs système",
       "unlock_contacts_description": "Gérer les contacts et envoyer des enquêtes ciblées",
       "unlock_contacts_title": "Débloquez des contacts avec un plan supérieur.",
-      "upload_contacts_error_attribute_type_mismatch": "L'attribut « {key} » est de type « {dataType} » mais le CSV contient des valeurs invalides : {values}",
-      "upload_contacts_error_duplicate_mappings": "Mappages en double trouvés pour les attributs suivants : {attributes}",
-      "upload_contacts_error_file_too_large": "La taille du fichier dépasse la limite maximale de 800 Ko",
-      "upload_contacts_error_generic": "Une erreur s'est produite lors de l'importation des contacts. Veuillez réessayer plus tard.",
-      "upload_contacts_error_invalid_file_type": "Veuillez importer un fichier CSV",
-      "upload_contacts_error_no_valid_contacts": "Le fichier CSV importé ne contient aucun contact valide, veuillez consulter l'exemple de fichier CSV pour le format correct.",
-      "upload_contacts_modal_attribute_header": "Attribut Formbricks",
       "upload_contacts_modal_attributes_description": "Mappez les colonnes de votre CSV aux attributs dans Formbricks.",
       "upload_contacts_modal_attributes_new": "Nouvel attribut",
       "upload_contacts_modal_attributes_search_or_add": "Rechercher ou ajouter un attribut",
+      "upload_contacts_modal_attributes_should_be_mapped_to": "devrait être mappé à",
       "upload_contacts_modal_attributes_title": "Attributs",
-      "upload_contacts_modal_csv_column_header": "Colonne CSV",
       "upload_contacts_modal_description": "Téléchargez un fichier CSV pour importer rapidement des contacts avec des attributs.",
       "upload_contacts_modal_download_example_csv": "Télécharger un exemple de CSV",
       "upload_contacts_modal_duplicates_description": "Que faire si un contact existe déjà ?",
@@ -876,40 +844,6 @@
       "no_attributes_yet": "Aucun attribut pour le moment !",
       "no_filters_yet": "Il n'y a pas encore de filtres !",
       "no_segments_yet": "Aucun segment n'est actuellement enregistré.",
-      "operator_contains": "contient",
-      "operator_does_not_contain": "ne contient pas",
-      "operator_ends_with": "se termine par",
-      "operator_is_after": "est après",
-      "operator_is_before": "est avant",
-      "operator_is_between": "est entre",
-      "operator_is_newer_than": "est plus récent que",
-      "operator_is_not_set": "n'est pas défini",
-      "operator_is_older_than": "est plus ancien que",
-      "operator_is_same_day": "est le même jour",
-      "operator_is_set": "est défini",
-      "operator_starts_with": "commence par",
-      "operator_title_contains": "Contient",
-      "operator_title_does_not_contain": "Ne contient pas",
-      "operator_title_ends_with": "Se termine par",
-      "operator_title_equals": "Égal",
-      "operator_title_greater_equal": "Supérieur ou égal à",
-      "operator_title_greater_than": "Supérieur à",
-      "operator_title_is_after": "Est après",
-      "operator_title_is_before": "Est avant",
-      "operator_title_is_between": "Est entre",
-      "operator_title_is_newer_than": "Est plus récent que",
-      "operator_title_is_not_set": "N'est pas défini",
-      "operator_title_is_older_than": "Est plus ancien que",
-      "operator_title_is_same_day": "Est le même jour",
-      "operator_title_is_set": "Est défini",
-      "operator_title_less_equal": "Inférieur ou égal à",
-      "operator_title_less_than": "Inférieur à",
-      "operator_title_not_equals": "N'est pas égal à",
-      "operator_title_starts_with": "Commence par",
-      "operator_title_user_is_in": "L'utilisateur est dans",
-      "operator_title_user_is_not_in": "L'utilisateur n'est pas dans",
-      "operator_user_is_in": "L'utilisateur est dans",
-      "operator_user_is_not_in": "L'utilisateur n'est pas dans",
       "person_and_attributes": "Personne et attributs",
       "phone": "Téléphone",
       "please_remove_the_segment_from_these_surveys_in_order_to_delete_it": "Veuillez supprimer le segment de ces enquêtes afin de le supprimer.",
@@ -934,7 +868,6 @@
       "user_targeting_is_currently_only_available_when": "La ciblage des utilisateurs est actuellement disponible uniquement lorsque",
       "value_cannot_be_empty": "La valeur ne peut pas être vide.",
       "value_must_be_a_number": "La valeur doit être un nombre.",
-      "value_must_be_positive": "La valeur doit être un nombre positif.",
       "view_filters": "Filtres de vue",
       "where": "Où",
       "with_the_formbricks_sdk": "avec le SDK Formbricks"
@@ -1021,32 +954,19 @@
         "enterprise_features": "Fonctionnalités d'entreprise",
         "get_an_enterprise_license_to_get_access_to_all_features": "Obtenez une licence Entreprise pour accéder à toutes les fonctionnalités.",
         "keep_full_control_over_your_data_privacy_and_security": "Gardez un contrôle total sur la confidentialité et la sécurité de vos données.",
-        "license_invalid_description": "La clé de licence dans votre variable d'environnement ENTERPRISE_LICENSE_KEY n'est pas valide. Veuillez vérifier les fautes de frappe ou demander une nouvelle clé.",
-        "license_status": "Statut de la licence",
-        "license_status_active": "Active",
-        "license_status_description": "Statut de votre licence entreprise.",
-        "license_status_expired": "Expirée",
-        "license_status_invalid": "Licence invalide",
-        "license_status_unreachable": "Inaccessible",
-        "license_unreachable_grace_period": "Le serveur de licence est injoignable. Vos fonctionnalités entreprise restent actives pendant une période de grâce de 3 jours se terminant le {gracePeriodEnd}.",
         "no_call_needed_no_strings_attached_request_a_free_30_day_trial_license_to_test_all_features_by_filling_out_this_form": "Aucun appel nécessaire, aucune obligation : Demandez une licence d'essai gratuite de 30 jours pour tester toutes les fonctionnalités en remplissant ce formulaire :",
         "no_credit_card_no_sales_call_just_test_it": "Aucune carte de crédit. Aucun appel de vente. Testez-le simplement :)",
         "on_request": "Sur demande",
         "organization_roles": "Rôles d'organisation (Administrateur, Éditeur, Développeur, etc.)",
         "questions_please_reach_out_to": "Des questions ? Veuillez contacter",
-        "recheck_license": "Revérifier la licence",
-        "recheck_license_failed": "La vérification de la licence a échoué. Le serveur de licences est peut-être inaccessible.",
-        "recheck_license_invalid": "La clé de licence est invalide. Veuillez vérifier votre ENTERPRISE_LICENSE_KEY.",
-        "recheck_license_success": "Vérification de la licence réussie",
-        "recheck_license_unreachable": "Le serveur de licences est inaccessible. Veuillez réessayer plus tard.",
-        "rechecking": "Revérification en cours...",
         "request_30_day_trial_license": "Demander une licence d'essai de 30 jours",
         "saml_sso": "SAML SSO",
         "service_level_agreement": "Accord de niveau de service",
         "soc2_hipaa_iso_27001_compliance_check": "Vérification de conformité SOC2, HIPAA, ISO 27001",
         "sso": "SSO (Google, Microsoft, OpenID Connect)",
         "teams": "Équipes et Rôles d'Accès (Lire, Lire et Écrire, Gérer)",
-        "unlock_the_full_power_of_formbricks_free_for_30_days": "Débloquez tout le potentiel de Formbricks. Gratuit pendant 30 jours."
+        "unlock_the_full_power_of_formbricks_free_for_30_days": "Débloquez tout le potentiel de Formbricks. Gratuit pendant 30 jours.",
+        "your_enterprise_license_is_active_all_features_unlocked": "Votre licence d'entreprise est active. Toutes les fonctionnalités sont déverrouillées."
       },
       "general": {
         "bulk_invite_warning_description": "Dans le plan gratuit, tous les membres de l'organisation se voient toujours attribuer le rôle \"Owner\".",
@@ -1070,7 +990,7 @@
         "from_your_organization": "de votre organisation",
         "invitation_sent_once_more": "Invitation envoyée une fois de plus.",
         "invite_deleted_successfully": "Invitation supprimée avec succès",
-        "invite_expires_on": "L'invitation expire le {date}",
+        "invited_on": "Invité le {date}",
         "invites_failed": "Invitations échouées",
         "leave_organization": "Quitter l'organisation",
         "leave_organization_description": "Vous quitterez cette organisation et perdrez l'accès à toutes les enquêtes et réponses. Vous ne pourrez revenir que si vous êtes de nouveau invité.",
@@ -1183,6 +1103,8 @@
         "please_fill_all_workspace_fields": "Veuillez remplir tous les champs pour ajouter un nouvel espace de travail.",
         "read": "Lire",
         "read_write": "Lire et Écrire",
+        "select_member": "Sélectionner membre",
+        "select_workspace": "Sélectionner un espace de travail",
         "team_admin": "Administrateur d'équipe",
         "team_created_successfully": "Équipe créée avec succès.",
         "team_deleted_successfully": "Équipe supprimée avec succès.",
@@ -1232,6 +1154,7 @@
         "add_fallback_placeholder": "Ajouter un espace réservé à afficher s'il n'y a pas de valeur à rappeler.",
         "add_hidden_field_id": "Ajouter un champ caché ID",
         "add_highlight_border": "Ajouter une bordure de surlignage",
+        "add_highlight_border_description": "Ajoutez une bordure extérieure à votre carte d'enquête.",
         "add_logic": "Ajouter de la logique",
         "add_none_of_the_above": "Ajouter \"Aucun des éléments ci-dessus\"",
         "add_option": "Ajouter une option",
@@ -1249,6 +1172,7 @@
         "adjust_survey_closed_message_description": "Modifiez le message que les visiteurs voient lorsque l'enquête est fermée.",
         "adjust_the_theme_in_the": "Ajustez le thème dans le",
         "all_other_answers_will_continue_to": "Toutes les autres réponses continueront à",
+        "allow_file_type": "Autoriser le type de fichier",
         "allow_multi_select": "Autoriser la sélection multiple",
         "allow_multiple_files": "Autoriser plusieurs fichiers",
         "allow_users_to_select_more_than_one_image": "Permettre aux utilisateurs de sélectionner plusieurs images",
@@ -1270,7 +1194,6 @@
         "block_duplicated": "Bloc dupliqué.",
         "bold": "Gras",
         "brand_color": "Couleur de marque",
-        "brand_color_description": "Appliqué aux boutons, liens et éléments mis en évidence.",
         "brightness": "Luminosité",
         "bulk_edit": "Modification en masse",
         "bulk_edit_description": "Modifiez toutes les options ci-dessous, une par ligne. Les lignes vides seront ignorées et les doublons supprimés.",
@@ -1288,9 +1211,7 @@
         "capture_new_action": "Capturer une nouvelle action",
         "card_arrangement_for_survey_type_derived": "Disposition des cartes pour les enquêtes {surveyTypeDerived}",
         "card_background_color": "Couleur de fond de la carte",
-        "card_background_color_description": "Remplit la zone de la carte d'enquête.",
         "card_border_color": "Couleur de la bordure de la carte",
-        "card_border_color_description": "Délimite la carte d'enquête.",
         "card_styling": "Style de carte",
         "casual": "Décontracté",
         "caution_edit_duplicate": "Dupliquer et modifier",
@@ -1301,14 +1222,24 @@
         "caution_explanation_responses_are_safe": "Les réponses anciennes et nouvelles se mélangent, ce qui peut entraîner des résumés de données trompeurs.",
         "caution_recommendation": "Cela peut entraîner des incohérences de données dans le résumé du sondage. Nous recommandons de dupliquer le sondage à la place.",
         "caution_text": "Les changements entraîneront des incohérences.",
+        "centered_modal_overlay_color": "Couleur de superposition modale centrée",
         "change_anyway": "Changer de toute façon",
         "change_background": "Changer l'arrière-plan",
         "change_question_type": "Changer le type de question",
         "change_survey_type": "Le changement de type de sondage affecte l'accès existant",
+        "change_the_background_color_of_the_card": "Changez la couleur de fond de la carte.",
+        "change_the_background_color_of_the_input_fields": "Vous pouvez modifier la couleur d'arrière-plan des champs de saisie.",
         "change_the_background_to_a_color_image_or_animation": "Changez l'arrière-plan en une couleur, une image ou une animation.",
+        "change_the_border_color_of_the_card": "Changez la couleur de la bordure de la carte.",
+        "change_the_border_color_of_the_input_fields": "Vous pouvez modifier la couleur de la bordure des champs de saisie.",
+        "change_the_border_radius_of_the_card_and_the_inputs": "Vous pouvez arrondir la bordure des encadrés et des champs de saisie.",
+        "change_the_brand_color_of_the_survey": "Vous pouvez modifier la couleur dominante d'une enquête.",
         "change_the_placement_of_this_survey": "Changez le placement de cette enquête.",
+        "change_the_question_color_of_the_survey": "Vous pouvez modifier la couleur des questions d'une enquête.",
         "changes_saved": "Modifications enregistrées.",
         "changing_survey_type_will_remove_existing_distribution_channels": "Le changement du type de sondage affectera la façon dont il peut être partagé. Si les répondants ont déjà des liens d'accès pour le type actuel, ils peuvent perdre l'accès après le changement.",
+        "character_limit_toggle_description": "Limitez la longueur des réponses.",
+        "character_limit_toggle_title": "Ajouter des limites de caractères",
         "checkbox_label": "Étiquette de case à cocher",
         "choose_the_actions_which_trigger_the_survey": "Choisissez les actions qui déclenchent l'enquête.",
         "choose_the_first_question_on_your_block": "Choisissez la première question de votre bloc",
@@ -1328,6 +1259,7 @@
         "contact_fields": "Champs de contact",
         "contains": "Contient",
         "continue_to_settings": "Continuer vers les paramètres",
+        "control_which_file_types_can_be_uploaded": "Contrôlez quels types de fichiers peuvent être téléchargés.",
         "convert_to_multiple_choice": "Convertir en choix multiples",
         "convert_to_single_choice": "Convertir en choix unique",
         "country": "Pays",
@@ -1340,13 +1272,11 @@
         "darken_or_lighten_background_of_your_choice": "Assombrir ou éclaircir l'arrière-plan de votre choix.",
         "date_format": "Format de date",
         "days_before_showing_this_survey_again": "ou plus de jours doivent s'écouler entre le dernier sondage affiché et l'affichage de ce sondage.",
-        "delete_anyways": "Supprimer quand même",
         "delete_block": "Supprimer le bloc",
         "delete_choice": "Supprimer l'option",
         "disable_the_visibility_of_survey_progress": "Désactiver la visibilité de la progression du sondage.",
         "display_an_estimate_of_completion_time_for_survey": "Afficher une estimation du temps de complétion pour l'enquête.",
         "display_number_of_responses_for_survey": "Afficher le nombre de réponses pour l'enquête",
-        "display_type": "Type d'affichage",
         "divide": "Diviser /",
         "does_not_contain": "Ne contient pas",
         "does_not_end_with": "Ne se termine pas par",
@@ -1354,7 +1284,6 @@
         "does_not_include_all_of": "n'inclut pas tout",
         "does_not_include_one_of": "n'inclut pas un de",
         "does_not_start_with": "Ne commence pas par",
-        "dropdown": "Menu déroulant",
         "duplicate_block": "Dupliquer le bloc",
         "duplicate_question": "Dupliquer la question",
         "edit_link": "Modifier le lien",
@@ -1446,7 +1375,8 @@
         "hide_progress_bar": "Cacher la barre de progression",
         "hide_question_settings": "Masquer les paramètres de la question",
         "hostname": "Nom d'hôte",
-        "if_you_need_more_please": "Si vous avez besoin de plus, veuillez",
+        "how_funky_do_you_want_your_cards_in_survey_type_derived_surveys": "À quel point voulez-vous que vos cartes soient funky dans les enquêtes {surveyTypeDerived}",
+        "if_you_need_more_please": "Si vous en avez besoin de plus, s'il vous plaît",
         "if_you_really_want_that_answer_ask_until_you_get_it": "Continuer à afficher à chaque déclenchement jusqu'à ce qu'une réponse soit soumise.",
         "ignore_global_waiting_time": "Ignorer la période de refroidissement",
         "ignore_global_waiting_time_description": "Cette enquête peut s'afficher chaque fois que ses conditions sont remplies, même si une autre enquête a été affichée récemment.",
@@ -1456,9 +1386,7 @@
         "initial_value": "Valeur initiale",
         "inner_text": "Texte interne",
         "input_border_color": "Couleur de la bordure des champs de saisie",
-        "input_border_color_description": "Délimite les champs de texte et les zones de texte.",
         "input_color": "Couleur d'arrière-plan des champs de saisie",
-        "input_color_description": "Remplit l'intérieur des champs de texte.",
         "insert_link": "Insérer un lien",
         "invalid_targeting": "Ciblage invalide : Veuillez vérifier vos filtres d'audience",
         "invalid_video_url_warning": "Merci d'entrer une URL YouTube, Vimeo ou Loom valide. Les autres plateformes vidéo ne sont pas encore supportées.",
@@ -1485,10 +1413,10 @@
         "key": "Clé",
         "last_name": "Nom de famille",
         "let_people_upload_up_to_25_files_at_the_same_time": "Permettre aux utilisateurs de télécharger jusqu'à 25 fichiers en même temps.",
-        "limit_the_maximum_file_size": "Limiter la taille maximale des fichiers pour les téléversements.",
-        "limit_upload_file_size_to": "Limiter la taille de téléversement des fichiers à",
+        "limit_file_types": "Limiter les types de fichiers",
+        "limit_the_maximum_file_size": "Limiter la taille maximale du fichier",
+        "limit_upload_file_size_to": "Limiter la taille des fichiers téléchargés à",
         "link_survey_description": "Partagez un lien vers une page d'enquête ou intégrez-le dans une page web ou un e-mail.",
-        "list": "Liste",
         "load_segment": "Segment de chargement",
         "logic_error_warning": "Changer causera des erreurs logiques",
         "logic_error_warning_text": "Changer le type de question supprimera les conditions logiques de cette question.",
@@ -1500,7 +1428,7 @@
         "matrix_all_fields": "Tous les champs",
         "matrix_rows": "Lignes",
         "max_file_size": "Taille maximale du fichier",
-        "max_file_size_limit_is": "La limite de taille maximale du fichier est",
+        "max_file_size_limit_is": "La taille maximale du fichier est",
         "move_question_to_block": "Déplacer la question vers le bloc",
         "multiply": "Multiplier *",
         "needed_for_self_hosted_cal_com_instance": "Nécessaire pour une instance Cal.com auto-hébergée",
@@ -1532,6 +1460,7 @@
         "picture_idx": "Image {idx}",
         "pin_can_only_contain_numbers": "Le code PIN ne peut contenir que des chiffres.",
         "pin_must_be_a_four_digit_number": "Le code PIN doit être un numéro à quatre chiffres.",
+        "please_enter_a_file_extension": "Veuillez entrer une extension de fichier.",
         "please_enter_a_valid_url": "Veuillez entrer une URL valide (par exemple, https://example.com)",
         "please_set_a_survey_trigger": "Veuillez définir un déclencheur d'enquête.",
         "please_specify": "Veuillez préciser",
@@ -1542,12 +1471,12 @@
         "protect_survey_with_pin_description": "Seules les personnes ayant le code PIN peuvent accéder à l'enquête.",
         "publish": "Publier",
         "question": "Question",
+        "question_color": "Couleur des questions",
         "question_deleted": "Question supprimée.",
         "question_duplicated": "Question dupliquée.",
         "question_id_updated": "ID de la question mis à jour",
-        "question_used_in_logic_warning_text": "Des éléments de ce bloc sont utilisés dans une règle logique, êtes-vous sûr de vouloir le supprimer ?",
-        "question_used_in_logic_warning_title": "Incohérence de logique",
-        "question_used_in_quota": "Cette question est utilisée dans le quota “{quotaName}”",
+        "question_used_in_logic": "Cette question est utilisée dans la logique de la question '{'questionIndex'}'.",
+        "question_used_in_quota": "Cette question est utilisée dans le quota \"{quotaName}\"",
         "question_used_in_recall": "Cette question est rappelée dans la question {questionIndex}.",
         "question_used_in_recall_ending_card": "Cette question est rappelée dans la carte de fin.",
         "quotas": {
@@ -1603,7 +1532,6 @@
         "response_limits_redirections_and_more": "Limites de réponse, redirections et plus.",
         "response_options": "Options de réponse",
         "roundness": "Rondeur",
-        "roundness_description": "Contrôle l'arrondi des coins de la carte.",
         "row_used_in_logic_error": "Cette ligne est utilisée dans la logique de la question {questionIndex}. Veuillez d'abord la supprimer de la logique.",
         "rows": "Lignes",
         "save_and_close": "Enregistrer et fermer",
@@ -1611,7 +1539,6 @@
         "search_for_images": "Rechercher des images",
         "seconds_after_trigger_the_survey_will_be_closed_if_no_response": "Les secondes après le déclenchement, l'enquête sera fermée si aucune réponse n'est donnée.",
         "seconds_before_showing_the_survey": "secondes avant de montrer l'enquête.",
-        "select_field": "Sélectionner un champ",
         "select_or_type_value": "Sélectionnez ou saisissez une valeur",
         "select_ordering": "Choisir l'ordre",
         "select_saved_action": "Sélectionner une action enregistrée",
@@ -1645,6 +1572,7 @@
         "styling_set_to_theme_styles": "Style défini sur les styles du thème",
         "subheading": "Sous-titre",
         "subtract": "Soustraire -",
+        "suggest_colors": "Suggérer des couleurs",
         "survey_completed_heading": "Enquête terminée",
         "survey_completed_subheading": "Cette enquête gratuite et open-source a été fermée",
         "survey_display_settings": "Paramètres d'affichage de l'enquête",
@@ -1658,6 +1586,8 @@
         "the_survey_will_be_shown_once_even_if_person_doesnt_respond": "Afficher une seule fois, même si la personne ne répond pas.",
         "then": "Alors",
         "this_action_will_remove_all_the_translations_from_this_survey": "Cette action supprimera toutes les traductions de cette enquête.",
+        "this_extension_is_already_added": "Cette extension est déjà ajoutée.",
+        "this_file_type_is_not_supported": "Ce type de fichier n'est pas pris en charge.",
         "three_points": "3 points",
         "times": "fois",
         "to_keep_the_placement_over_all_surveys_consistent_you_can": "Pour maintenir la cohérence du placement sur tous les sondages, vous pouvez",
@@ -1678,51 +1608,8 @@
         "upper_label": "Étiquette supérieure",
         "url_filters": "Filtres d'URL",
         "url_not_supported": "URL non supportée",
-        "validation": {
-          "add_validation_rule": "Ajouter une règle de validation",
-          "answer_all_rows": "Répondre à toutes les lignes",
-          "characters": "Caractères",
-          "contains": "Contient",
-          "delete_validation_rule": "Supprimer la règle de validation",
-          "does_not_contain": "Ne contient pas",
-          "email": "Est un e-mail valide",
-          "end_date": "Date de fin",
-          "file_extension_is": "L'extension de fichier est",
-          "file_extension_is_not": "L'extension de fichier n'est pas",
-          "is": "Est",
-          "is_between": "Est entre",
-          "is_earlier_than": "Est antérieur à",
-          "is_greater_than": "Est supérieur à",
-          "is_later_than": "Est postérieur à",
-          "is_less_than": "Est inférieur à",
-          "is_not": "N'est pas",
-          "is_not_between": "N'est pas entre",
-          "kb": "Ko",
-          "max_length": "Au maximum",
-          "max_selections": "Au maximum",
-          "max_value": "Au maximum",
-          "mb": "Mo",
-          "min_length": "Au moins",
-          "min_selections": "Au moins",
-          "min_value": "Au moins",
-          "minimum_options_ranked": "Nombre minimum d'options classées",
-          "minimum_rows_answered": "Nombre minimum de lignes répondues",
-          "options_selected": "Options sélectionnées",
-          "pattern": "Correspond au modèle d'expression régulière",
-          "phone": "Est un numéro de téléphone valide",
-          "rank_all_options": "Classer toutes les options",
-          "select_file_extensions": "Sélectionner les extensions de fichier...",
-          "select_option": "Sélectionner une option",
-          "start_date": "Date de début",
-          "url": "Est une URL valide"
-        },
-        "validation_logic_and": "Toutes sont vraies",
-        "validation_logic_or": "au moins une est vraie",
-        "validation_rules": "Règles de validation",
-        "validation_rules_description": "Accepter uniquement les réponses qui répondent aux critères suivants",
         "variable_is_used_in_logic_of_question_please_remove_it_from_logic_first": "{variable} est utilisé dans la logique de la question {questionIndex}. Veuillez d'abord le supprimer de la logique.",
-        "variable_is_used_in_quota_please_remove_it_from_quota_first": "La variable “{variableName}” est utilisée dans le quota “{quotaName}”",
-        "variable_name_conflicts_with_hidden_field": "Le nom de la variable est en conflit avec un ID de champ masqué existant.",
+        "variable_is_used_in_quota_please_remove_it_from_quota_first": "La variable \"{variableName}\" est utilisée dans le quota \"{quotaName}\"",
         "variable_name_is_already_taken_please_choose_another": "Le nom de la variable est déjà pris, veuillez en choisir un autre.",
         "variable_name_must_start_with_a_letter": "Le nom de la variable doit commencer par une lettre.",
         "variable_used_in_recall": "La variable \"{variable}\" est rappelée dans la question {questionIndex}.",
@@ -2128,71 +2015,9 @@
       "look": {
         "add_background_color": "Ajouter une couleur d'arrière-plan",
         "add_background_color_description": "Ajoutez une couleur d'arrière-plan au conteneur du logo.",
-        "advanced_styling_field_border_radius": "Rayon de bordure",
-        "advanced_styling_field_button_bg": "Arrière-plan du bouton",
-        "advanced_styling_field_button_bg_description": "Remplit le bouton Suivant / Envoyer.",
-        "advanced_styling_field_button_border_radius_description": "Arrondit les coins du bouton.",
-        "advanced_styling_field_button_font_size_description": "Ajuste la taille du texte du libellé du bouton.",
-        "advanced_styling_field_button_font_weight_description": "Rend le texte du bouton plus léger ou plus gras.",
-        "advanced_styling_field_button_height_description": "Contrôle la hauteur du bouton.",
-        "advanced_styling_field_button_padding_x_description": "Ajoute de l'espace à gauche et à droite.",
-        "advanced_styling_field_button_padding_y_description": "Ajoute de l'espace en haut et en bas.",
-        "advanced_styling_field_button_text": "Texte du bouton",
-        "advanced_styling_field_button_text_description": "Colore le libellé à l'intérieur des boutons.",
-        "advanced_styling_field_description_color": "Couleur de la description",
-        "advanced_styling_field_description_color_description": "Colore le texte sous chaque titre.",
-        "advanced_styling_field_description_size": "Taille de police de la description",
-        "advanced_styling_field_description_size_description": "Ajuste la taille du texte de description.",
-        "advanced_styling_field_description_weight": "Graisse de police de la description",
-        "advanced_styling_field_description_weight_description": "Rend le texte de description plus léger ou plus gras.",
-        "advanced_styling_field_font_size": "Taille de police",
-        "advanced_styling_field_font_weight": "Graisse de police",
-        "advanced_styling_field_headline_color": "Couleur du titre",
-        "advanced_styling_field_headline_color_description": "Colore le texte principal de la question.",
-        "advanced_styling_field_headline_size": "Taille de police du titre",
-        "advanced_styling_field_headline_size_description": "Ajuste la taille du texte du titre.",
-        "advanced_styling_field_headline_weight": "Graisse de police du titre",
-        "advanced_styling_field_headline_weight_description": "Rend le texte du titre plus léger ou plus gras.",
-        "advanced_styling_field_height": "Hauteur minimale",
-        "advanced_styling_field_indicator_bg": "Arrière-plan de l'indicateur",
-        "advanced_styling_field_indicator_bg_description": "Colore la partie remplie de la barre.",
-        "advanced_styling_field_input_border_radius_description": "Arrondit les coins du champ de saisie.",
-        "advanced_styling_field_input_font_size_description": "Ajuste la taille du texte saisi dans les champs.",
-        "advanced_styling_field_input_height_description": "Contrôle la hauteur minimale du champ de saisie.",
-        "advanced_styling_field_input_padding_x_description": "Ajoute de l'espace à gauche et à droite.",
-        "advanced_styling_field_input_padding_y_description": "Ajoute de l'espace en haut et en bas.",
-        "advanced_styling_field_input_placeholder_opacity_description": "Atténue le texte d'indication du placeholder.",
-        "advanced_styling_field_input_shadow_description": "Ajoute une ombre portée autour des champs de saisie.",
-        "advanced_styling_field_input_text": "Texte de saisie",
-        "advanced_styling_field_input_text_description": "Colore le texte saisi dans les champs.",
-        "advanced_styling_field_option_bg": "Arrière-plan",
-        "advanced_styling_field_option_bg_description": "Remplit les éléments d'option.",
-        "advanced_styling_field_option_border_radius_description": "Arrondit les coins des options.",
-        "advanced_styling_field_option_font_size_description": "Ajuste la taille du texte des libellés d'option.",
-        "advanced_styling_field_option_label": "Couleur de l'étiquette",
-        "advanced_styling_field_option_label_description": "Colore le texte des libellés d'option.",
-        "advanced_styling_field_option_padding_x_description": "Ajoute de l'espace à gauche et à droite.",
-        "advanced_styling_field_option_padding_y_description": "Ajoute de l'espace en haut et en bas.",
-        "advanced_styling_field_padding_x": "Marge intérieure X",
-        "advanced_styling_field_padding_y": "Marge intérieure Y",
-        "advanced_styling_field_placeholder_opacity": "Opacité du placeholder",
-        "advanced_styling_field_shadow": "Ombre",
-        "advanced_styling_field_track_bg": "Arrière-plan de la piste",
-        "advanced_styling_field_track_bg_description": "Colore la partie non remplie de la barre.",
-        "advanced_styling_field_track_height": "Hauteur de la piste",
-        "advanced_styling_field_track_height_description": "Contrôle l'épaisseur de la barre de progression.",
-        "advanced_styling_field_upper_label_color": "Couleur de l'étiquette du titre",
-        "advanced_styling_field_upper_label_color_description": "Colore le petit libellé au-dessus des champs de saisie.",
-        "advanced_styling_field_upper_label_size": "Taille de police de l'étiquette du titre",
-        "advanced_styling_field_upper_label_size_description": "Ajuste la taille du petit libellé au-dessus des champs de saisie.",
-        "advanced_styling_field_upper_label_weight": "Graisse de police de l'étiquette du titre",
-        "advanced_styling_field_upper_label_weight_description": "Rend le libellé plus léger ou plus gras.",
-        "advanced_styling_section_buttons": "Boutons",
-        "advanced_styling_section_headlines": "Titres et descriptions",
-        "advanced_styling_section_inputs": "Champs de saisie",
-        "advanced_styling_section_options": "Options (boutons radio/cases à cocher)",
         "app_survey_placement": "Placement du sondage d'application",
         "app_survey_placement_settings_description": "Modifiez l'emplacement où les sondages seront affichés dans votre application web ou site web.",
+        "centered_modal_overlay_color": "Couleur de superposition modale centrée",
         "email_customization": "Personnalisation des e-mails",
         "email_customization_description": "Modifiez l'apparence des e-mails que Formbricks envoie en votre nom.",
         "enable_custom_styling": "Activer le style personnalisé",
@@ -2203,9 +2028,6 @@
         "formbricks_branding_hidden": "Le logo Formbricks est masqué.",
         "formbricks_branding_settings_description": "Nous apprécions votre soutien mais comprenons si vous choisissez de le désactiver.",
         "formbricks_branding_shown": "Le logo Formbricks est affiché.",
-        "generate_theme_btn": "Générer",
-        "generate_theme_confirmation": "Souhaitez-vous générer un thème de couleurs assorti basé sur votre couleur de marque ? Cela écrasera vos paramètres de couleur actuels.",
-        "generate_theme_header": "Générer un thème de couleurs ?",
         "logo_removed_successfully": "Logo supprimé avec succès",
         "logo_settings_description": "Téléchargez le logo de votre entreprise pour personnaliser les enquêtes et les aperçus de liens.",
         "logo_updated_successfully": "Logo mis à jour avec succès",
@@ -2220,8 +2042,6 @@
         "show_formbricks_branding_in": "Afficher le logo Formbricks dans les enquêtes {type}",
         "show_powered_by_formbricks": "Afficher la signature « Propulsé par Formbricks »",
         "styling_updated_successfully": "Style mis à jour avec succès",
-        "suggest_colors": "Suggérer des couleurs",
-        "suggested_colors_applied_please_save": "Couleurs suggérées générées avec succès. Appuyez sur « Enregistrer » pour conserver les modifications.",
         "theme": "Thème",
         "theme_settings_description": "Créez un thème de style pour toutes les enquêtes. Vous pouvez activer un style personnalisé pour chaque enquête."
       },
@@ -2985,7 +2805,6 @@
     "preview_survey_question_2_choice_1_label": "Oui, tenez-moi au courant.",
     "preview_survey_question_2_choice_2_label": "Non, merci !",
     "preview_survey_question_2_headline": "Souhaitez-vous être informé ?",
-    "preview_survey_question_2_subheader": "Ceci est un exemple de description.",
     "preview_survey_welcome_card_headline": "Bienvenue !",
     "prioritize_features_description": "Identifiez les fonctionnalités dont vos utilisateurs ont le plus et le moins besoin.",
     "prioritize_features_name": "Prioriser les fonctionnalités",