@rebasepro/app 0.11.1-canary.gfd39654 → 0.12.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/app",
   "type": "module",
-  "version": "0.11.1-canary.gfd39654",
+  "version": "0.12.0",
   "description": "Rebase core — framework-agnostic runtime for data-driven admin panels",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -52,12 +52,12 @@
     "magic-string": "^0.30.0",
     "notistack": "^3.0.2",
     "react-i18next": "^17.0.8",
-    "@rebasepro/common": "0.11.1-canary.gfd39654",
-    "@rebasepro/types": "0.11.1-canary.gfd39654",
-    "@rebasepro/ui": "0.11.1-canary.gfd39654",
-    "@rebasepro/utils": "0.11.1-canary.gfd39654",
-    "@rebasepro/admin-types": "0.11.1-canary.gfd39654",
-    "@rebasepro/forms": "0.11.1-canary.gfd39654"
+    "@rebasepro/admin-types": "0.12.0",
+    "@rebasepro/types": "0.12.0",
+    "@rebasepro/ui": "0.12.0",
+    "@rebasepro/forms": "0.12.0",
+    "@rebasepro/utils": "0.12.0",
+    "@rebasepro/common": "0.12.0"
   },
   "peerDependencies": {
     "react": ">=19.0.0",

package/src/collections/filter-operator-resolution.ts

@@ -1,8 +1,10 @@
 import {
     ALL_WHERE_FILTER_OPS,
     DataType,
+    DEFAULT_FILTERABLE_RELATION_KINDS,
     getDataSourceCapabilities,
     Property,
+    RelationProperty,
     WhereFilterOp
 } from "@rebasepro/types";
 
@@ -30,6 +32,39 @@ const DEFAULT_OPS_BY_TYPE: Partial<Record<DataType, readonly WhereFilterOp[]>> =
 /** Operators offered when the property is an *array of* a filterable type. */
 const ARRAY_OPS: readonly WhereFilterOp[] = ["array-contains", "array-contains-any"];
 
+/**
+ * Whether a relation is one the collection's engine can compile into a
+ * `WHERE`.
+ *
+ * Which kinds those are is the *driver's* answer, not this function's, so it
+ * comes from {@link DataSourceCapabilities.filterableRelationKinds}. The admin
+ * is one UI over Postgres, MongoDB, Firestore and whatever a developer
+ * registers, and "a many-to-many compiles to an `EXISTS` over the junction" is
+ * a fact about the Postgres driver — true today, and not the sort of thing to
+ * assert on an engine's behalf.
+ *
+ * Offering an uncompilable filter is not a cosmetic bug. The Postgres driver
+ * used to drop a filter key it could not resolve, which *widened* the result
+ * set — filtering a many-to-many column returned every row instead of none.
+ * That now fails closed with a 400, which is correct for a real schema drift
+ * and wrong as the answer to a control the admin itself put on screen.
+ *
+ * A relation whose kind cannot be determined at all — no inline `relation`
+ * block and no stamped `resolvedRelation` — stays filterable. The server
+ * resolves relations before the config reaches the admin, so this is the
+ * hand-built-property case, and silently dropping a working filter there would
+ * be its own regression.
+ */
+export function isFilterableRelation(property: Property, engine?: string): boolean {
+    if (property.type !== "relation") return true;
+    const relationProperty = property as RelationProperty;
+    const kind = relationProperty.relation?.kind ?? relationProperty.resolvedRelation?.kind;
+    if (!kind) return true;
+    const kinds = getDataSourceCapabilities(engine).filterableRelationKinds
+        ?? DEFAULT_FILTERABLE_RELATION_KINDS;
+    return kinds.includes(kind);
+}
+
 export interface ResolveFilterOperatorsParams {
     /**
      * The property to filter on. For array properties, pass the **item**
@@ -56,8 +91,9 @@ export interface ResolveFilterOperatorsParams {
  * 2. what makes sense for the property type (e.g. no `>` on booleans);
  * 3. the developer's optional narrowing — `property.admin.filterOperators`.
  *
- * Returns an empty array when the property is not filterable (either by
- * type, or because the developer disabled it with `filterOperators: []`).
+ * Returns an empty array when the property is not filterable — by type, by
+ * developer narrowing (`filterOperators: []`), or because it is a relation the
+ * query layer has no column for (see {@link isFilterableRelation}).
  *
  * @group Models
  */
@@ -66,6 +102,8 @@ export function resolveFilterOperators({
     isArray,
     engine
 }: ResolveFilterOperatorsParams): WhereFilterOp[] {
+    if (!isFilterableRelation(property, engine)) return [];
+
     const typeDefaults: readonly WhereFilterOp[] = isArray
         ? ARRAY_OPS
         : DEFAULT_OPS_BY_TYPE[property.type] ?? [];

package/src/collections/property_presentation.ts

@@ -14,7 +14,8 @@
  * declarative conditions feature is authored and stored, never applied. It lives
  * here now because here is where it would be called from once it is wired up.
  */
-import type { ArrayProperty, ConditionContext, EnumValueConfig, Property, PropertyConditions, ReferenceProperty } from "@rebasepro/types";
+import type { ConditionContext, EnumValueConfig, Property, PropertyConditions, ReferenceProperty } from "@rebasepro/types";
+import type { AdminArrayOptions, AdminReferenceOptions } from "@rebasepro/admin-types";
 import { evaluateCondition } from "@rebasepro/common";
 
 export function isReadOnly(property: Property): boolean {
@@ -126,7 +127,9 @@ export function applyPropertyConditions(
             (result as ReferenceProperty).path = evaluateCondition(conditions.referencePath, context) as string;
         }
         if (conditions.referenceFilter) {
-            (result as ReferenceProperty).fixedFilter = evaluateCondition(conditions.referenceFilter, context) as ReferenceProperty["fixedFilter"];
+            result.admin = result.admin || {};
+            (result.admin as AdminReferenceOptions).fixedFilter =
+                evaluateCondition(conditions.referenceFilter, context) as AdminReferenceOptions["fixedFilter"];
         }
     }
 
@@ -136,10 +139,12 @@ export function applyPropertyConditions(
 
     if (result.type === "array") {
         if (conditions.canAddElements !== undefined) {
-            (result as ArrayProperty).canAddElements = evaluateCondition(conditions.canAddElements, context) as boolean;
+            result.admin = result.admin || {};
+            (result.admin as AdminArrayOptions).canAddElements = evaluateCondition(conditions.canAddElements, context) as boolean;
         }
         if (conditions.sortable !== undefined) {
-            (result as ArrayProperty).sortable = evaluateCondition(conditions.sortable, context) as boolean;
+            result.admin = result.admin || {};
+            (result.admin as AdminArrayOptions).sortable = evaluateCondition(conditions.sortable, context) as boolean;
         }
     }
 

package/src/collections/title-property.ts

@@ -1,4 +1,4 @@
-import type { Property, Relation } from "@rebasepro/types";
+import { isRelationalCollectionConfig, type Property, type Relation } from "@rebasepro/types";
 import { generateForeignKeyName } from "@rebasepro/utils";
 import type { AdminCollection } from "@rebasepro/admin-types";
 import { getPrimaryKeys, isPropertyBuilder } from "@rebasepro/common";
@@ -104,7 +104,7 @@ function getForeignKeyColumns<M extends Record<string, unknown>>(collection: Adm
         }
     };
 
-    for (const relation of collection.relations ?? []) {
+    for (const relation of (isRelationalCollectionConfig(collection) ? collection.relations : undefined) ?? []) {
         addRelationKeys(relation);
     }
 

package/src/components/LoginView/LoginView.tsx

@@ -21,6 +21,7 @@ declare global {
 import {
     ArrowLeftIcon,
     Button,
+    Checkbox,
     cls,
     IconButton,
     iconSize,
@@ -141,6 +142,15 @@ export interface LoginViewProps {
      * Pre-fill the password field (e.g. for demo or testing environments).
      */
     defaultPassword?: string;
+
+    /**
+     * When set, the email/password forms render a "Join the newsletter"
+     * opt-in checkbox. Called with the address that just authenticated —
+     * sign-in or registration — if the box was ticked. Wire it to whatever
+     * stores the subscription; failures are the callback's problem, the
+     * login flow never waits on it.
+     */
+    onNewsletterOptIn?: (email: string) => void;
 }
 
 type AuthMode = "buttons" | "login" | "register" | "forgot";
@@ -203,7 +213,8 @@ export function LoginView({
     additionalComponent,
     topComponent,
     defaultEmail,
-    defaultPassword
+    defaultPassword,
+    onNewsletterOptIn
 }: LoginViewProps) {
 
     const modeState = useModeController();
@@ -213,6 +224,9 @@ export function LoginView({
     const [mode, setMode] = useState<AuthMode>("buttons");
     const [fadeIn, setFadeIn] = useState(false);
     const [viewVisible, setViewVisible] = useState(true);
+    // Lives here, not in LoginForm: the form unmounts on every login↔register
+    // switch, and losing the tick on a mode change would silently drop opt-ins.
+    const [newsletterOptIn, setNewsletterOptIn] = useState(false);
 
     const switchMode = (newMode: AuthMode) => {
         setViewVisible(false);
@@ -360,6 +374,9 @@ export function LoginView({
                             bootstrapMode={true}
                             defaultEmail={defaultEmail}
                             defaultPassword={defaultPassword}
+                            onNewsletterOptIn={onNewsletterOptIn}
+                            newsletterOptIn={newsletterOptIn}
+                            setNewsletterOptIn={setNewsletterOptIn}
                         />
                     )}
 
@@ -442,6 +459,9 @@ export function LoginView({
                                     switchToRegister={showRegistration ? () => switchMode("register") : undefined}
                                     defaultEmail={defaultEmail}
                                     defaultPassword={defaultPassword}
+                                    onNewsletterOptIn={onNewsletterOptIn}
+                                    newsletterOptIn={newsletterOptIn}
+                                    setNewsletterOptIn={setNewsletterOptIn}
                                 />
                             )}
 
@@ -457,6 +477,9 @@ export function LoginView({
                                     switchToLogin={() => switchMode("login")}
                                     defaultEmail={defaultEmail}
                                     defaultPassword={defaultPassword}
+                                    onNewsletterOptIn={onNewsletterOptIn}
+                                    newsletterOptIn={newsletterOptIn}
+                                    setNewsletterOptIn={setNewsletterOptIn}
                                 />
                             )}
 
@@ -646,7 +669,10 @@ function LoginForm({
     switchToRegister,
     switchToLogin,
     defaultEmail,
-    defaultPassword
+    defaultPassword,
+    onNewsletterOptIn,
+    newsletterOptIn = false,
+    setNewsletterOptIn
 }: {
     onClose: () => void,
     onForgotPassword?: () => void,
@@ -658,9 +684,13 @@ function LoginForm({
     switchToRegister?: () => void,
     switchToLogin?: () => void,
     defaultEmail?: string,
-    defaultPassword?: string
+    defaultPassword?: string,
+    onNewsletterOptIn?: (email: string) => void,
+    newsletterOptIn?: boolean,
+    setNewsletterOptIn?: (checked: boolean) => void
 }) {
     const passwordRef = useRef<HTMLInputElement | null>(null);
+    const { t } = useTranslation();
 
     const [email, setEmail] = useState<string | undefined>(defaultEmail);
     const [password, setPassword] = useState<string | undefined>(defaultPassword);
@@ -684,15 +714,28 @@ function LoginForm({
     // is not one of those: without a catch here every rejected sign-in becomes an
     // unhandled rejection, reported as a crash by anything listening for one,
     // while the user has already been shown the error.
+    // Fires only on the resolution path, i.e. after the controller accepted
+    // the credentials — a ticked box on a failed attempt must not subscribe
+    // an address its owner never proved they control.
+    function subscribeIfOptedIn(email: string) {
+        if (newsletterOptIn && onNewsletterOptIn) {
+            onNewsletterOptIn(email);
+        }
+    }
+
     function handleEnterPassword() {
         if (email && password && authController.emailPasswordLogin) {
-            void Promise.resolve(authController.emailPasswordLogin(email, password)).catch(() => undefined);
+            void Promise.resolve(authController.emailPasswordLogin(email, password))
+                .then(() => subscribeIfOptedIn(email))
+                .catch(() => undefined);
         }
     }
 
     function handleRegistration() {
         if (email && password && authController.register) {
-            void Promise.resolve(authController.register(email, password, displayName)).catch(() => undefined);
+            void Promise.resolve(authController.register(email, password, displayName))
+                .then(() => subscribeIfOptedIn(email))
+                .catch(() => undefined);
         }
     }
 
@@ -813,6 +856,19 @@ function LoginForm({
                 </div>
             )}
 
+            {onNewsletterOptIn && (
+                <label className="flex items-center gap-2 cursor-pointer mt-1 mb-1">
+                    <Checkbox
+                        checked={newsletterOptIn}
+                        onCheckedChange={(checked) => setNewsletterOptIn?.(checked === true)}
+                        size="small"
+                    />
+                    <Typography variant="caption" color="secondary" className="select-none">
+                        {t("join_newsletter")}
+                    </Typography>
+                </label>
+            )}
+
             <LoadingButton
                 type="submit"
                 variant="filled"

package/src/components/RebaseAuth.tsx

@@ -1,16 +1,16 @@
 import React, { useLayoutEffect, useRef } from "react";
 import { useRebaseRegistryDispatch } from "../hooks";
-import type { RebaseAuthConfig } from "@rebasepro/admin-types";
+import type { RebaseAuthViewConfig } from "@rebasepro/admin-types";
 
 /**
  * Declarative component to configure authentication in Rebase.
  * Renders nothing — purely registers config into the RebaseRegistry.
  *
  * This is a framework-level component that lives in core since
- * authentication is cross-cutting (CMS, Studio, any app area).
+ * authentication is cross-cutting (admin, Studio, any app area).
  * @group Core
  */
-export function RebaseAuth({ loginView }: RebaseAuthConfig) {
+export function RebaseAuth({ loginView }: RebaseAuthViewConfig) {
     const dispatch = useRebaseRegistryDispatch();
     const registeredRef = useRef(false);
 

package/src/components/common/useColumnsIds.tsx

@@ -6,7 +6,7 @@ import type { AdminCollection } from "@rebasepro/admin-types";
 
 /**
  * Get a property in a property tree from a dot-path like `address.street`.
- * Inlined here to avoid importing property-aware utilities from the CMS layer.
+ * Inlined here to avoid importing property-aware utilities from the admin layer.
  */
 function getPropertyInPath(properties: Properties, path: string): Property | undefined {
     if (typeof properties === "object") {

package/src/core/Rebase.tsx

@@ -36,7 +36,7 @@ import { EffectiveRoleControllerContext } from "../contexts/EffectiveRoleControl
 import { useBuildEffectiveRoleController } from "../hooks/useBuildEffectiveRoleController";
 
 /**
- * If you are using independent components of the CMS
+ * If you are using independent components of the admin
  * you need to wrap them with this main component, so the internal hooks work.
  *
  * This is the main component of Rebase. It acts as the provider of all the
@@ -159,7 +159,7 @@ export function Rebase<USER extends User>(props: RebaseProps<USER>) {
     const resolvedData = useMemo(() => {
         const registeredDefault = dataSourcesValue.sources[DEFAULT_DATA_SOURCE_KEY];
         if (registeredDefault) return registeredDefault;
-        // CMS boundary: the SDK client returns flat rows; wrap them into the
+        // admin boundary: the SDK client returns flat rows; wrap them into the
         // Entity view-model the admin (`useData()`) renders.
         if (client?.data) return wrapAsEntityData(client.data, entityDataOptions);
         const built = Object.values(dataSourcesValue.sources);
@@ -204,7 +204,6 @@ export function Rebase<USER extends User>(props: RebaseProps<USER>) {
                 if (!cancelled) console.debug("[Rebase] Could not load storage sources", e);
             });
         return () => { cancelled = true; };
-        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [client, authUser, loginSkipped]);
 
     // Normalize the prop + discovered definitions into a registry + sources map.

package/src/core/RebaseProps.tsx

@@ -47,10 +47,8 @@ type DeepPartial<T> = T extends object
  * Controller to simulate different roles when dev mode is active.
  * @group Models
  */
-export interface EffectiveRoleController {
-    effectiveRole: string | null;
-    setEffectiveRole: (role: string | null) => void;
-}
+export type { EffectiveRoleController } from "@rebasepro/types";
+import type { EffectiveRoleController } from "@rebasepro/types";
 
 
 /**
@@ -122,7 +120,7 @@ export type RebaseProps<USER extends User> = {
     basePath?: string;
 
     /**
-     * Optional base path for the CMS collections.
+     * Optional base path for the admin collections.
      * Defaults to "/c"
      */
     baseCollectionPath?: string;
@@ -136,13 +134,13 @@ export type RebaseProps<USER extends User> = {
 
 
     /**
-     * Format of the dates in the CMS.
+     * Format of the dates in the admin.
      * Defaults to 'MMMM dd, yyyy, HH:mm:ss'
      */
     dateTimeFormat?: string;
 
     /**
-     * Locale of the CMS, currently only affecting dates
+     * Locale of the admin, currently only affecting dates
      */
     locale?: Locale;
 
@@ -246,7 +244,7 @@ export type RebaseProps<USER extends User> = {
     userConfigPersistence?: UserConfigurationPersistence;
 
     /**
-     * Callback used to get analytics events from the CMS
+     * Callback used to get analytics events from the admin
      */
     onAnalyticsEvent?: (event: AnalyticsEvent, data?: object) => void;
 
@@ -258,12 +256,12 @@ export type RebaseProps<USER extends User> = {
 
 
     /**
-     * Plugins loaded in the CMS
+     * Plugins loaded in the admin
      */
     plugins?: RebasePlugin[];
 
     /**
-     * Extra slots for the CMS
+     * Extra slots for the admin
      */
     slots?: SlotContribution[];
 

package/src/hooks/useBuildModeController.tsx

@@ -4,7 +4,7 @@ import type { ModeController } from "./useModeController";
 
 /**
  * Use this hook to build a color mode controller that determines
- * the theme of the CMS
+ * the theme of the admin
  */
 export function useBuildModeController(): ModeController {
 

package/src/hooks/useCustomizationController.tsx

@@ -5,7 +5,7 @@ import { CustomizationControllerContext } from "../contexts/CustomizationControl
 /**
  * Use this hook to retrieve the customization controller.
  * This hook includes all the customization options that can be used
- * to customize the CMS.
+ * to customize the admin.
  *
  * You will likely not need to use this hook directly.
  *

package/src/hooks/useRebaseContext.tsx

@@ -33,7 +33,7 @@ export const useRebaseContext = <USER extends User = User, AuthControllerType ex
     const authController = useAuthController<USER, AuthControllerType>();
     // `context.data` is the flat SDK view — identical in shape to the backend
     // `context.data` and the frontend SDK client, so callbacks behave the same
-    // everywhere. The admin CMS reads Entities via `useData()` directly.
+    // everywhere. The admin reads Entities via `useData()` directly.
     const entityData = useData();
     const data = React.useMemo(() => wrapAsSdkData(entityData), [entityData]);
     const storageSource = useStorageSource();

package/src/hooks/useRebaseRegistry.tsx

@@ -1,5 +1,5 @@
 import React, { createContext, useContext, useState, useCallback, useMemo, useRef } from "react";
-import type { RebaseRegistryController, RebaseAdminConfig, RebaseStudioConfig, RebaseAuthConfig } from "@rebasepro/admin-types";
+import type { RebaseRegistryController, RebaseAdminConfig, RebaseStudioConfig, RebaseAuthViewConfig } from "@rebasepro/admin-types";
 
 /**
  * Split into two contexts to prevent infinite re-render loops:
@@ -12,18 +12,18 @@ import type { RebaseRegistryController, RebaseAdminConfig, RebaseStudioConfig, R
  */
 
 interface RegistryDispatch {
-    registerCMS: (config: RebaseAdminConfig) => void;
-    unregisterCMS: () => void;
+    registerAdmin: (config: RebaseAdminConfig) => void;
+    unregisterAdmin: () => void;
     registerStudio: (config: RebaseStudioConfig) => void;
     unregisterStudio: () => void;
-    registerAuth: (config: RebaseAuthConfig) => void;
+    registerAuth: (config: RebaseAuthViewConfig) => void;
     unregisterAuth: () => void;
 }
 
 interface RegistryState {
     cmsConfig: RebaseAdminConfig | null;
     studioConfig: RebaseStudioConfig | null;
-    authConfig: RebaseAuthConfig | null;
+    authConfig: RebaseAuthViewConfig | null;
 }
 
 const RegistryDispatchContext = createContext<RegistryDispatch | undefined>(undefined);
@@ -36,15 +36,15 @@ const RegistryStateContext = createContext<RegistryState>({
 export function RebaseRegistryProvider({ children }: { children: React.ReactNode }) {
     const [cmsConfig, setCmsConfig] = useState<RebaseAdminConfig | null>(null);
     const [studioConfig, setStudioConfig] = useState<RebaseStudioConfig | null>(null);
-    const [authConfig, setAuthConfig] = useState<RebaseAuthConfig | null>(null);
+    const [authConfig, setAuthConfig] = useState<RebaseAuthViewConfig | null>(null);
 
     // Dispatch functions are stable — never change identity
     const dispatch = useMemo<RegistryDispatch>(() => ({
-        registerCMS: (config: RebaseAdminConfig) => setCmsConfig(config),
-        unregisterCMS: () => setCmsConfig(null),
+        registerAdmin: (config: RebaseAdminConfig) => setCmsConfig(config),
+        unregisterAdmin: () => setCmsConfig(null),
         registerStudio: (config: RebaseStudioConfig) => setStudioConfig(config),
         unregisterStudio: () => setStudioConfig(null),
-        registerAuth: (config: RebaseAuthConfig) => setAuthConfig(config),
+        registerAuth: (config: RebaseAuthViewConfig) => setAuthConfig(config),
         unregisterAuth: () => setAuthConfig(null)
     }), []);
 

package/src/hooks/useStudioBridge.tsx

@@ -18,9 +18,9 @@ export type { BreadcrumbEntry, BreadcrumbsController };
 // ─── Bridge interface ───────────────────────────────────────────────
 
 /**
- * StudioBridge provides optional CMS capabilities to Studio components.
- * When CMS is present, a bridge provider injects real implementations.
- * When CMS is absent, noop defaults ensure Studio works standalone.
+ * StudioBridge provides optional admin capabilities to Studio components.
+ * When the admin is present, a bridge provider injects real implementations.
+ * When the admin is absent, noop defaults ensure Studio works standalone.
  */
 export interface StudioBridge {
     collectionRegistry: CollectionRegistryController;
@@ -84,10 +84,10 @@ const NOOP_BRIDGE: StudioBridge = {
 export const StudioBridgeContext = createContext<StudioBridge>(NOOP_BRIDGE);
 
 /**
- * Provider that injects CMS capabilities into Studio.
+ * Provider that injects admin capabilities into Studio.
  * Accepts partial overrides — any field not provided falls back to noop.
  *
- * Usage (in app wiring, when CMS is present):
+ * Usage (in app wiring, when the admin is present):
  * ```tsx
  * <StudioBridgeProvider value={{
  *     collectionRegistry: useCollectionRegistryController(),
@@ -121,27 +121,27 @@ export function StudioBridgeProvider({
 
 // ─── Convenience hooks ──────────────────────────────────────────────
 
-/** Collection registry — returns noop if CMS is not present. */
+/** Collection registry — returns noop if the admin is not present. */
 export function useStudioCollectionRegistry(): CollectionRegistryController {
     return useContext(StudioBridgeContext).collectionRegistry;
 }
 
-/** Side panel controller — returns noop if CMS is not present. */
+/** Side panel controller — returns noop if the admin is not present. */
 export function useStudioSidePanelController(): SidePanelController {
     return useContext(StudioBridgeContext).sidePanelController;
 }
 
-/** URL controller — returns noop if CMS is not present. */
+/** URL controller — returns noop if the admin is not present. */
 export function useStudioUrlController(): UrlController {
     return useContext(StudioBridgeContext).urlController;
 }
 
-/** Navigation state — returns noop if CMS is not present. */
+/** Navigation state — returns noop if the admin is not present. */
 export function useStudioNavigationState(): NavigationStateController {
     return useContext(StudioBridgeContext).navigationState;
 }
 
-/** Breadcrumbs controller — returns noop if CMS is not present. */
+/** Breadcrumbs controller — returns noop if the admin is not present. */
 export function useStudioBreadcrumbs(): BreadcrumbsController {
     return useContext(StudioBridgeContext).breadcrumbs;
 }

package/src/index.ts

@@ -24,7 +24,7 @@ export * from "./i18n/RebaseI18nProvider";
 export * from "./locales/en";
 export * from "./locales/es";
 
-// Studio Bridge — shared context for optional CMS↔Studio integration
+// Studio Bridge — shared context for optional admin↔Studio integration
 export * from "./hooks/useStudioBridge";
 
 // Self-assembling bridge registration hook

package/src/locales/de.ts

@@ -58,6 +58,7 @@ export const de: RebaseTranslations = {
     dark_mode: "Dunkel",
     light_mode: "Hell",
     system_mode: "System",
+    join_newsletter: "Newsletter abonnieren, kein Spam",
     ok: "Ok",
     save_collection_config: "Sammlungsstruktur speichern",
     search_for_more_icons: "Nach weiteren Symbolen suchen…",
@@ -277,7 +278,7 @@ export const de: RebaseTranslations = {
     action_defined_in_code: "Diese Aktion ist im Code definiert mit dem Schlüssel",
     add_custom_entity_action: "Benutzerdefinierte Entitätsaktion hinzufügen",
     remove_this_action: "Diese Aktion entfernen?",
-    remove_action_warning: "Dadurch werden keine Daten gelöscht, sondern nur die Aktion im CMS",
+    remove_action_warning: "Dadurch werden keine Daten gelöscht, sondern nur die Aktion im Admin-Panel",
 
     subcollections_of: "Untersammlungen von",
     add_subcollection: "Untersammlung hinzufügen",
@@ -286,14 +287,14 @@ export const de: RebaseTranslations = {
     view_defined_in_code: "Diese Ansicht ist im Code definiert mit dem Schlüssel",
     add_custom_entity_view: "Benutzerdefinierte Entitätsansicht hinzufügen",
     delete_this_subcollection: "Diese Untersammlung löschen?",
-    remove_collection_warning: "Dadurch werden keine Daten gelöscht, sondern nur die Sammlung im CMS",
+    remove_collection_warning: "Dadurch werden keine Daten gelöscht, sondern nur die Sammlung im Admin-Panel",
     remove_this_view: "Diese Ansicht entfernen?",
-    remove_view_warning: "Dadurch werden keine Daten gelöscht, sondern nur die Ansicht im CMS",
+    remove_view_warning: "Dadurch werden keine Daten gelöscht, sondern nur die Ansicht im Admin-Panel",
 
     no_collection_selected: "Keine Sammlung ausgewählt",
     code_for_collection: "Code für",
     use_config_define_json: "Verwenden Sie diese Konfiguration, um die Sammlung im JSON-Format zu definieren.",
-    customise_collection_code: "Wenn Sie die Sammlung im Code anpassen möchten, können Sie diesen Sammlungscode zu Ihrer CMS-App-Konfiguration hinzufügen.",
+    customise_collection_code: "Wenn Sie die Sammlung im Code anpassen möchten, können Sie diesen Sammlungscode zu Ihrer Admin-App-Konfiguration hinzufügen.",
     copied: "Kopiert",
 
     property_cant_be_edited: "Diese Eigenschaft kann nicht bearbeitet werden",
@@ -464,7 +465,7 @@ export const de: RebaseTranslations = {
     continue_from_scratch: "Von vorne beginnen",
 
     /** Admin views config */
-    cms_users: "CMS-Benutzer",
+    admin_users: "Admin-Benutzer",
     roles_menu: "Rollen",
     project_settings: "Projekteinstellungen",
 
@@ -726,8 +727,8 @@ no_filter: "No filter",
     studio_sql_error_executing: "An error occurred while executing the query.",
     studio_sql_error_explaining: "An error occurred while explaining the query.",
     studio_sql_save_first_to_favorite: "Please save the snippet first before favoriting.",
-    studio_sql_cms: "Collections:",
-    studio_sql_cms_collections_tooltip: "Tables in this query that are mapped as CMS collections",
+    studio_sql_collections_label: "Collections:",
+    studio_sql_admin_collections_tooltip: "Tables in this query that are mapped as admin collections",
     studio_sql_edit_entity: "Edit {{name}} #{{id}}",
     studio_sql_sql_not_supported: "SQL execution not supported by this data source",
     studio_sql_fetch_error: "Failed to fetch connection options: {{message}}",
@@ -832,7 +833,7 @@ no_filter: "No filter",
     studio_add_kanban_column_add: "Add",
     studio_add_kanban_column_cancel: "Cancel",
     studio_collection_view_sql: "SQL Editor",
-    studio_collection_view_cms: "CMS View",
+    studio_collection_view_admin: "Admin View",
     studio_editor_collection_tooltip: "Edit collection schema",
     studio_editor_collection_no_permission: "You don't have permission to edit this collection",
     studio_editor_collection_start_tooltip: "Copy path or edit schema",
@@ -865,7 +866,7 @@ no_filter: "No filter",
     studio_editor_collection_start_saved: "Default config saved",
     studio_home_duplicate_collection: "Duplicate",
     studio_home_delete: "Delete",
-    studio_home_confirm_delete_no_data: "This will not delete any data, only the collection in the CMS",
+    studio_home_confirm_delete_no_data: "This will not delete any data, only the collection in the admin panel",
     studio_home_collection_deleted: "Collection deleted",
     studio_kanban_configure: "Configure Kanban",
     studio_missing_reference_error: "No collection for path: {{path}}",