diff --git a/.eslintrc.json b/.eslintrc.json
index 28469069c..3969b69e4 100644
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -65,6 +65,13 @@
     ],
     "no-unused-expressions": "warn",
     "no-unused-vars": "off",
+    "no-warning-comments": [
+      "warn",
+      {
+        "terms": ["DO NOT SUBMIT"],
+        "location": "anywhere"
+      }
+    ],
     "sort-imports": "off",
     "sort-keys": "off"
   },
diff --git a/resources/js/App.tsx b/resources/js/App.tsx
index ee4dc691b..c9c9576d0 100644
--- a/resources/js/App.tsx
+++ b/resources/js/App.tsx
@@ -13,6 +13,7 @@ import {MemoTitle} from "./features/root/MemoTitle";
 const AdminFacilitiesListPage = lazy(() => import("features/root/pages/AdminFacilitiesList.page"));
 const AdminUsersListPage = lazy(() => import("features/root/pages/AdminUsersList.page"));
 const CalendarPage = lazy(() => import("features/root/pages/Calendar.page"));
+const CalendarTablePage = lazy(() => import("features/root/pages/CalendarTable.page"));
 const LoginPage = lazy(() => import("features/authentication/pages/Login.page"));
 const RootPage = lazy(() => import("features/root/pages/Root.page"));
 
