@rebasepro/admin 0.11.1-canary.gfd39654 → 0.12.0

package/src/components/HomePage/ContentHomePage.tsx

@@ -24,7 +24,7 @@ import { useRestoreScroll } from "@rebasepro/app";
 
 import { SchemaDriftBanner } from "@rebasepro/app";
 import { useBreadcrumbsController } from "../../hooks/useBreadcrumbsController";
-import { useCMSContext } from "../../hooks/useCMSContext";
+import { useAdminContext } from "../../hooks/useAdminContext";
 
 export const DEFAULT_GROUP_NAME = "Views";
 export const ADMIN_GROUP_NAME = "Admin";
@@ -43,7 +43,7 @@ export function ContentHomePage({
     hiddenGroups?: string[];
 }) {
 
-    const context = useCMSContext();
+    const context = useAdminContext();
     const { navigationStateController } = context;
     const customizationController = useCustomizationController();
     const adminModeController = useAdminModeController();
@@ -65,7 +65,7 @@ export function ContentHomePage({
     } = navigationStateController.topLevelNavigation || {};
 
     // Build a set of Studio-only dev view slugs so we can distinguish them from
-    // CMS custom views added via <RebaseAdmin views={...}> or plugins.
+    // admin custom views added via <RebaseAdmin views={...}> or plugins.
     const studioViewSlugs = useMemo(() => {
         const slugs = new Set<string>();
         (registry.studioConfig?.devViews ?? []).forEach(v => slugs.add(v.slug));
@@ -74,7 +74,7 @@ export function ContentHomePage({
     }, [registry.studioConfig, registry.cmsConfig?.collectionEditor]);
 
     // Studio mode shows Studio dev views + admin entries (Users/Roles).
-    // Content mode shows collections, CMS custom views, and admin entries — but not Studio dev views.
+    // Content mode shows collections, admin custom views, and admin entries — but not Studio dev views.
     const rawNavigationEntries = useMemo(() => {
         if (adminModeController.mode === "studio") {
             return unFilteredNavigationEntries.filter(e => (e.type === "view" && studioViewSlugs.has(e.slug)) || e.type === "admin");

package/src/components/RebaseAdmin.tsx

@@ -3,7 +3,7 @@ import { useRebaseRegistryDispatch } from "@rebasepro/app";
 import type { RebaseAdminConfig } from "@rebasepro/admin-types";
 
 /**
- * Declarative component to configure the CMS in Rebase.
+ * Declarative component to configure the admin in Rebase.
  * Renders nothing — purely registers config into the RebaseRegistry.
  *
  * When `collectionEditor` is provided, the built-in visual schema editor
@@ -14,7 +14,7 @@ export function RebaseAdmin({ collections, views, homePage, entityViews, entityA
     const dispatch = useRebaseRegistryDispatch();
 
     useLayoutEffect(() => {
-        dispatch.registerCMS({ collections,
+        dispatch.registerAdmin({ collections,
 views,
 homePage,
 entityViews,
@@ -22,7 +22,7 @@ entityActions,
 collectionEditor,
 navigationGroupMappings,
 basePath });
-        return () => dispatch.unregisterCMS();
+        return () => dispatch.unregisterAdmin();
     }, [dispatch, collections, views, homePage, entityViews, entityActions, collectionEditor, navigationGroupMappings, basePath]);
 
     return null;

package/src/components/RebaseAuthGate.tsx

@@ -15,7 +15,7 @@ import type { AuthControllerExtended } from "@rebasepro/admin-types";
  * - Renders `children` when a user is authenticated.
  *
  * **Independently usable**: Use this alone when you want auth gating
- * without the full CMS layout or navigation.
+ * without the full admin layout or navigation.
  *
  * @example
  * ```tsx

package/src/components/RebaseLayout.tsx

@@ -19,8 +19,12 @@ export interface RebaseLayoutProps {
     appBar?: React.ReactNode;
     /** Custom Drawer to override the default. */
     drawer?: React.ReactNode;
-    /** Whether to auto-open the drawer on load. */
+    /** Expand the drawer while the pointer is over it. Not a load-time default — that is `defaultDrawerOpen`. */
     autoOpenDrawer?: boolean;
+    /** Start with the drawer expanded instead of collapsed to icons. Ignored on small layouts. */
+    defaultDrawerOpen?: boolean;
+    /** Path to the logo shown in the drawer and top bar. Falls back to the Rebase mark. */
+    logo?: string;
     /** Dev views passed to AdminModeSyncer (resolved from RebaseNavigation). */
     devViews?: AppView[];
 }
@@ -49,6 +53,8 @@ export function RebaseLayout(props: RebaseLayoutProps) {
         appBar,
         drawer,
         autoOpenDrawer = false,
+        defaultDrawerOpen = false,
+        logo,
         devViews = []
     } = props;
 
@@ -63,7 +69,7 @@ export function RebaseLayout(props: RebaseLayoutProps) {
     );
 
     return (
-        <Scaffold autoOpenDrawer={autoOpenDrawer}>
+        <Scaffold autoOpenDrawer={autoOpenDrawer} defaultDrawerOpen={defaultDrawerOpen} logo={logo}>
             <AdminModeSyncer devViews={devViews}/>
             {appBar}
             {ActiveDrawer}

package/src/components/RebaseNavigation.tsx

@@ -50,13 +50,13 @@ export interface RebaseNavigationProps {
 }
 
 /**
- * Navigation layer — builds and provides all CMS navigation controllers:
+ * Navigation layer — builds and provides all admin navigation controllers:
  * collection registry, URL controller, navigation state, side entity,
  * and the self-assembling Studio bridge.
  *
  * Also handles the collection editor config controller when enabled.
  *
- * **Independently usable**: Use this when you need CMS navigation
+ * **Independently usable**: Use this when you need admin navigation
  * (entity tables, side panels) in a custom layout.
  *
  * @example
@@ -76,7 +76,7 @@ export function RebaseNavigation({ children }: RebaseNavigationProps) {
 
     // ── Collection Editor resolution ──────────────────────────────────
     // The collection editor is ALWAYS enabled when Studio is registered.
-    // The `collectionEditor` CMS config is for fine-tuning (readOnly, auth, etc.),
+    // The `collectionEditor` admin config is for fine-tuning (readOnly, auth, etc.),
     // not for opting-in. When omitted, the editor defaults to enabled
     // (read-only in production).
     const collectionEditorConfig = registry.cmsConfig?.collectionEditor;
@@ -86,7 +86,7 @@ export function RebaseNavigation({ children }: RebaseNavigationProps) {
         return collectionEditorConfig;
     }, [collectionEditorConfig]);
 
-    // ── Combine CMS and Studio Configs ────────────────────────────────
+    // ── Combine admin and Studio Configs ────────────────────────────────
     const cmsCollections = registry.cmsConfig?.collections ?? EMPTY_COLLECTIONS;
 
     // ── Build the navigation controllers ──────────────────────────────
@@ -203,8 +203,8 @@ export function RebaseNavigation({ children }: RebaseNavigationProps) {
         return base;
     }, [registry.studioConfig?.devViews, schemaView]);
 
-    // Merge CMS-registered views with Studio dev views.
-    // Order: CMS views (developer's primary content) → Studio dev views (tooling).
+    // Merge admin-registered views with Studio dev views.
+    // Order: admin views (developer's primary content) → Studio dev views (tooling).
     // Plugin views are merged later inside resolveAppViews.
     const cmsViews = registry.cmsConfig?.views;
     const mergedViews = useMemo(() => {
@@ -234,7 +234,7 @@ export function RebaseNavigation({ children }: RebaseNavigationProps) {
         adminMode: adminModeController?.mode
     });
 
-    // ── Merge CMS-registered entityViews/entityActions into the customization controller ──
+    // ── Merge admin-registered entityViews/entityActions into the customization controller ──
     // The <Rebase> component builds the customizationController from its own props,
     // but entity views passed to <RebaseAdmin> are stored in the registry and not
     // automatically merged. We re-provide an enriched controller here so that
@@ -260,7 +260,7 @@ export function RebaseNavigation({ children }: RebaseNavigationProps) {
     }, [parentCustomizationController, registry.cmsConfig?.entityViews, registry.cmsConfig?.entityActions]);
 
     // ── Inner content with all context providers ──────────────────────
-    // Re-provide RebaseDataContext with the routed data so that every CMS
+    // Re-provide RebaseDataContext with the routed data so that every admin
     // consumer (list/entity views, references, board, import/export, and
     // `context.data`) is routed to the correct driver by collection path.
     const navigationContent = (
@@ -302,7 +302,7 @@ export function RebaseNavigation({ children }: RebaseNavigationProps) {
 }
 
 /**
- * Internal component that auto-registers CMS controllers into the
+ * Internal component that auto-registers admin controllers into the
  * self-assembling Studio bridge. Must be rendered inside both the
  * navigation contexts and the StudioBridgeRegistryProvider.
  */

package/src/components/RebaseRouteDefs.tsx

@@ -45,7 +45,7 @@ export interface RebaseRouteDefsProps {
 }
 
 /**
- * Route definitions for the CMS.
+ * Route definitions for the admin.
  *
  * Defines all standard routes: home, studio home, collection view,
  * settings, debug, custom views, and a catch-all 404.
@@ -77,7 +77,7 @@ export function RebaseRouteDefs({ children, layout }: RebaseRouteDefsProps) {
 
     const routeContents = (
         <>
-            {/* Core CMS Routes */}
+            {/* Core admin Routes */}
             <Route path={"/"} element={cmsHomePage}/>
             {registry.studioConfig && (
                 <Route path={"/s"} element={studioHomePage}/>

package/src/components/RebaseShell.tsx

@@ -14,12 +14,17 @@ export interface RebaseShellProps {
     /** Top bar. Only rendered if provided — pass `<AppBar/>` for the default one. */
     appBar?: React.ReactNode;
     drawer?: React.ReactNode;
+    /** Expand the drawer while the pointer is over it. Not a load-time default — that is `defaultDrawerOpen`. */
     autoOpenDrawer?: boolean;
+    /** Start with the drawer expanded instead of collapsed to icons. Ignored on small layouts. */
+    defaultDrawerOpen?: boolean;
+    /** Path to the logo shown in the drawer and top bar. Falls back to the Rebase mark. */
+    logo?: string;
     children?: React.ReactNode;
 }
 
 /**
- * Convenience component that composes all four CMS layers:
+ * Convenience component that composes all four admin layers:
  *
  * ```
  * <RebaseAuthGate>
@@ -40,6 +45,8 @@ export function RebaseShell(props: RebaseShellProps) {
         appBar,
         drawer,
         autoOpenDrawer = false,
+        defaultDrawerOpen = false,
+        logo,
         children
     } = props;
 
@@ -61,6 +68,8 @@ export function RebaseShell(props: RebaseShellProps) {
                                 appBar={appBar}
                                 drawer={drawer}
                                 autoOpenDrawer={autoOpenDrawer}
+                                defaultDrawerOpen={defaultDrawerOpen}
+                                logo={logo}
                                 devViews={devViews}
                             />
                         }

package/src/components/RelationSelector.tsx

@@ -66,6 +66,20 @@ export interface RelationSelectorProps {
     invisible?: boolean;
 
     relation: Relation;
+    /**
+     * Whether the selector picks many rows or one.
+     *
+     * Defaults to what the relation implies — a `hasMany` or `manyToMany`
+     * picks many — which is right wherever the selector *edits* the relation,
+     * because there the cardinality is the shape of the stored value.
+     *
+     * A filter is the case where it is not. `tags == <one tag>` asks a single
+     * question about a to-many link, and the operator is what decides how many
+     * values it takes. Deriving multiplicity from the relation there meant a
+     * to-many relation could only ever emit a list, so the filter field had to
+     * hide every single-value operator to avoid handing `==` an array.
+     */
+    multiple?: boolean;
     fixedFilter?: FilterValues<string>;
     pageSize?: number;
     emptyPlaceholder?: string;
@@ -89,6 +103,7 @@ export const RelationSelector = React.forwardRef<
             useChips = true,
             className,
             relation,
+            multiple: multipleOverride,
             fixedFilter,
             pageSize,
             emptyPlaceholder,
@@ -102,7 +117,7 @@ export const RelationSelector = React.forwardRef<
         const collection = relation.target();
         const dataClient = useData();
         const sidePanelController = useSidePanel();
-        const multiple = relationCardinality(relation) === "many";
+        const multiple = multipleOverride ?? relationCardinality(relation) === "many";
 
         const [isPopoverOpen, setIsPopoverOpen] = useState(false);
         const isPopoverOpenRef = useRef(false);
@@ -223,7 +238,7 @@ export const RelationSelector = React.forwardRef<
 
                 if (hasEmbeddedData) {
                     const r = rel as EntityRelation;
-                    // CMS wire format embeds relation data as { id, path, values }
+                    // admin wire format embeds relation data as { id, path, values }
                     newResolvedItems.push(toRelationItem(r.data as unknown as Entity, r));
                 } else if (currentSelectedMap.has(relId)) {
                     // We already have it in currentSelected
@@ -259,7 +274,7 @@ export const RelationSelector = React.forwardRef<
                     const relation = isPrimitive ? new EntityRelation(relId, path) : rel as EntityRelation;
 
                     if (!isPrimitive && (rel as EntityRelation).data) {
-                        // CMS wire format embeds relation data as { id, path, values }
+                        // admin wire format embeds relation data as { id, path, values }
                         return toRelationItem((rel as EntityRelation).data as unknown as Entity, relation);
                     }
                     if (currentSelectedMap.has(String(relId))) {

package/src/components/SelectableTable/filters/FilterFieldBinding.tsx

@@ -138,7 +138,7 @@ function DefaultFilterField({
             operators={operators}
             path={referenceProperty.path}
             title={title}
-            includeId={referenceProperty.includeId}
+            includeId={referenceProperty.admin?.includeId}
             previewProperties={referenceProperty.admin?.previewProperties}
             hidden={hidden ?? false}
             setHidden={setHidden ?? (() => undefined)}/>;

package/src/components/SelectableTable/filters/ReferenceFilterField.tsx

@@ -1,6 +1,6 @@
 import { useSelectionDialog } from "../../../hooks/useSelectionDialog";
 
-import React, { useMemo, useState } from "react";
+import React, { useId, useMemo, useState } from "react";
 import { VirtualTableWhereFilterOp } from "@rebasepro/ui";
 import { Entity, EntityReference } from "@rebasepro/types";
 import { ReferencePreview } from "../../../preview";
@@ -9,6 +9,7 @@ import { getReferenceFrom } from "@rebasepro/common";
 import { useTranslation } from "@rebasepro/app";
 import { useCollectionRegistryController } from "../../../hooks/navigation/contexts/CollectionRegistryContext";
 import type { AdminCollection } from "@rebasepro/admin-types";
+import { isNullFilterOperator, nullFilterOperatorFor, valueOperatorFor } from "./null_filter";
 
 interface ReferenceFilterFieldProps {
     name: string,
@@ -39,7 +40,9 @@ const operationLabels = {
     in: "In",
     "not-in": "Not in",
     "array-contains": "Contains",
-    "array-contains-any": "Contains Any"
+    "array-contains-any": "Contains Any",
+    "is-null": "Is null",
+    "is-not-null": "Is not null"
 };
 
 const multipleSelectOperations = ["array-contains-any", "in", "not-in"];
@@ -66,6 +69,9 @@ export function ReferenceFilterField({
         possibleOperations.push("in", "not-in");
     }
 
+    // The null checks take no operand, so they apply either way.
+    possibleOperations.push("is-null", "is-not-null");
+
     if (operators) {
         possibleOperations = possibleOperations.filter(op => (operators as readonly string[]).includes(op));
     }
@@ -97,6 +103,14 @@ export function ReferenceFilterField({
         setOperation(op);
         setInternalValue(newValue);
 
+        // A null check takes no operand, so it is complete on its own — the
+        // value gate below would otherwise clear the filter the moment one is
+        // chosen from the dropdown, where there is no value to accompany it.
+        if (isNullFilterOperator(op)) {
+            setValue([op, null]);
+            return;
+        }
+
         const hasNewValue = newValue !== null && Array.isArray(newValue)
             ? newValue.length > 0
             : newValue !== undefined;
@@ -125,6 +139,12 @@ export function ReferenceFilterField({
     };
 
     const multiple = multipleSelectOperations.includes(operation);
+    const nullFiltered = isNullFilterOperator(operation);
+
+    // The filters dialog renders every filterable property at once, and this
+    // id was the literal string "null-filter" — so clicking any label toggled
+    // whichever checkbox the document matched first, never the one clicked.
+    const nullFilterId = useId();
 
     const referenceDialogController = useSelectionDialog({
         multiselect: multiple,
@@ -200,17 +220,24 @@ export function ReferenceFilterField({
                     </Button>
                 }
 
+                {/*
+                  * Switches the operator to the matching null check rather
+                  * than pairing a null value with whatever operator is
+                  * selected. Only the operator travels to the driver, and a
+                  * null *operand* means different things to different ones —
+                  * Mongo rejects `$in: null` outright. See
+                  * `nullFilterOperatorFor`.
+                  */}
                 {!isArray && <Label
                     className="border cursor-pointer rounded-md p-2 flex items-center gap-2 bg-surface-50 dark:bg-surface-900 hover:bg-surface-100 dark:hover:bg-surface-800"
-                    htmlFor="null-filter"
+                    htmlFor={nullFilterId}
                 >
-                    <Checkbox id="null-filter"
-                        checked={internalValue === null}
+                    <Checkbox id={nullFilterId}
+                        checked={nullFiltered}
                         size={"small"}
-                        onCheckedChange={(checked) => {
-                            if (internalValue !== null)
-                                updateFilter(operation, null);
-                            else updateFilter(operation, undefined);
+                        onCheckedChange={() => {
+                            if (!nullFiltered) updateFilter(nullFilterOperatorFor(operation), null);
+                            else updateFilter(valueOperatorFor(operation, possibleOperations) ?? operation, undefined);
                         }}/>
                     {t("filter_for_null_values")}
                 </Label>}

package/src/components/SelectableTable/filters/RelationFilterField.tsx

@@ -1,8 +1,9 @@
-import React, { useMemo, useState } from "react";
+import React, { useId, useMemo, useState } from "react";
 import { VirtualTableWhereFilterOp } from "@rebasepro/ui";
 import { EntityRelation, Relation } from "@rebasepro/types";
 import { Checkbox, Label, Select, SelectItem } from "@rebasepro/ui";
 import { RelationSelector } from "../../RelationSelector";
+import { isNullFilterOperator, nullFilterOperatorFor, valueOperatorFor } from "./null_filter";
 
 /** Whether an authored relation yields many rows. Derived from its kind. */
 function relationCardinality(relation: { kind?: string; cardinality?: string } | undefined): "one" | "many" | undefined {
@@ -39,11 +40,60 @@ const operationLabels = {
     in: "In",
     "not-in": "Not in",
     "array-contains": "Contains",
-    "array-contains-any": "Contains Any"
+    "array-contains-any": "Contains Any",
+    "is-null": "Is empty",
+    "is-not-null": "Is not empty"
 };
 
 const multipleSelectOperations = ["array-contains-any", "in", "not-in"];
 
+/**
+ * What this field can render, before `operators` narrows it.
+ *
+ * Every relation gets the whole set. The value selector is told how many
+ * values to take by the *operator* — see the `multiple` prop passed below —
+ * so a to-many relation can be asked `== <one tag>` as readily as
+ * `in <several>`, and the question of what shape the relation stores never
+ * enters into it.
+ *
+ * That is a change: this list used to be split by the value the selector
+ * produced, because the selector took its multiplicity from the relation's
+ * cardinality and so a to-many one could only ever emit a list. Every
+ * single-value operator had to be withheld to keep an array from reaching
+ * `==`. `ReferenceFilterField` never had the problem — it has always sized its
+ * dialog from the operator — which is what made the split look like a
+ * property of relations rather than a limitation of one component.
+ *
+ * The array operators are the exception, and belong only to a to-many link,
+ * which is the only one that *is* a list. On a to-one relation the filter
+ * compiles to a comparison on a scalar foreign key, and `@>` against one is a
+ * type error rather than an empty result.
+ */
+const RELATION_OPERATIONS: (keyof typeof operationLabels)[] =
+    ["==", "!=", ">", "<", ">=", "<=", "in", "not-in", "is-null", "is-not-null"];
+const LIST_ONLY_OPERATIONS: (keyof typeof operationLabels)[] =
+    ["array-contains", "array-contains-any"];
+
+/**
+ * The operators this field will actually put on screen.
+ *
+ * Exported because the failure mode is silence: when the intersection of what
+ * the field can render and what the engine can run comes out empty, the field
+ * returns null and the filter control the table header offered opens onto
+ * nothing. That is a rendering outcome no unit test of either side alone
+ * catches, so the intersection itself is the thing worth pinning.
+ */
+export function renderableRelationOperators(
+    relation: { kind?: string; cardinality?: string } | undefined,
+    operators?: readonly VirtualTableWhereFilterOp[]
+): (keyof typeof operationLabels)[] {
+    const possible = relationCardinality(relation) === "many"
+        ? [...RELATION_OPERATIONS, ...LIST_ONLY_OPERATIONS]
+        : RELATION_OPERATIONS;
+    if (!operators) return possible;
+    return possible.filter(op => (operators as readonly string[]).includes(op));
+}
+
 export function RelationFilterField({
     value,
     setValue,
@@ -56,13 +106,13 @@ export function RelationFilterField({
 
     const manyRelation = relationCardinality(relation) === "many";
 
-    let possibleOperations: (keyof typeof operationLabels)[] = manyRelation
-        ? ["array-contains", "array-contains-any"]
-        : ["==", "!=", ">", "<", ">=", "<=", "in", "not-in"];
+    // The filters dialog renders every filterable property at once, and the
+    // checkbox's id was the literal string "null-filter" — so clicking any
+    // label toggled whichever checkbox the document matched first. Harmless
+    // while one relation per table could show it; not once every relation can.
+    const nullFilterId = useId();
 
-    if (operators) {
-        possibleOperations = possibleOperations.filter(op => (operators as readonly string[]).includes(op));
-    }
+    const possibleOperations = renderableRelationOperators(relation, operators);
 
     const [fieldOperation, fieldValue] = value || [possibleOperations[0], undefined];
     const [operation, setOperation] = useState<VirtualTableWhereFilterOp>(fieldOperation);
@@ -80,6 +130,14 @@ export function RelationFilterField({
         setOperation(op);
         setInternalValue(newValue);
 
+        // A null check takes no operand, so it is complete on its own — the
+        // value gate below would otherwise clear the filter the moment one is
+        // chosen from the dropdown, where there is no value to accompany it.
+        if (isNullFilterOperator(op)) {
+            setValue([op, null]);
+            return;
+        }
+
         const hasNewValue = newValue !== null && Array.isArray(newValue)
             ? newValue.length > 0
             : newValue !== undefined;
@@ -91,6 +149,7 @@ export function RelationFilterField({
     }
 
     const multiple = multipleSelectOperations.includes(operation);
+    const nullFiltered = isNullFilterOperator(operation);
 
     const relationSelectorValue = useMemo(() => {
         if (internalValue === null || internalValue === undefined) return undefined;
@@ -135,27 +194,44 @@ export function RelationFilterField({
             <div className="grow ml-2 h-full gap-2 flex flex-col w-[340px]">
                 <RelationSelector
                     relation={relation}
+                    // The operator, not the relation, decides how many values
+                    // are being asked for — `updateFilter` already coerces the
+                    // held value on the same test, so the two cannot disagree.
+                    multiple={multiple}
                     value={relationSelectorValue}
                     onValueChange={handleRelationSelectorChange}
-                    disabled={internalValue === null}
+                    disabled={nullFiltered}
                     size={"medium"}
                 />
 
-                {!manyRelation && <Label
+                {/*
+                  * Shown for a to-many relation too. It used to be hidden
+                  * there because the only operators offered were the array
+                  * ones, which have no null to ask about — but "posts with no
+                  * tags" is the question a filter on a link is most often
+                  * for, and the driver answers it with `NOT EXISTS`.
+                  *
+                  * It switches the operator to the matching null check rather
+                  * than pairing a null value with whatever operator is
+                  * selected. Only the operator travels to the driver, and
+                  * `is-null` is a thing every engine implements; a null
+                  * *operand* is not — see `nullFilterOperatorFor`.
+                  */}
+                <Label
                     className="border cursor-pointer rounded-md p-2 flex items-center gap-2 bg-surface-50 dark:bg-surface-900 hover:bg-surface-100 dark:hover:bg-surface-800"
-                    htmlFor="null-filter"
+                    htmlFor={nullFilterId}
                 >
                     <Checkbox
-                        id="null-filter"
-                        checked={internalValue === null}
+                        id={nullFilterId}
+                        checked={nullFiltered}
                         size={"small"}
                         onCheckedChange={() => {
-                            if (internalValue !== null) updateFilter(operation, null);
-                            else updateFilter(operation, undefined);
+                            if (!nullFiltered) updateFilter(nullFilterOperatorFor(operation), null);
+                            else updateFilter(valueOperatorFor(operation, possibleOperations) ?? operation, undefined);
                         }}
                     />
-                    Filter for null values
-                </Label>}
+                    {manyRelation ? "Filter for empty relations" : "Filter for null values"}
+                </Label>
             </div>
         </div>
     );

package/src/components/SelectableTable/filters/null_filter.ts

@@ -0,0 +1,63 @@
+import { WhereFilterOp } from "@rebasepro/types";
+
+/**
+ * The "filter for null values" checkbox, expressed portably.
+ *
+ * The checkbox used to emit `[whichever operator is selected, null]` and leave
+ * the driver to work out that a null value means a null check. That reads as
+ * an engine-neutral convention and is not one:
+ *
+ *  - Postgres took `["==", null]` as `IS NULL`, but dropped `["in", null]`
+ *    entirely — a dropped condition widens, so ticking the box returned every
+ *    row instead of the ones with no value.
+ *  - MongoDB maps `in`/`not-in` straight onto `$in`/`$nin`, and Mongo rejects
+ *    those with a non-array: `$in needs an array`. The read fails outright.
+ *  - A Firestore driver is supplied by the developer, and the Firestore SDK
+ *    likewise refuses `in` without a non-empty array.
+ *
+ * Only `==`/`!=` ever worked, and only because two engines independently chose
+ * to special-case a null operand. Nothing in the filter contract promises that,
+ * and a filter field is shared by every engine the admin can talk to.
+ *
+ * `is-null`/`is-not-null` are the operators that mean this, they are in
+ * {@link ALL_WHERE_FILTER_OPS}, and every driver already handles them
+ * explicitly rather than by inference. So the checkbox emits those, and the
+ * question of what a null operand means to a given engine stops being asked.
+ */
+export const NULL_FILTER_OPERATORS: readonly WhereFilterOp[] = ["is-null", "is-not-null"];
+
+/** Whether `op` asks about absence rather than about a value. */
+export function isNullFilterOperator(op: WhereFilterOp | undefined): boolean {
+    return op === "is-null" || op === "is-not-null";
+}
+
+/**
+ * The null check carrying the same sense as `op`.
+ *
+ * The checkbox is a toggle, not an operator, so the operator it is ticked
+ * alongside is what says which way round it means: `==`/`in` are asking for
+ * a match, so their null form is "has nothing"; `!=`/`not-in` are asking for
+ * the absence of one, so theirs is "has something".
+ */
+export function nullFilterOperatorFor(op: WhereFilterOp | undefined): WhereFilterOp {
+    if (op === "!=" || op === "not-in" || op === "is-not-null") return "is-not-null";
+    return "is-null";
+}
+
+/**
+ * The value operator to return to when the checkbox is unticked.
+ *
+ * `is-null` could have been reached from `==` or from `in` — the field cannot
+ * know which, and it does not matter. What matters is landing on an operator
+ * the dropdown actually offers, in the same sense, so the control does not
+ * come back showing something it cannot render.
+ */
+export function valueOperatorFor(
+    op: WhereFilterOp | undefined,
+    offered: readonly WhereFilterOp[]
+): WhereFilterOp | undefined {
+    const negative = op === "is-not-null";
+    const wanted: WhereFilterOp[] = negative ? ["!=", "not-in"] : ["==", "in", "array-contains"];
+    return wanted.find(candidate => offered.includes(candidate))
+        ?? offered.find(candidate => !isNullFilterOperator(candidate));
+}

package/src/components/SidePanelProvider.tsx

@@ -15,8 +15,8 @@ import { useAuthController, useBridgeRegistration, NavigationBlockerProvider } f
  * Provider that builds the SidePanelController and makes it available
  * via the SidePanelControllerContext from @rebasepro/app.
  *
- * After the CMS extraction refactor, `useBuildSidePanel` lives
- * in the CMS package while the context it feeds into lives in core.
+ * After the admin extraction refactor, `useBuildSidePanel` lives
+ * in the admin package while the context it feeds into lives in core.
  * This provider bridges the two: place it inside the `<Rebase>` tree and
  * above any component that calls `useSidePanel()`.
  *