@@ -51,6 +52,7 @@ const App: VoidComponent = () => {
         <Route path="/admin" component={FacilityAdminPages}>
           <UnknownNotFound />
           <LeafRoute routeKey="facility.admin.calendar" path="/calendar" component={CalendarPage} />
+          <LeafRoute routeKey="facility.admin.calendar_table" path="/calendar-table" component={CalendarTablePage} />
           <LeafRoute routeKey="facility.admin.clients" path="/clients" component={NotYetImplemented} />
           <LeafRoute routeKey="facility.admin.staff" path="/staff" component={NotYetImplemented} />
           <LeafRoute routeKey="facility.admin.reports" path="/reports" component={NotYetImplemented} />
diff --git a/resources/js/components/ui/Table/TQueryTable.tsx b/resources/js/components/ui/Table/TQueryTable.tsx
index 02f0233cb..95311e841 100644
--- a/resources/js/components/ui/Table/TQueryTable.tsx
+++ b/resources/js/components/ui/Table/TQueryTable.tsx
@@ -8,7 +8,6 @@ import {
 } from "@tanstack/solid-table";
 import {createLocalStoragePersistence} from "components/persistence/persistence";
 import {richJSONSerialiser} from "components/persistence/serialiser";
-import {NON_NULLABLE} from "components/utils";
 import {toastMessages} from "components/utils/toast";
 import {FilterH} from "data-access/memo-api/tquery/filter_utils";
 import {
@@ -18,7 +17,14 @@ import {
   tableHelper,
 } from "data-access/memo-api/tquery/table";
 import {createTQuery} from "data-access/memo-api/tquery/tquery";
-import {ColumnName, ColumnType, DataColumnSchema, DataItem, isDataColumn} from "data-access/memo-api/tquery/types";
+import {
+  ColumnName,
+  ColumnType,
+  DataColumnSchema,
+  DataItem,
+  Sort,
+  isDataColumn,
+} from "data-access/memo-api/tquery/types";
 import {DEV, JSX, VoidComponent, createComputed, createEffect, createMemo, createSignal} from "solid-js";
 import toast from "solid-toast";
 import {
@@ -70,11 +76,7 @@ export interface TQueryTableProps {
   /** The entity URL, must not change. */
   readonly staticEntityURL: string;
   readonly staticTranslations?: TableTranslations;
-  /**
-   * The key part used to persist the table settings.
-   * If not provided, the settings are persisted with the entity URL as the key. Specifying this
-   * key allows persisting the settings separately for different tables showing the same entity.
-   */
+  /** The key to use for persisting the parameters of the displayed page. If not present, nothing is persisted. */
   readonly staticPersistenceKey?: string;
   /**
    * The filter that is always applied to the data, regardless of other filtering.
@@ -82,6 +84,8 @@ export interface TQueryTableProps {
    * entity B, so only entities A related direclty to that particular entity B should be shown.
    */
   readonly intrinsicFilter?: FilterH;
+  /** The sort that is always applied to the data at the end of the filter specified by the user. */
+  readonly intrinsicSort?: Sort;
   /** The definition of the columns in the table, in their correct order. */
   readonly columns: readonly PartialColumnConfig[];
   readonly initialSort?: SortingState;
@@ -173,16 +177,22 @@ export const TQueryTable: VoidComponent<TQueryTableProps> = (props) => {
     ["bool", {cell: tableCells.bool, size: 100}],
     ["date", {cell: tableCells.date}],
     ["datetime", {cell: tableCells.datetime}],
-    ["int", {cell: tableCells.int}],
+    ["int", {cell: tableCells.int, size: 150}],
+    ["list", {enableSorting: false}],
+    ["object", {enableSorting: false}],
     ["string", {}],
     ["text", {enableSorting: false}],
     ["uuid", {cell: tableCells.uuid, enableSorting: false, size: 80}],
+    ["uuid_list", {cell: tableCells.uuidList, enableSorting: false, size: 80}],
+    ["dict", {cell: tableCells.dict}],
+    ["dict_list", {cell: tableCells.dictList, enableSorting: false}],
   ]);
 
   const [allInitialised, setAllInitialised] = createSignal(false);
   const requestCreator = createTableRequestCreator({
     columnsConfig,
     intrinsicFilter: () => props.intrinsicFilter,
+    intrinsicSort: () => props.intrinsicSort,
     initialSort: props.initialSort,
     initialPageSize:
       props.initialPageSize ||
@@ -213,25 +223,27 @@ export const TQueryTable: VoidComponent<TQueryTableProps> = (props) => {
     sorting,
     pagination,
   } = requestController;
-  createLocalStoragePersistence<PersistentState>({
-    key: ["TQueryTable", entityURL, props.staticPersistenceKey].filter(NON_NULLABLE).join(":"),
-    value: () => ({
-      colVis: columnVisibility[0](),
-    }),
-    onLoad: (value) => {
-      // Ensure a bad (e.g. outdated) entry won't affect visibility of a columnn that cannot have
-      // the visibility controlled by the user.
-      const colVis = {...value.colVis};
-      for (const col of columnsConfig()) {
-        if (col.columnDef.enableHiding === false) {
-          delete colVis[col.name];
+  if (props.staticPersistenceKey) {
+    createLocalStoragePersistence<PersistentState>({
+      key: `TQueryTable:${props.staticPersistenceKey}`,
+      value: () => ({
+        colVis: columnVisibility[0](),
+      }),
+      onLoad: (value) => {
+        // Ensure a bad (e.g. outdated) entry won't affect visibility of a columnn that cannot have
+        // the visibility controlled by the user.
+        const colVis = {...value.colVis};
+        for (const col of columnsConfig()) {
+          if (col.columnDef.enableHiding === false) {
+            delete colVis[col.name];
+          }
         }
-      }
-      columnVisibility[1](colVis);
-    },
-    serialiser: richJSONSerialiser<PersistentState>(),
-    version: [PERSISTENCE_VERSION],
-  });
+        columnVisibility[1](colVis);
+      },
+      serialiser: richJSONSerialiser<PersistentState>(),
+      version: [PERSISTENCE_VERSION],
+    });
+  }
   // Allow querying data now that the DEV columns are added and columns visibility is loaded.
   setAllInitialised(true);
   const {rowsCount, pageCount, scrollToTopSignal, filterErrors} = tableHelper({
diff --git a/resources/js/components/ui/Table/Table.module.scss b/resources/js/components/ui/Table/Table.module.scss
index bcbbc66d5..f0d478891 100644
--- a/resources/js/components/ui/Table/Table.module.scss
+++ b/resources/js/components/ui/Table/Table.module.scss
@@ -9,48 +9,52 @@
   > .scrollingWrapper {
     @apply overflow-x-auto;
 
-    > .tableBg {
-      @apply w-max bg-gray-300 mr-16;
+    > .scrollToTopElement {
+      @apply w-max;
 
-      > .table {
-        @apply grid p-px gap-px;
+      > .tableBg {
+        @apply w-max bg-gray-300 mr-16;
 
-        > .headerRow {
-          @apply contents;
+        > .table {
+          @apply grid p-px gap-px;
 
-          > .cell {
-            @apply outline outline-1 outline-gray-400 bg-gray-100;
-            min-height: 30px;
+          > .headerRow {
+            @apply contents;
+
+            > .cell {
+              @apply outline outline-1 outline-gray-400 bg-gray-100;
+              min-height: 30px;
+            }
           }
-        }
 
-        > .dataRow {
-          @apply contents;
+          > .dataRow {
+            @apply contents;
 
-          > .cell {
-            @apply bg-white text-black rounded-sm px-1.5 py-1 flex items-center overflow-hidden;
-            min-height: 30px;
-          }
+            > .cell {
+              @apply bg-white text-black rounded-sm px-1.5 py-1 flex items-center overflow-hidden;
+              min-height: 30px;
+            }
 
-          &:hover > .cell {
-            @apply bg-hover;
+            &:hover > .cell {
+              @apply bg-hover;
+            }
           }
-        }
 
-        > .wideRow {
-          grid-column: 1 / -1;
-          @apply bg-white p-2 text-gray-500 text-center;
-        }
+          > .wideRow {
+            grid-column: 1 / -1;
+            @apply bg-white p-2 text-gray-500 text-center;
+          }
 
-        > .bottomBorder {
-          grid-column: 1 / -1;
-          @apply border-b border-b-gray-300;
-          margin-top: -5px;
-        }
+          > .bottomBorder {
+            grid-column: 1 / -1;
+            @apply border-b border-b-gray-300;
+            margin-top: -5px;
+          }
 
-        &.dimmed {
-          > .dataRow > .cell {
-            @apply bg-opacity-70 text-opacity-30;
+          &.dimmed {
+            > .dataRow > .cell {
+              @apply bg-opacity-70 text-opacity-30;
+            }
           }
         }
       }
@@ -65,7 +69,7 @@
       @apply pr-2;
     }
 
-    > .scrollingWrapper > .tableBg > .table {
+    > .scrollingWrapper > .scrollToTopElement > .tableBg > .table {
       > .headerRow > .cell {
         @apply sticky top-px;
       }
diff --git a/resources/js/components/ui/Table/Table.tsx b/resources/js/components/ui/Table/Table.tsx
index f29c10aa5..e8ac4dd7e 100644
--- a/resources/js/components/ui/Table/Table.tsx
+++ b/resources/js/components/ui/Table/Table.tsx
@@ -132,13 +132,13 @@ const DEFAULT_PROPS = {
  */
 export const Table = <T,>(allProps: VoidProps<Props<T>>): JSX.Element => {
   const props = mergeProps(DEFAULT_PROPS, allProps);
-  let scrollToTopPoint: HTMLDivElement | undefined;
+  let scrollToTopElement: HTMLDivElement | undefined;
   createEffect(
     on(
       () => props.scrollToTopSignal?.(),
       (_input, prevInput) => {
         if (prevInput !== undefined) {
-          scrollToTopPoint?.scrollIntoView({behavior: "smooth"});
+          scrollToTopElement?.scrollIntoView({behavior: "smooth"});
         }
       },
     ),
@@ -196,64 +196,69 @@ export const Table = <T,>(allProps: VoidProps<Props<T>>): JSX.Element => {
             onScroll={[setLastScrollTimestamp, Date.now()]}
             onScrollEnd={[setLastScrollTimestamp, 0]}
           >
-            <div ref={scrollToTopPoint} class={s.tableBg}>
-              <div
-                class={cx(s.table, {[s.dimmed!]: props.isDimmed})}
-                style={{"grid-template-columns": gridTemplateColumns()}}
-              >
-                <div class={s.headerRow}>
-                  <For each={getHeaders(props.table)}>
-                    {({header, column}) => (
-                      <Show when={header()}>
-                        {(header) => (
-                          <div
-                            class={s.cell}
-                            onWheel={(e) => {
-                              const scrWrapper = scrollingWrapper();
-                              if (scrWrapper && e.deltaY) {
-                                setDesiredScrollX((l = scrWrapper.scrollLeft) =>
-                                  Math.min(Math.max(l + e.deltaY, 0), scrWrapper.scrollWidth - scrWrapper.clientWidth),
-                                );
-                                e.preventDefault();
-                              }
-                            }}
-                          >
-                            <Show when={!header().isPlaceholder}>
-                              <CellRenderer component={column.columnDef.header} props={header().getContext()} />
-                            </Show>
-                          </div>
-                        )}
-                      </Show>
-                    )}
-                  </For>
-                </div>
-                <Dynamic
-                  component={{For, Index}[props.rowsIteration]}
-                  each={props.table.getRowModel().rows}
-                  fallback={
-                    <div class={s.wideRow}>
-                      <Show when={props.isDimmed} fallback={EMPTY_VALUE_SYMBOL}>
-                        <BigSpinner />
-                      </Show>
-                    </div>
-                  }
+            <div ref={scrollToTopElement} class={s.scrollToTopElement}>
+              <div class={s.tableBg}>
+                <div
+                  class={cx(s.table, {[s.dimmed!]: props.isDimmed})}
+                  style={{"grid-template-columns": gridTemplateColumns()}}
                 >
-                  {(rowMaybeAccessor: Row<T> | Accessor<Row<T>>) => {
-                    const row = typeof rowMaybeAccessor === "function" ? rowMaybeAccessor : () => rowMaybeAccessor;
-                    return (
-                      <div class={s.dataRow} inert={props.isDimmed || undefined}>
-                        <Index each={row().getVisibleCells()}>
-                          {(cell) => (
-                            <span class={s.cell}>
-                              <CellRenderer component={cell().column.columnDef.cell} props={cell().getContext()} />
-                            </span>
+                  <div class={s.headerRow}>
+                    <For each={getHeaders(props.table)}>
+                      {({header, column}) => (
+                        <Show when={header()}>
+                          {(header) => (
+                            <div
+                              class={s.cell}
+                              onWheel={(e) => {
+                                const scrWrapper = scrollingWrapper();
+                                if (scrWrapper && e.deltaY) {
+                                  setDesiredScrollX((l = scrWrapper.scrollLeft) =>
+                                    Math.min(
+                                      Math.max(l + e.deltaY, 0),
+                                      scrWrapper.scrollWidth - scrWrapper.clientWidth,
+                                    ),
+                                  );
+                                  e.preventDefault();
+                                }
+                              }}
+                            >
+                              <Show when={!header().isPlaceholder}>
+                                <CellRenderer component={column.columnDef.header} props={header().getContext()} />
+                              </Show>
+                            </div>
                           )}
-                        </Index>
+                        </Show>
+                      )}
+                    </For>
+                  </div>
+                  <Dynamic
+                    component={{For, Index}[props.rowsIteration]}
+                    each={props.table.getRowModel().rows}
+                    fallback={
+                      <div class={s.wideRow}>
+                        <Show when={props.isDimmed} fallback={EMPTY_VALUE_SYMBOL}>
+                          <BigSpinner />
+                        </Show>
                       </div>
-                    );
-                  }}
-                </Dynamic>
-                <div class={s.bottomBorder} />
+                    }
+                  >
+                    {(rowMaybeAccessor: Row<T> | Accessor<Row<T>>) => {
+                      const row = typeof rowMaybeAccessor === "function" ? rowMaybeAccessor : () => rowMaybeAccessor;
+                      return (
+                        <div class={s.dataRow} inert={props.isDimmed || undefined}>
+                          <Index each={row().getVisibleCells()}>
+                            {(cell) => (
+                              <span class={s.cell}>
+                                <CellRenderer component={cell().column.columnDef.cell} props={cell().getContext()} />
+                              </span>
+                            )}
+                          </Index>
+                        </div>
+                      );
+                    }}
+                  </Dynamic>
+                  <div class={s.bottomBorder} />
+                </div>
               </div>
             </div>
           </div>
diff --git a/resources/js/components/ui/Table/table_cells.tsx b/resources/js/components/ui/Table/table_cells.tsx
index 69c1abefe..8d7e72c9b 100644
--- a/resources/js/components/ui/Table/table_cells.tsx
+++ b/resources/js/components/ui/Table/table_cells.tsx
@@ -1,9 +1,10 @@
 import {CellContext, HeaderContext} from "@tanstack/solid-table";
 import {DATE_FORMAT, DATE_TIME_FORMAT, NUMBER_FORMAT, useLangFunc} from "components/utils";
 import {DateTime} from "luxon";
-import {JSX, Show} from "solid-js";
+import {Index, JSX, Show} from "solid-js";
 import {Header} from "./Header";
 import {IdColumn} from "./IdColumn";
+import {useDictionaries} from "data-access/memo-api/dictionaries";
 
 /** The component used as header in column definition. */
 export type HeaderComponent = <T>(ctx: HeaderContext<T, unknown>) => JSX.Element;
@@ -20,17 +21,45 @@ export type CellComponent = <T>(ctx: CellContext<T, unknown>) => JSX.Element;
 /** Returns a collection of cell functions for various data types. */
 export function useTableCells() {
   const t = useLangFunc();
+  const dictionaries = useDictionaries();
   return {
     defaultHeader: ((ctx) => <Header ctx={ctx} />) satisfies HeaderComponent,
-    default: cellFunc((v) => <div class="wrapText">{String(v)}</div>),
+    default: cellFunc((v) => <div class="wrapText">{defaultFormatValue(v)}</div>),
     bool: cellFunc<boolean>((v) => (v ? t("bool_values.yes") : t("bool_values.no"))),
     date: cellFunc<string>((v) => DateTime.fromISO(v).toLocaleString(DATE_FORMAT)),
     datetime: cellFunc<string>((v) => DateTime.fromISO(v).toLocaleString(DATE_TIME_FORMAT)),
     int: cellFunc<number>((v) => <span class="w-full text-right">{NUMBER_FORMAT.format(v)}</span>),
     uuid: cellFunc<string>((v) => <IdColumn id={v} />),
+    uuidList: cellFunc<readonly string[]>((v) => (
+      <div class="w-full flex flex-col">
+        <Index each={v}>{(id) => <IdColumn id={id()} />}</Index>
+      </div>
+    )),
+    dict: cellFunc<string>((v) => dictionaries()?.positionsById.get(v)?.label || "??"),
+    dictList: cellFunc<readonly string[]>((v) => (
+      <ul>
+        <Index each={v}>{(id) => <li>{dictionaries()?.positionsById.get(id())?.label || "??"}</li>}</Index>
+      </ul>
+    )),
   };
 }
 
+function defaultFormatValue(value: unknown) {
+  if (value == undefined) {
+    return "";
+  } else if (Array.isArray(value)) {
+    return (
+      <ul>
+        <Index each={value}>{(item) => <li>{defaultFormatValue(item())}</li>}</Index>
+      </ul>
+    );
+  } else if (typeof value === "object") {
+    return JSON.stringify(value);
+  } else {
+    return String(value);
+  }
+}
+
 export function cellFunc<V>(
   func: <T>(v: V, ctx: CellContext<T, unknown>) => JSX.Element | undefined,
   fallback?: () => JSX.Element,
diff --git a/resources/js/components/ui/Table/tquery_filters/BoolFilterControl.tsx b/resources/js/components/ui/Table/tquery_filters/BoolFilterControl.tsx
index ad30477ea..e8d39135b 100644
--- a/resources/js/components/ui/Table/tquery_filters/BoolFilterControl.tsx
+++ b/resources/js/components/ui/Table/tquery_filters/BoolFilterControl.tsx
@@ -15,19 +15,19 @@ export const BoolFilterControl: FilterControl<NullColumnFilter | BoolColumnFilte
     }
     // Ignore other external filter changes.
   });
-  function buildFilter(value: string): NullColumnFilter | BoolColumnFilter | undefined {
-    switch (value) {
+  function buildFilter(): NullColumnFilter | BoolColumnFilter | undefined {
+    switch (value()) {
       case "-":
         return undefined;
       case "t":
       case "f":
-        return {type: "column", column: props.name, op: "=", val: value === "t"};
+        return {type: "column", column: props.name, op: "=", val: value() === "t"};
       case "*":
         return {type: "column", column: props.name, op: "null", inv: true};
       case "null":
         return {type: "column", column: props.name, op: "null"};
       default:
-        throw new Error(`Invalid value: ${value}`);
+        throw new Error(`Invalid value: ${value()}`);
     }
   }
   const items = createMemo(() => {
@@ -60,7 +60,7 @@ export const BoolFilterControl: FilterControl<NullColumnFilter | BoolColumnFilte
           value={value()}
           onValueChange={(value) => {
             setValue(value!);
-            props.setFilter(buildFilter(value!));
+            props.setFilter(buildFilter());
           }}
           nullable={false}
           small
diff --git a/resources/js/components/ui/Table/tquery_filters/ColumnFilterController.module.scss b/resources/js/components/ui/Table/tquery_filters/ColumnFilterController.module.scss
index bfb15174b..cb3abbad0 100644
--- a/resources/js/components/ui/Table/tquery_filters/ColumnFilterController.module.scss
+++ b/resources/js/components/ui/Table/tquery_filters/ColumnFilterController.module.scss
@@ -29,9 +29,9 @@
     }
 
     .valuesSyncer {
-      width: 6px;
+      width: 5px;
       height: 55%;
-      @apply row-span-2 self-center -mr-0.5;
+      @apply row-span-2 self-center;
       @apply border-2 border-r-0 border-current text-black text-opacity-30 cursor-pointer;
       border-start-start-radius: 3px;
       border-end-start-radius: 3px;
diff --git a/resources/js/components/ui/Table/tquery_filters/ColumnFilterController.tsx b/resources/js/components/ui/Table/tquery_filters/ColumnFilterController.tsx
index 795c0ad4c..18bdfa28c 100644
--- a/resources/js/components/ui/Table/tquery_filters/ColumnFilterController.tsx
+++ b/resources/js/components/ui/Table/tquery_filters/ColumnFilterController.tsx
@@ -3,6 +3,8 @@ import {FilterIconButton, useTable} from "..";
 import {BoolFilterControl} from "./BoolFilterControl";
 import s from "./ColumnFilterController.module.scss";
 import {DateTimeFilterControl} from "./DateTimeFilterControl";
+import {DictFilterControl} from "./DictFilterControl";
+import {DictListFilterControl} from "./DictListFilterControl";
 import {IntFilterControl} from "./IntFilterControl";
 import {TextualFilterControl} from "./TextualFilterControl";
 import {UuidFilterControl} from "./UuidFilterControl";
@@ -53,10 +55,12 @@ export const ColumnFilterController: VoidComponent<FilterControlProps> = (props)
         return () => <TextualFilterControl {...anyFilterProps} columnType={meta.type} />;
       case "uuid":
         return () => <UuidFilterControl {...anyFilterProps} />;
-      case "dict":
+      case "uuid_list":
         return undefined; // TODO: Implement.
+      case "dict":
+        return () => <DictFilterControl {...anyFilterProps} dictionaryId={meta.dictionaryId} />;
       case "dict_list":
-        return undefined; // TODO: Implement.
+        return () => <DictListFilterControl {...anyFilterProps} dictionaryId={meta.dictionaryId} />;
       default:
         return meta satisfies never;
     }
diff --git a/resources/js/components/ui/Table/tquery_filters/DateTimeFilterControl.tsx b/resources/js/components/ui/Table/tquery_filters/DateTimeFilterControl.tsx
index 6a7d1b036..d2213ece1 100644
--- a/resources/js/components/ui/Table/tquery_filters/DateTimeFilterControl.tsx
+++ b/resources/js/components/ui/Table/tquery_filters/DateTimeFilterControl.tsx
@@ -101,7 +101,7 @@ export const DateTimeFilterControl: VoidComponent<Props> = (props) => {
   const syncActive = () => !!lower() || !!upper();
   return (
     <div
-      class="grid gap-0.5 gap-x-1 items-baseline"
+      class="grid gap-0.5 items-baseline"
       style={{"grid-template-columns": `auto ${canSyncRange() ? "auto" : ""} 1fr`}}
     >
       <div>{t("range.from")}</div>
diff --git a/resources/js/components/ui/Table/tquery_filters/DictFilterControl.tsx b/resources/js/components/ui/Table/tquery_filters/DictFilterControl.tsx
new file mode 100644
index 000000000..efd0929de
--- /dev/null
+++ b/resources/js/components/ui/Table/tquery_filters/DictFilterControl.tsx
@@ -0,0 +1,97 @@
+import {Select, SelectItem} from "components/ui/form/Select";
+import {useLangFunc} from "components/utils";
+import {useDictionaries} from "data-access/memo-api/dictionaries";
+import {FilterH} from "data-access/memo-api/tquery/filter_utils";
+import {VoidComponent, createComputed, createMemo, createSignal} from "solid-js";
+import {SelectItemLabelOnList, makeSelectItem} from "./select_items";
+import {FilterControlProps} from "./types";
+
+interface Props extends FilterControlProps {
+  readonly dictionaryId: string;
+}
+
+export const DictFilterControl: VoidComponent<Props> = (props) => {
+  const t = useLangFunc();
+  const dictionaries = useDictionaries();
+
+  const [value, setValue] = createSignal<readonly string[]>([]);
+  createComputed(() => {
+    if (!props.filter) {
+      setValue([]);
+    }
+    // Ignore other external filter changes.
+  });
+  function buildFilter(): FilterH | undefined {
+    if (!value().length) {
+      return undefined;
+    } else if (value().includes("*")) {
+      return {type: "column", column: props.name, op: "null", inv: true};
+    } else {
+      const hasNull = value().includes("null");
+      return {
+        type: "op",
+        op: "|",
+        val: [
+          hasNull ? {type: "column", column: props.name, op: "null"} : "never",
+          {type: "column", column: props.name, op: "in", val: value().filter((v) => v !== "null")},
+        ],
+      };
+    }
+  }
+  const items = createMemo(() => {
+    const items: SelectItem[] = [];
+    if (props.nullable) {
+      items.push(
+        makeSelectItem({
+          symbol: "*",
+          description: t("tables.filter.non_null_value"),
+          label: () => <SelectItemLabelOnList symbol="*" description={t("tables.filter.non_null_value")} />,
+        }),
+        {
+          value: "__separator__",
+          label: () => <hr />,
+          disabled: true,
+        },
+        makeSelectItem({
+          value: "null",
+          symbol: "‘’",
+          text: `'' ${t("tables.filter.null_value")}`,
+          description: t("tables.filter.null_value"),
+          label: () => <SelectItemLabelOnList symbol="‘’" description={t("tables.filter.null_value")} />,
+        }),
+      );
+    }
+    for (const position of dictionaries()?.get(props.dictionaryId)?.activePositions || []) {
+      items.push({
+        value: position.id,
+        text: position.label,
+      });
+    }
+    return items;
+  });
+  return (
+    <div style={{"min-width": "160px"}}>
+      <Select
+        name={`table_filter_val_${props.name}`}
+        items={items()}
+        value={value()}
+        onValueChange={(newValue) => {
+          if (newValue.includes("*") && newValue.length > 1) {
+            // The * (non-null) is exclusive with all the other options.
+            if (value().includes("*")) {
+              setValue(newValue.filter((v) => v !== "*"));
+            } else {
+              setValue(["*"]);
+            }
+          } else {
+            setValue(newValue);
+          }
+          props.setFilter(buildFilter());
+        }}
+        onFilterChange="internal"
+        multiple
+        small
+      />
+    </div>
+  );
+};
diff --git a/resources/js/components/ui/Table/tquery_filters/DictListFilterControl.tsx b/resources/js/components/ui/Table/tquery_filters/DictListFilterControl.tsx
new file mode 100644
index 000000000..8b60d51b6
--- /dev/null
+++ b/resources/js/components/ui/Table/tquery_filters/DictListFilterControl.tsx
@@ -0,0 +1,64 @@
+import {DictionarySelect} from "components/ui/form/DictionarySelect";
+import {SegmentedControl} from "components/ui/form/SegmentedControl";
+import {useLangFunc} from "components/utils";
+import {FilterH} from "data-access/memo-api/tquery/filter_utils";
+import {VoidComponent, createComputed, createSignal} from "solid-js";
+import {FilterControlProps} from "./types";
+
+interface Props extends FilterControlProps {
+  readonly dictionaryId: string;
+}
+
+const MODES = ["has_all", "has_any", "has_only"] as const;
+type Mode = (typeof MODES)[number];
+
+export const DictListFilterControl: VoidComponent<Props> = (props) => {
+  const t = useLangFunc();
+  const [mode, setMode] = createSignal<Mode>("has_all");
+  const [value, setValue] = createSignal<readonly string[]>([]);
+  createComputed(() => {
+    if (!props.filter) {
+      setMode("has_all");
+      setValue([]);
+    }
+    // Ignore other external filter changes.
+  });
+  function buildFilter(): FilterH | undefined {
+    if (mode() === "has_all" && !value().length) {
+      return undefined;
+    }
+    return {
+      type: "column",
+      column: props.name,
+      op: mode(),
+      val: value(),
+    };
+  }
+  createComputed(() => props.setFilter(buildFilter()));
+  return (
+    <div class="flex flex-col items-stretch gap-0.5" style={{"min-width": "160px"}}>
+      <SegmentedControl
+        name={`table_filter_mode_${props.name}`}
+        items={MODES.map((m) => ({
+          value: m,
+          label: () => (
+            <span title={t(`tables.filter.set_operation.${m}.explanation`)}>
+              {t(`tables.filter.set_operation.${m}.short`)}
+            </span>
+          ),
+        }))}
+        value={mode()}
+        setValue={setMode}
+        small
+      />
+      <DictionarySelect
+        name={`table_filter_val_${props.name}`}
+        dictionary={props.dictionaryId}
+        value={value()}
+        onValueChange={setValue}
+        multiple
+        small
+      />
+    </div>
+  );
+};
diff --git a/resources/js/components/ui/Table/tquery_filters/IntFilterControl.tsx b/resources/js/components/ui/Table/tquery_filters/IntFilterControl.tsx
index c651b6461..0d36d31f7 100644
--- a/resources/js/components/ui/Table/tquery_filters/IntFilterControl.tsx
+++ b/resources/js/components/ui/Table/tquery_filters/IntFilterControl.tsx
@@ -70,7 +70,7 @@ export const IntFilterControl: VoidComponent<Props> = (props) => {
   const syncActive = () => lower() || upper();
   return (
     <div
-      class="grid gap-0.5 gap-x-1 items-baseline"
+      class="grid gap-0.5 items-baseline"
       style={{"grid-template-columns": `auto ${canSyncRange() ? "auto" : ""} 1fr`}}
     >
       <div>{t("range.min")}</div>
diff --git a/resources/js/components/ui/Table/tquery_filters/select_items.tsx b/resources/js/components/ui/Table/tquery_filters/select_items.tsx
index f93d1f98c..0b2dfd6c5 100644
--- a/resources/js/components/ui/Table/tquery_filters/select_items.tsx
+++ b/resources/js/components/ui/Table/tquery_filters/select_items.tsx
@@ -6,10 +6,13 @@ import {Match, Show, Switch, VoidComponent} from "solid-js";
 interface SelectItemSymbolProps {
   readonly symbol: string;
   readonly class?: string;
+  readonly title?: string;
 }
 
 export const SelectItemSymbol: VoidComponent<SelectItemSymbolProps> = (props) => (
-  <span class={cx("font-semibold", props.class)}>{props.symbol}</span>
+  <span class={cx("font-semibold", props.class)} title={props.title}>
+    {props.symbol}
+  </span>
 );
 
 interface SelectItemDescriptionProps {
@@ -40,7 +43,9 @@ export const SelectItemLabelOnList: VoidComponent<SelectItemLabelProps> = (props
 
 export const SelectItemLabel: VoidComponent<SelectItemLabelProps> = (props) => (
   <Switch>
-    <Match when={props.symbol}>{(symbol) => <SelectItemSymbol symbol={symbol()} class={props.symbolClass} />}</Match>
+    <Match when={props.symbol}>
+      {(symbol) => <SelectItemSymbol symbol={symbol()} class={props.symbolClass} title={props.description} />}
+    </Match>
     <Match when={props.description}>{(desc) => <SelectItemDescription description={desc()} />}</Match>
   </Switch>
 );
@@ -48,7 +53,7 @@ export const SelectItemLabel: VoidComponent<SelectItemLabelProps> = (props) => (
 export function makeSelectItem(opts: Partial<SelectItem> & SelectItemLabelProps = {}) {
   return {
     value: opts.symbol || "",
-    text: `${opts.symbol};${opts.description}`,
+    text: `${opts.symbol} ${opts.description}`,
     label: () => <SelectItemLabel {...opts} />,
     labelOnList: () => <SelectItemLabelOnList {...opts} />,
     ...opts,
diff --git a/resources/js/components/ui/form/Select.module.scss b/resources/js/components/ui/form/Select.module.scss
index 731881e8d..cf3b04064 100644
--- a/resources/js/components/ui/form/Select.module.scss
+++ b/resources/js/components/ui/form/Select.module.scss
@@ -80,6 +80,8 @@
       @apply grow shrink basis-0;
       @apply rounded px-1;
       min-width: 2rem;
+      // This entry is needed, otherwise the input grows too much, despite min-width and flex-basis.
+      width: 2rem;
       @apply outline-none;
     }
   }
diff --git a/resources/js/components/utils/day_minute_util.ts b/resources/js/components/utils/day_minute_util.ts
index c831129ac..75763c1c9 100644
--- a/resources/js/components/utils/day_minute_util.ts
+++ b/resources/js/components/utils/day_minute_util.ts
@@ -19,13 +19,13 @@ export function dayMinuteToHM(dayMinute: number) {
   };
 }
 
-export function formatDayMinuteHM(dayMinute: number) {
+export function formatDayMinuteHM(dayMinute: number, formatOpts?: Intl.DateTimeFormatOptions) {
   return DateTime.fromObject({
     year: 2000,
     month: 1,
     day: 1,
     ...dayMinuteToHM(dayMinute),
-  }).toLocaleString({hour: "numeric", minute: "2-digit"});
+  }).toLocaleString({hour: "numeric", minute: "2-digit", ...formatOpts});
 }
 
 /** Checks whether the time span is at least partially on the given day. */
diff --git a/resources/js/data-access/memo-api/dictionaries.ts b/resources/js/data-access/memo-api/dictionaries.ts
index 0755d7c96..2d513ff84 100644
--- a/resources/js/data-access/memo-api/dictionaries.ts
+++ b/resources/js/data-access/memo-api/dictionaries.ts
@@ -18,6 +18,8 @@ export class Dictionaries {
      * Contains only the dictionaries with a translatable name (not starting with `+`).
      */
     readonly byName: ReadonlyMap<string, Dictionary>,
+    /** A map of all the positions from all the dictionaries, by id. */
+    readonly positionsById: ReadonlyMap<string, Position>,
   ) {}
 
   static fromResources(t: LangFunc, resources: DictionaryResource[]) {
@@ -27,13 +29,17 @@ export class Dictionaries {
   private static fromDictionaries(dictinoaries: Dictionary[]) {
     const byId = new Map<string, Dictionary>();
     const byName = new Map<string, Dictionary>();
+    const positionsById = new Map<string, Position>();
     for (const dictionary of dictinoaries) {
       byId.set(dictionary.id, dictionary);
       if (dictionary.resource.isFixed && dictionary.isTranslatable) {
         byName.set(dictionary.resource.name, dictionary);
       }
+      for (const position of dictionary.allPositions) {
+        positionsById.set(position.id, position);
+      }
     }
-    return new Dictionaries(byId, byName);
+    return new Dictionaries(byId, byName, positionsById);
   }
 
   [Symbol.iterator]() {
diff --git a/resources/js/data-access/memo-api/tquery/filter_utils.test.ts b/resources/js/data-access/memo-api/tquery/filter_utils.test.ts
new file mode 100644
index 000000000..289663c23
--- /dev/null
+++ b/resources/js/data-access/memo-api/tquery/filter_utils.test.ts
@@ -0,0 +1,242 @@
+import {describe, expect, test} from "vitest";
+import {FilterH, FilterReductor, invert} from "./filter_utils";
+
+describe("filter_utils", () => {
+  const reductor = new FilterReductor({
+    columns: [
+      {name: "c-str", type: "string"},
+      {name: "c-nullable-str", type: "string", nullable: true},
+      {name: "c-uuid-list", type: "uuid_list", nullable: true},
+    ],
+  });
+
+  test("invert", () => {
+    expect(invert({type: "column", column: "foo", op: "=", val: "bar"})).toEqual({
+      type: "column",
+      column: "foo",
+      op: "=",
+      val: "bar",
+      inv: true,
+    });
+    expect(invert({type: "column", column: "foo", op: "=", val: "bar", inv: true})).toEqual({
+      type: "column",
+      column: "foo",
+      op: "=",
+      val: "bar",
+      inv: false,
+    });
+    expect(invert("always")).toEqual("never");
+    expect(invert("never")).toEqual("always");
+  });
+
+  test("op null", () => {
+    expect(reductor.reduce({type: "column", column: "c-str", op: "null"})).toEqual("never");
+    expect(reductor.reduce({type: "column", column: "c-nullable-str", op: "null"})).toEqual({
+      type: "column",
+      column: "c-nullable-str",
+      op: "null",
+    });
+  });
+
+  test("empty string val", () => {
+    expect(reductor.reduce({type: "column", column: "c-str", op: "=", val: ""})).toEqual("never");
+    expect(reductor.reduce({type: "column", column: "c-str", op: ">", val: ""})).toEqual("always");
+    expect(reductor.reduce({type: "column", column: "c-str", op: "<", val: ""})).toEqual("never");
+    expect(reductor.reduce({type: "column", column: "c-str", op: ">=", val: ""})).toEqual("always");
+    expect(reductor.reduce({type: "column", column: "c-str", op: "<=", val: ""})).toEqual("never");
+    expect(reductor.reduce({type: "column", column: "c-str", op: "v%", val: ""})).toEqual("always");
+
+    const nullFilter = {type: "column", column: "c-nullable-str", op: "null"};
+    const notNullFilter = {...nullFilter, inv: true};
+    expect(reductor.reduce({type: "column", column: "c-nullable-str", op: "=", val: ""})).toEqual(nullFilter);
+    expect(reductor.reduce({type: "column", column: "c-nullable-str", op: ">", val: ""})).toEqual(notNullFilter);
+    expect(reductor.reduce({type: "column", column: "c-nullable-str", op: "<", val: ""})).toEqual("never");
+    expect(reductor.reduce({type: "column", column: "c-nullable-str", op: ">=", val: ""})).toEqual("always");
+    expect(reductor.reduce({type: "column", column: "c-nullable-str", op: "<=", val: ""})).toEqual(nullFilter);
+    expect(reductor.reduce({type: "column", column: "c-nullable-str", op: "v%", val: ""})).toEqual("always");
+  });
+
+  test("untrimmed string val", () => {
+    expect(reductor.reduce({type: "column", column: "c-str", op: "=", val: "foo  "})).toEqual("never");
+    expect(reductor.reduce({type: "column", column: "c-str", op: "<", val: "foo  "})).toEqual({
+      type: "column",
+      column: "c-str",
+      op: "<",
+      val: "foo  ",
+    });
+
+    expect(reductor.reduce({type: "column", column: "c-nullable-str", op: "=", val: "foo  "})).toEqual("never");
+    expect(reductor.reduce({type: "column", column: "c-nullable-str", op: "<", val: "foo  "})).toEqual({
+      type: "column",
+      column: "c-nullable-str",
+      op: "<",
+      val: "foo  ",
+    });
+  });
+
+  describe("has_* filters", () => {
+    test("empty val", () => {
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_all", val: []})).toEqual("always");
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_any", val: []})).toEqual("never");
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_only", val: []})).toEqual({
+        type: "column",
+        column: "c-uuid-list",
+        op: "null",
+      });
+    });
+
+    test("single element in val", () => {
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_all", val: ["x"]})).toEqual({
+        type: "column",
+        column: "c-uuid-list",
+        op: "has",
+        val: "x",
+      });
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_any", val: ["x"]})).toEqual({
+        type: "column",
+        column: "c-uuid-list",
+        op: "has",
+        val: "x",
+      });
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_only", val: ["x"]})).toEqual({
+        type: "column",
+        column: "c-uuid-list",
+        op: "has_only",
+        val: ["x"],
+      });
+    });
+
+    test("empty string in val", () => {
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_all", val: [""]})).toEqual("never");
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_any", val: [""]})).toEqual("never");
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_only", val: [""]})).toEqual({
+        type: "column",
+        column: "c-uuid-list",
+        op: "null",
+      });
+
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_all", val: ["", "x"]})).toEqual("never");
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_any", val: ["", "x"]})).toEqual({
+        type: "column",
+        column: "c-uuid-list",
+        op: "has",
+        val: "x",
+      });
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_only", val: ["", "x"]})).toEqual({
+        type: "column",
+        column: "c-uuid-list",
+        op: "has_only",
+        val: ["x"],
+      });
+    });
+
+    test("untrimmed string in val", () => {
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_all", val: ["x  "]})).toEqual("never");
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_any", val: ["x  "]})).toEqual("never");
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_only", val: ["x  "]})).toEqual({
+        type: "column",
+        column: "c-uuid-list",
+        op: "null",
+      });
+
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_all", val: ["x  ", "y"]})).toEqual(
+        "never",
+      );
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_any", val: ["x  ", "y"]})).toEqual({
+        type: "column",
+        column: "c-uuid-list",
+        op: "has",
+        val: "y",
+      });
+      expect(reductor.reduce({type: "column", column: "c-uuid-list", op: "has_only", val: ["x  ", "y"]})).toEqual({
+        type: "column",
+        column: "c-uuid-list",
+        op: "has_only",
+        val: ["y"],
+      });
+    });
+  });
+
+  describe("bool op filters", () => {
+    test("empty val", () => {
+      expect(reductor.reduce({type: "op", op: "&", val: []})).toEqual("always");
+      expect(reductor.reduce({type: "op", op: "|", val: []})).toEqual("never");
+    });
+
+    test("single element in val", () => {
+      const f: FilterH = {type: "column", column: "c-uuid-list", op: "has_all", val: ["x", "y", "z"]};
+      expect(reductor.reduce({type: "op", op: "&", val: [f]})).toEqual(f);
+      expect(reductor.reduce({type: "op", op: "|", val: [f]})).toEqual(f);
+    });
+
+    test("always/never in val", () => {
+      const alwaysFilter: FilterH = {type: "column", column: "c-str", op: "v%", val: ""};
+      const neverFilter: FilterH = {type: "column", column: "c-str", op: "v%", val: "", inv: true};
+      expect(reductor.reduce(alwaysFilter)).toEqual("always");
+      expect(reductor.reduce(neverFilter)).toEqual("never");
+
+      const f: FilterH = {type: "column", column: "c-uuid-list", op: "has_all", val: ["x", "y", "z"]};
+      expect(reductor.reduce({type: "op", op: "&", val: [alwaysFilter, f]})).toEqual(f);
+      expect(reductor.reduce({type: "op", op: "&", val: [neverFilter, f]})).toEqual("never");
+      expect(reductor.reduce({type: "op", op: "&", val: [alwaysFilter, neverFilter, f]})).toEqual("never");
+      expect(reductor.reduce({type: "op", op: "|", val: [alwaysFilter, f]})).toEqual("always");
+      expect(reductor.reduce({type: "op", op: "|", val: [neverFilter, f]})).toEqual(f);
+      expect(reductor.reduce({type: "op", op: "|", val: [alwaysFilter, neverFilter, f]})).toEqual("always");
+
+      expect(reductor.reduce({type: "op", op: "&", val: [alwaysFilter, f], inv: true})).toEqual(invert(f));
+      expect(reductor.reduce({type: "op", op: "&", val: [neverFilter, f], inv: true})).toEqual("always");
+      expect(reductor.reduce({type: "op", op: "&", val: [alwaysFilter, neverFilter, f], inv: true})).toEqual("always");
+      expect(reductor.reduce({type: "op", op: "|", val: [alwaysFilter, f], inv: true})).toEqual("never");
+      expect(reductor.reduce({type: "op", op: "|", val: [neverFilter, f], inv: true})).toEqual(invert(f));
+      expect(reductor.reduce({type: "op", op: "|", val: [alwaysFilter, neverFilter, f], inv: true})).toEqual("never");
+    });
+
+    test("nested bool op filters", () => {
+      const f: FilterH = {type: "column", column: "c-uuid-list", op: "has_all", val: ["x", "y", "z"]};
+      const g: FilterH = {type: "column", column: "c-str", op: "v%", val: "foo"};
+      const h: FilterH = {type: "column", column: "c-nullable-str", op: "=", val: "bar"};
+
+      expect(
+        reductor.reduce({
+          type: "op",
+          op: "&",
+          val: [
+            {type: "op", op: "&", val: [f, g]},
+            {type: "op", op: "&", val: [h]},
+          ],
+        }),
+      ).toEqual({type: "op", op: "&", val: [f, g, h]});
+      expect(
+        reductor.reduce({
+          type: "op",
+          op: "|",
+          val: [
+            {type: "op", op: "|", val: [f, g]},
+            {type: "op", op: "|", val: [h]},
+          ],
+        }),
+      ).toEqual({type: "op", op: "|", val: [f, g, h]});
+
+      expect(
+        reductor.reduce({
+          type: "op",
+          op: "&",
+          val: [
+            {type: "op", op: "|", val: [f, g], inv: true},
+            {type: "op", op: "|", val: [h], inv: true},
+          ],
+        }),
+      ).toEqual({type: "op", op: "&", val: [invert(f), invert(g), invert(h)]});
+      expect(
+        reductor.reduce({
+          type: "op",
+          op: "|",
+          val: [
+            {type: "op", op: "&", val: [f, g], inv: true},
+            {type: "op", op: "&", val: [h], inv: true},
+          ],
+        }),
+      ).toEqual({type: "op", op: "|", val: [invert(f), invert(g), invert(h)]});
+    });
+  });
+});
diff --git a/resources/js/data-access/memo-api/tquery/filter_utils.ts b/resources/js/data-access/memo-api/tquery/filter_utils.ts
index 48a7ee606..a55f1c530 100644
--- a/resources/js/data-access/memo-api/tquery/filter_utils.ts
+++ b/resources/js/data-access/memo-api/tquery/filter_utils.ts
@@ -34,6 +34,10 @@ export function invert(filter: FilterH, invert?: boolean): FilterH {
   }
 }
 
+function otherBoolOp(op: "&" | "|") {
+  return op === "&" ? "|" : "&";
+}
+
 export class FilterReductor {
   private readonly columnsData = new Map<ColumnName, ColumnSchema>();
 
@@ -78,6 +82,9 @@ export class FilterReductor {
           if (subFilter.type === "op" && subFilter.op === op && !subFilter.inv) {
             // Unnest a bool operation of the same type.
             subFiltersToProcess.push(...subFilter.val.toReversed());
+          } else if (subFilter.type === "op" && subFilter.op === otherBoolOp(op) && subFilter.inv) {
+            // Invert the inverted nested operation of the other type using De Morgan's laws.
+            subFiltersToProcess.push(...subFilter.val.map((f) => invert(f)).toReversed());
           } else {
             reducedSubFilters.push(subFilter);
           }
@@ -111,7 +118,7 @@ export class FilterReductor {
         if (val === "") {
           // Frontend treats the null values in string columns as empty strings (because this is what
           // is reasonable for the user).
-          if (op === "=" || op === "==" || op === "lv" || op === "<" || op === "<=") {
+          if (op === "=" || op === "==" || op === "lv" || op === "<=") {
             // Matches only null strings.
             return nullFilter();
           } else if (op === ">") {
@@ -120,7 +127,7 @@ export class FilterReductor {
           } else if (op === ">=" || op === "v%" || op === "%v" || op === "%v%" || op === "/v/") {
             // Matches everything.
             return "always";
-          } else if (op === "has") {
+          } else if (op === "<" || op === "has") {
             // Even a null column is not considered to "have an empty string", but rather to contain nothing.
             return "never";
           } else if (op === "in" || op === "has_all" || op === "has_any" || op === "has_only") {
@@ -138,17 +145,15 @@ export class FilterReductor {
         }
         if (Array.isArray(val)) {
           const vals = new Set<string | number>(val);
-          function deleteEmptyVal() {
-            return vals.delete("");
-          }
-          function deleteUntrimmedVals() {
+          /** Removes from vals all invalid values, i.e. empty and untrimmed strings. Returns whether modified. */
+          function deleteInvalidVals() {
             let modified = false;
             for (const v of vals) {
               if (typeof v !== "string") {
-                // No strings in the vals.
+                // Assume no strings in the vals.
                 return false;
               }
-              if (v !== v.trim()) {
+              if (!v || v !== v.trim()) {
                 vals.delete(v);
                 modified = true;
               }
@@ -157,53 +162,40 @@ export class FilterReductor {
           }
           const valsArray = () => [...vals] as string[] | number[];
           if (op === "in") {
-            const containedEmpty = deleteEmptyVal();
-            deleteUntrimmedVals();
-            return this.reduce({
-              type: "op",
-              op: "|",
-              val: [
-                containedEmpty ? nullFilter() : "never",
-                vals.size === 0
-                  ? "never"
-                  : vals.size === 1
-                    ? {type: "column", column, op: "=", val: valsArray()[0]!}
-                    : {type: "column", column, op: "in", val: valsArray()},
-              ],
-            });
+            deleteInvalidVals();
+            return vals.size === 0
+              ? "never"
+              : vals.size === 1
+                ? {type: "column", column, op: "=", val: valsArray()[0]!}
+                : {type: "column", column, op: "in", val: valsArray()};
+          } else if (op === "=") {
+            const hadInvalidVals = deleteInvalidVals();
+            return hadInvalidVals
+              ? "never"
+              : vals.size === 0
+                ? nullFilter()
+                : {type: "column", column, op: "=", val: valsArray() as /* currently only */ string[]};
           } else {
             const stringValsArray = valsArray as () => string[];
             if (op === "has_all") {
-              return vals.size === 0
-                ? "always"
-                : deleteEmptyVal() || deleteUntrimmedVals()
-                  ? "never"
+              const hadInvalidVals = deleteInvalidVals();
+              return hadInvalidVals
+                ? "never"
+                : vals.size === 0
+                  ? "always"
                   : vals.size === 1
                     ? {type: "column", column, op: "has", val: stringValsArray()[0]!}
                     : {type: "column", column, op: "has_all", val: stringValsArray()};
             } else if (op === "has_any") {
-              deleteEmptyVal();
-              deleteUntrimmedVals();
+              deleteInvalidVals();
               return vals.size === 0
                 ? "never"
                 : vals.size === 1
                   ? {type: "column", column, op: "has", val: stringValsArray()[0]!}
                   : {type: "column", column, op: "has_any", val: stringValsArray()};
             } else if (op === "has_only") {
-              deleteEmptyVal();
-              deleteUntrimmedVals();
-              return this.reduce({
-                type: "op",
-                op: "|",
-                val: [
-                  nullFilter(),
-                  vals.size === 0
-                    ? "never"
-                    : vals.size === 1
-                      ? {type: "column", column, op: "=", val: stringValsArray()}
-                      : {type: "column", column, op: "has_only", val: stringValsArray()},
-                ],
-              });
+              deleteInvalidVals();
+              return vals.size === 0 ? nullFilter() : {type: "column", column, op: "has_only", val: stringValsArray()};
             }
           }
           throw new Error(`Bad filter: ${JSON.stringify(filter)}`);
diff --git a/resources/js/data-access/memo-api/tquery/table.ts b/resources/js/data-access/memo-api/tquery/table.ts
index e93ede8e6..1f31f23ea 100644
--- a/resources/js/data-access/memo-api/tquery/table.ts
+++ b/resources/js/data-access/memo-api/tquery/table.ts
@@ -9,7 +9,7 @@ import {translateError} from "../error_util";
 import {Api} from "../types";
 import {FilterH, FilterReductor} from "./filter_utils";
 import {RequestCreator} from "./tquery";
-import {Column, ColumnName, DataRequest, DataResponse, Filter} from "./types";
+import {Column, ColumnName, DataRequest, DataResponse, Filter, Sort, SortItem} from "./types";
 
 export interface ColumnConfig {
   readonly name: string;
@@ -45,12 +45,14 @@ const DEFAULT_PAGE_SIZE = 50;
 export function createTableRequestCreator({
   columnsConfig,
   intrinsicFilter = () => undefined,
+  intrinsicSort = () => undefined,
   initialSort = [],
   initialPageSize = DEFAULT_PAGE_SIZE,
   allInitialised = () => true,
 }: {
   columnsConfig: Accessor<readonly ColumnConfig[]>;
   intrinsicFilter?: Accessor<FilterH | undefined>;
+  intrinsicSort?: Accessor<Sort | undefined>;
   initialSort?: SortingState;
   initialPageSize?: number;
   allInitialised?: Accessor<boolean>;
@@ -98,6 +100,9 @@ export function createTableRequestCreator({
         let restoredColumnVisibility = prevColumnVisibility;
         // Revert to the previous visibility state if possible, otherwise show all columns.
         if (!restoredColumnVisibility || !Object.values(restoredColumnVisibility).some((v) => v)) {
+          if (!columnsConfig().length) {
+            return {};
+          }
           restoredColumnVisibility = {};
           for (const {name} of columnsConfig()) {
             restoredColumnVisibility[name] = true;
@@ -155,6 +160,24 @@ export function createTableRequestCreator({
       if (!allInitialisedInternal() || !allInitialised()) {
         return undefined;
       }
+      const sort: SortItem[] = sorting().map(({id, desc}) => ({
+        type: "column",
+        column: id,
+        desc,
+      }));
+      const intrinsicSortToApply = intrinsicSort()?.filter((sortItem) => {
+        if (sortItem.type === "column" && sort.some((s) => s.type === "column" && s.column === sortItem.column)) {
+          // Skip repeated columns.
+          return false;
+        }
+        return true;
+      });
+      for (const sortItem of intrinsicSortToApply || []) {
+        if (sortItem.type === "column" && sort.some((s) => s.type === "column" && s.column === sortItem.column)) {
+          continue;
+        }
+        sort.push(sortItem);
+      }
       return {
         columns: dataColumns(),
         filter: filterReductor()?.reduce({
@@ -166,11 +189,7 @@ export function createTableRequestCreator({
             columnFiltersJoined(),
           ].filter(NON_NULLABLE),
         }),
-        sort: sorting().map(({id, desc}) => ({
-          type: "column",
-          column: id,
-          desc,
-        })),
+        sort,
         paging: {
           number: pagination().pageIndex + 1,
           size: pagination().pageSize,
diff --git a/resources/js/data-access/memo-api/tquery/types.ts b/resources/js/data-access/memo-api/tquery/types.ts
index 11c485bde..639021bda 100644
--- a/resources/js/data-access/memo-api/tquery/types.ts
+++ b/resources/js/data-access/memo-api/tquery/types.ts
@@ -37,7 +37,8 @@ interface PlainDataColumnSchema extends DataColumnSchemaBase {
     | "object"
     | "string"
     | "text"
-    | "uuid";
+    | "uuid"
+    | "uuid_list";
   /** The attribute defining this data column. */
   readonly attributeId?: string;
 }
@@ -107,6 +108,7 @@ export type ColumnValueFilter =
   | StringColumnFilter
   | TextColumnFilter
   | UuidColumnFilter
+  | UuidListColumnFilter
   | DictColumnFilter
   | DictListColumnFilter;
 
@@ -188,6 +190,10 @@ export type StringColumnFilter =
   | RegexpColumnFilter;
 export type TextColumnFilter = ContainsColumnFilter | LikeColumnFilter | RegexpColumnFilter;
 export type UuidColumnFilter = EqColumnFilter<string> | InColumnFilter<string>;
+export type UuidListColumnFilter =
+  | EqColumnFilter<readonly string[]>
+  | HasColumnFilter<string>
+  | SetsOpColumnFilter<string>;
 export type DictColumnFilter = EqColumnFilter<string> | InColumnFilter<string>;
 export type DictListColumnFilter =
   | EqColumnFilter<readonly string[]>
diff --git a/resources/js/features/root/pages/AdminFacilitiesList.page.tsx b/resources/js/features/root/pages/AdminFacilitiesList.page.tsx
index 5d0177e3a..1935cf292 100644
--- a/resources/js/features/root/pages/AdminFacilitiesList.page.tsx
+++ b/resources/js/features/root/pages/AdminFacilitiesList.page.tsx
@@ -18,6 +18,7 @@ export default (() => {
         staticPrefixQueryKey={Admin.keys.facility()}
         staticEntityURL="admin/facility"
         staticTranslations={createTableTranslations("facilities")}
+        staticPersistenceKey="adminFacilities"
         columns={[
           {name: "id", initialVisible: false},
           {name: "name", columnDef: {enableHiding: false}},
diff --git a/resources/js/features/root/pages/AdminUsersList.page.tsx b/resources/js/features/root/pages/AdminUsersList.page.tsx
index 170ae42b7..ef75762ee 100644
--- a/resources/js/features/root/pages/AdminUsersList.page.tsx
+++ b/resources/js/features/root/pages/AdminUsersList.page.tsx
@@ -19,6 +19,7 @@ export default (() => {
         staticPrefixQueryKey={Admin.keys.user()}
         staticEntityURL="admin/user"
         staticTranslations={createTableTranslations("users")}
+        staticPersistenceKey="adminUsers"
         columns={[
           {name: "id", initialVisible: false},
           {name: "name", columnDef: {enableHiding: false}},
@@ -26,7 +27,7 @@ export default (() => {
           {name: "hasEmailVerified", initialVisible: false},
           {name: "hasPassword"},
           {name: "passwordExpireAt", initialVisible: false},
-          {name: "facilityCount", initialVisible: false},
+          {name: "facilities.count", initialVisible: false},
           {
             name: "hasGlobalAdmin",
             columnDef: {
diff --git a/resources/js/features/root/pages/CalendarTable.page.tsx b/resources/js/features/root/pages/CalendarTable.page.tsx
new file mode 100644
index 000000000..a1ad71be4
--- /dev/null
+++ b/resources/js/features/root/pages/CalendarTable.page.tsx
@@ -0,0 +1,56 @@
+import {createTableTranslations} from "components/ui/Table";
+import {TQueryTable} from "components/ui/Table/TQueryTable";
+import {EN_DASH} from "components/ui/symbols";
+import {formatDayMinuteHM} from "components/utils/day_minute_util";
+import {FacilityMeeting} from "data-access/memo-api/groups/FacilityMeeting";
+import {VoidComponent} from "solid-js";
+import {activeFacilityId} from "state/activeFacilityId.state";
+
+export default (() => {
+  return (
+    <>
+      <TQueryTable
+        mode="standalone"
+        staticPrefixQueryKey={FacilityMeeting.keys.meeting()}
+        staticEntityURL={`facility/${activeFacilityId()}/meeting`}
+        staticTranslations={createTableTranslations("meetings")}
+        staticPersistenceKey="facilityMeetings"
+        intrinsicSort={[{type: "column", column: "date", desc: true}]}
+        columns={[
+          {name: "id", initialVisible: false},
+          {name: "date"},
+          {
+            name: "startDayminute",
+            extraDataColumns: ["durationMinutes"],
+            columnDef: {
+              cell: (c) => (
+                <span>
+                  {formatDayMinuteHM(c.row.getValue<number>("startDayminute"), {hour: "2-digit"})} {EN_DASH}{" "}
+                  {formatDayMinuteHM(
+                    c.row.getValue<number>("startDayminute") + c.row.getValue<number>("durationMinutes"),
+                    {hour: "2-digit"},
+                  )}
+                </span>
+              ),
+              enableColumnFilter: false,
+              size: 120,
+            },
+          },
+          {name: "durationMinutes", initialVisible: false, columnDef: {size: 120}},
+          {name: "categoryDictId", initialVisible: false},
+          {name: "typeDictId"},
+          {name: "statusDictId"},
+          {name: "staff.*.name"},
+          {name: "clients.*.name"},
+          {name: "isRemote"},
+          {name: "notes"},
+          {name: "resources.*.dictId"},
+          {name: "createdAt", columnDef: {sortDescFirst: true}, initialVisible: false},
+          {name: "createdBy.name", initialVisible: false},
+          {name: "updatedAt", columnDef: {sortDescFirst: true}, initialVisible: false},
+        ]}
+        initialSort={[{id: "date", desc: true}]}
+      />
+    </>
+  );
+}) satisfies VoidComponent;
diff --git a/resources/lang/pl_PL/models.yml b/resources/lang/pl_PL/models.yml
index db7942db5..86c80683d 100644
--- a/resources/lang/pl_PL/models.yml
+++ b/resources/lang/pl_PL/models.yml
@@ -65,7 +65,7 @@ user:
   password: "hasło"
   hasEmailVerified: "e-mail zweryfikowany"
   members: "przypisane placówki"
-  facilityCount: "liczba placówek"
+  facilities.count: "liczba placówek"
 
 staff:
   _name: "pracownik"
@@ -82,7 +82,7 @@ meeting:
   date: "data"
   startDayminute: "godzina rozpoczęcia"
   durationMinutes: "długość"
-  categoryDictId: "$t(dictionary.meetingCategory._name)"
+  categoryDictId: "kategoria"
   typeDictId: "typ"
   statusDictId: "$t(dictionary.meetingStatus._name)"
   staff: "$t(models.staff._name_plural)"
@@ -91,3 +91,6 @@ meeting:
   isRemote: "spotkanie zdalne"
   resources: "zasoby"
   notes: "$t(models.generic.notes)"
+  createdAt: "$t(models.generic.createdAt)"
+  updatedAt: "$t(models.generic.updatedAt)"
+  createdBy: "$t(models.generic.createdBy)"
diff --git a/resources/lang/pl_PL/routes.yml b/resources/lang/pl_PL/routes.yml
index 577f8427b..522fa12e2 100644
--- a/resources/lang/pl_PL/routes.yml
+++ b/resources/lang/pl_PL/routes.yml
@@ -13,6 +13,7 @@ facility:
   home: "$t(models.facility._name)"
   admin:
     calendar: "$t(calendar.calendar)"
+    calendar_table: "tabela spotkań"
     clients: "$t(models.client._name_plural)"
     staff: "pracownicy"
     reports: "raporty"
diff --git a/resources/lang/pl_PL/tables.yml b/resources/lang/pl_PL/tables.yml
index 30f238921..25db02232 100644
--- a/resources/lang/pl_PL/tables.yml
+++ b/resources/lang/pl_PL/tables.yml
@@ -20,12 +20,12 @@ tables:
       email: "$t(models.user.email)"
       hasPassword: "$t(models.user.hasPassword)"
       createdAt: "$t(models.user.createdAt)"
+      updatedAt: "$t(models.user.updatedAt)"
+      createdBy.name: "$t(models.user.createdBy)"
       hasGlobalAdmin: "$t(models.user.hasGlobalAdmin)"
       passwordExpireAt: "$t(models.user.passwordExpireAt)"
-      updatedAt: "$t(models.user.updatedAt)"
       hasEmailVerified: "$t(models.user.hasEmailVerified)"
-      createdBy.name: "$t(models.user.createdBy)"
-      facilityCount: "$t(models.user.facilityCount)"
+      facilities.count: "$t(models.user.facilities.count)"
       actions: "$t(tables.tables.generic.columnNames.actions)"
 
   userFacilities:
@@ -51,6 +51,29 @@ tables:
       url: "$t(models.facility.url)"
       actions: "$t(tables.tables.generic.columnNames.actions)"
 
+  meetings:
+    tableName: "$t(models.meeting._name_plural)"
+    summary__zero: "Brak spotkań"
+    summary__one: "{{count, number}} spotkanie"
+    summary__few: "{{count, number}} spotkania"
+    summary__many: "{{count, number}} spotkań"
+    columnNames:
+      id: "$t(tables.tables.generic.columnNames.id)"
+      date: "$t(models.meeting.date)"
+      startDayminute: "godzina"
+      durationMinutes: "$t(models.meeting.durationMinutes)"
+      categoryDictId: "$t(models.meeting.categoryDictId)"
+      typeDictId: "$t(models.meeting.typeDictId)"
+      statusDictId: "$t(models.meeting.statusDictId)"
+      staff.*.name: "$t(models.meeting.staff)"
+      clients.*.name: "$t(models.meeting.clients)"
+      isRemote: "$t(models.meeting.isRemote)"
+      notes: "$t(models.meeting.notes)"
+      resources.*.dictId: "$t(models.meeting.resources)"
+      createdAt: "$t(models.meeting.createdAt)"
+      updatedAt: "$t(models.meeting.updatedAt)"
+      createdBy.name: "$t(models.meeting.createdBy)"
+
 choose_columns: "Wybierz kolumny"
 sort_tooltip: "$t(actions.sort)"
 
@@ -62,9 +85,19 @@ filter:
   column_filters_set: "Filtry w kolumnach aktywne:"
   click_to_clear: "Kliknij aby wyczyścić"
   click_to_sync_date_range: "Kliknij aby ustawić jednodniowy zakres"
-  click_to_sync_number_range: "Kliknij aby ustawić maks = min"
+  click_to_sync_number_range: "Kliknij aby ustawić max = min"
   non_null_value: "niepuste"
   null_value: "puste"
+  set_operation:
+    has_all:
+      short: "wszystkie"
+      explanation: "Znajdź wiersze, które mają wszystkie wybrane wartości"
+    has_any:
+      short: "dowolne"
+      explanation: "Znajdź wiersze, które mają dowolną z wybranych wartości"
+    has_only:
+      short: "tylko"
+      explanation: "Znajdź wiersze, które mają tylko wybrane wartości (niekoniecznie wszystkie)"
   textual:
     fuzzy: "dopasowane"
     eq: "równe"