diff --git a/.fvm/flutter_sdk b/.fvm/flutter_sdk
index 229a3ed22..e7f1627bb 120000
--- a/.fvm/flutter_sdk
+++ b/.fvm/flutter_sdk
@@ -1 +1 @@
-/Users/mn/fvm/versions/3.24.4
\ No newline at end of file
+/Users/mn/fvm/versions/3.24.5
\ No newline at end of file
diff --git a/.fvm/fvm_config.json b/.fvm/fvm_config.json
index 489810e62..7f89fed42 100644
--- a/.fvm/fvm_config.json
+++ b/.fvm/fvm_config.json
@@ -1,3 +1,3 @@
 {
-  "flutterSdkVersion": "3.24.4"
+  "flutterSdkVersion": "3.24.5"
 }
\ No newline at end of file
diff --git a/.fvmrc b/.fvmrc
index ff263c64c..5c7f58e2b 100644
--- a/.fvmrc
+++ b/.fvmrc
@@ -1,3 +1,3 @@
 {
-  "flutter": "3.24.4"
+  "flutter": "3.24.5"
 }
\ No newline at end of file
diff --git a/ios/Podfile.lock b/ios/Podfile.lock
index 38ff7b6ee..ebd773b7a 100644
--- a/ios/Podfile.lock
+++ b/ios/Podfile.lock
@@ -22,7 +22,7 @@ PODS:
     - Flutter
   - flutter_local_notifications (0.0.1):
     - Flutter
-  - flutter_native_splash (0.0.1):
+  - flutter_native_splash (2.4.3):
     - Flutter
   - flutter_native_timezone (0.0.1):
     - Flutter
@@ -253,8 +253,8 @@ SPEC CHECKSUMS:
   flutter_health_fit: af332b5d7512b9cc8a05e7282cfcee02b056d32e
   flutter_image_compress_common: ec1d45c362c9d30a3f6a0426c297f47c52007e3e
   flutter_keyboard_visibility_temp_fork: 442dadca3b81868a225cd6a2f605bffff1215844
-  flutter_local_notifications: 4cde75091f6327eb8517fa068a0a5950212d2086
-  flutter_native_splash: edf599c81f74d093a4daf8e17bd7a018854bc778
+  flutter_local_notifications: df98d66e515e1ca797af436137b4459b160ad8c9
+  flutter_native_splash: e8a1e01082d97a8099d973f919f57904c925008a
   flutter_native_timezone: 5f05b2de06c9776b4cc70e1839f03de178394d22
   flutter_olm: 7154e02866bd06d91e400e94f66d5e2a955de0b1
   flutter_openssl_crypto: 636ad25f56fbe0f45b9e13b8589540b341a486a1
diff --git a/lib/blocs/theming/theming_cubit.dart b/lib/blocs/theming/theming_cubit.dart
index 6f065cfed..b11633be3 100644
--- a/lib/blocs/theming/theming_cubit.dart
+++ b/lib/blocs/theming/theming_cubit.dart
@@ -49,7 +49,6 @@ class ThemingCubit extends Cubit<ThemingState> {
     _lightTheme = withOverrides(
       FlexThemeData.light(
         scheme: scheme,
-        useMaterial3: true,
         fontFamily: mainFont,
       ),
     );
@@ -60,7 +59,6 @@ class ThemingCubit extends Cubit<ThemingState> {
     _darkTheme = withOverrides(
       FlexThemeData.dark(
         scheme: scheme,
-        useMaterial3: true,
         fontFamily: mainFont,
       ),
     );
diff --git a/lib/database/database.g.dart b/lib/database/database.g.dart
index 7f06e80e4..02769c37c 100644
--- a/lib/database/database.g.dart
+++ b/lib/database/database.g.dart
@@ -5551,20 +5551,246 @@ typedef $JournalUpdateCompanionBuilder = JournalCompanion Function({
   Value<int> rowid,
 });
 
+class $JournalFilterComposer extends Composer<_$JournalDb, Journal> {
+  $JournalFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get dateFrom => $composableBuilder(
+      column: $table.dateFrom, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get dateTo => $composableBuilder(
+      column: $table.dateTo, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get deleted => $composableBuilder(
+      column: $table.deleted, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get starred => $composableBuilder(
+      column: $table.starred, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get private => $composableBuilder(
+      column: $table.private, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get task => $composableBuilder(
+      column: $table.task, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get taskStatus => $composableBuilder(
+      column: $table.taskStatus, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<int> get flag => $composableBuilder(
+      column: $table.flag, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get type => $composableBuilder(
+      column: $table.type, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get subtype => $composableBuilder(
+      column: $table.subtype, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<int> get schemaVersion => $composableBuilder(
+      column: $table.schemaVersion, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get plainText => $composableBuilder(
+      column: $table.plainText, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<double> get latitude => $composableBuilder(
+      column: $table.latitude, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<double> get longitude => $composableBuilder(
+      column: $table.longitude, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get geohashString => $composableBuilder(
+      column: $table.geohashString, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<int> get geohashInt => $composableBuilder(
+      column: $table.geohashInt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get category => $composableBuilder(
+      column: $table.category, builder: (column) => ColumnFilters(column));
+}
+
+class $JournalOrderingComposer extends Composer<_$JournalDb, Journal> {
+  $JournalOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get dateFrom => $composableBuilder(
+      column: $table.dateFrom, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get dateTo => $composableBuilder(
+      column: $table.dateTo, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get deleted => $composableBuilder(
+      column: $table.deleted, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get starred => $composableBuilder(
+      column: $table.starred, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get private => $composableBuilder(
+      column: $table.private, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get task => $composableBuilder(
+      column: $table.task, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get taskStatus => $composableBuilder(
+      column: $table.taskStatus, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<int> get flag => $composableBuilder(
+      column: $table.flag, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get type => $composableBuilder(
+      column: $table.type, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get subtype => $composableBuilder(
+      column: $table.subtype, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<int> get schemaVersion => $composableBuilder(
+      column: $table.schemaVersion,
+      builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get plainText => $composableBuilder(
+      column: $table.plainText, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<double> get latitude => $composableBuilder(
+      column: $table.latitude, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<double> get longitude => $composableBuilder(
+      column: $table.longitude, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get geohashString => $composableBuilder(
+      column: $table.geohashString,
+      builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<int> get geohashInt => $composableBuilder(
+      column: $table.geohashInt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get category => $composableBuilder(
+      column: $table.category, builder: (column) => ColumnOrderings(column));
+}
+
+class $JournalAnnotationComposer extends Composer<_$JournalDb, Journal> {
+  $JournalAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get createdAt =>
+      $composableBuilder(column: $table.createdAt, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get updatedAt =>
+      $composableBuilder(column: $table.updatedAt, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get dateFrom =>
+      $composableBuilder(column: $table.dateFrom, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get dateTo =>
+      $composableBuilder(column: $table.dateTo, builder: (column) => column);
+
+  GeneratedColumn<bool> get deleted =>
+      $composableBuilder(column: $table.deleted, builder: (column) => column);
+
+  GeneratedColumn<bool> get starred =>
+      $composableBuilder(column: $table.starred, builder: (column) => column);
+
+  GeneratedColumn<bool> get private =>
+      $composableBuilder(column: $table.private, builder: (column) => column);
+
+  GeneratedColumn<bool> get task =>
+      $composableBuilder(column: $table.task, builder: (column) => column);
+
+  GeneratedColumn<String> get taskStatus => $composableBuilder(
+      column: $table.taskStatus, builder: (column) => column);
+
+  GeneratedColumn<int> get flag =>
+      $composableBuilder(column: $table.flag, builder: (column) => column);
+
+  GeneratedColumn<String> get type =>
+      $composableBuilder(column: $table.type, builder: (column) => column);
+
+  GeneratedColumn<String> get subtype =>
+      $composableBuilder(column: $table.subtype, builder: (column) => column);
+
+  GeneratedColumn<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => column);
+
+  GeneratedColumn<int> get schemaVersion => $composableBuilder(
+      column: $table.schemaVersion, builder: (column) => column);
+
+  GeneratedColumn<String> get plainText =>
+      $composableBuilder(column: $table.plainText, builder: (column) => column);
+
+  GeneratedColumn<double> get latitude =>
+      $composableBuilder(column: $table.latitude, builder: (column) => column);
+
+  GeneratedColumn<double> get longitude =>
+      $composableBuilder(column: $table.longitude, builder: (column) => column);
+
+  GeneratedColumn<String> get geohashString => $composableBuilder(
+      column: $table.geohashString, builder: (column) => column);
+
+  GeneratedColumn<int> get geohashInt => $composableBuilder(
+      column: $table.geohashInt, builder: (column) => column);
+
+  GeneratedColumn<String> get category =>
+      $composableBuilder(column: $table.category, builder: (column) => column);
+}
+
 class $JournalTableManager extends RootTableManager<
     _$JournalDb,
     Journal,
     JournalDbEntity,
     $JournalFilterComposer,
     $JournalOrderingComposer,
+    $JournalAnnotationComposer,
     $JournalCreateCompanionBuilder,
-    $JournalUpdateCompanionBuilder> {
+    $JournalUpdateCompanionBuilder,
+    (JournalDbEntity, BaseReferences<_$JournalDb, Journal, JournalDbEntity>),
+    JournalDbEntity,
+    PrefetchHooks Function()> {
   $JournalTableManager(_$JournalDb db, Journal table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer: $JournalFilterComposer(ComposerState(db, table)),
-          orderingComposer: $JournalOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $JournalFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $JournalOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $JournalAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> id = const Value.absent(),
             Value<DateTime> createdAt = const Value.absent(),
@@ -5661,225 +5887,25 @@ class $JournalTableManager extends RootTableManager<
             category: category,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $JournalFilterComposer extends FilterComposer<_$JournalDb, Journal> {
-  $JournalFilterComposer(super.$state);
-  ColumnFilters<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get dateFrom => $state.composableBuilder(
-      column: $state.table.dateFrom,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get dateTo => $state.composableBuilder(
-      column: $state.table.dateTo,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get deleted => $state.composableBuilder(
-      column: $state.table.deleted,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get starred => $state.composableBuilder(
-      column: $state.table.starred,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get private => $state.composableBuilder(
-      column: $state.table.private,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get task => $state.composableBuilder(
-      column: $state.table.task,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get taskStatus => $state.composableBuilder(
-      column: $state.table.taskStatus,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<int> get flag => $state.composableBuilder(
-      column: $state.table.flag,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get type => $state.composableBuilder(
-      column: $state.table.type,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get subtype => $state.composableBuilder(
-      column: $state.table.subtype,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<int> get schemaVersion => $state.composableBuilder(
-      column: $state.table.schemaVersion,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get plainText => $state.composableBuilder(
-      column: $state.table.plainText,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<double> get latitude => $state.composableBuilder(
-      column: $state.table.latitude,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<double> get longitude => $state.composableBuilder(
-      column: $state.table.longitude,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get geohashString => $state.composableBuilder(
-      column: $state.table.geohashString,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<int> get geohashInt => $state.composableBuilder(
-      column: $state.table.geohashInt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get category => $state.composableBuilder(
-      column: $state.table.category,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $JournalOrderingComposer extends OrderingComposer<_$JournalDb, Journal> {
-  $JournalOrderingComposer(super.$state);
-  ColumnOrderings<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get dateFrom => $state.composableBuilder(
-      column: $state.table.dateFrom,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get dateTo => $state.composableBuilder(
-      column: $state.table.dateTo,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get deleted => $state.composableBuilder(
-      column: $state.table.deleted,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get starred => $state.composableBuilder(
-      column: $state.table.starred,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get private => $state.composableBuilder(
-      column: $state.table.private,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get task => $state.composableBuilder(
-      column: $state.table.task,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get taskStatus => $state.composableBuilder(
-      column: $state.table.taskStatus,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<int> get flag => $state.composableBuilder(
-      column: $state.table.flag,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get type => $state.composableBuilder(
-      column: $state.table.type,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get subtype => $state.composableBuilder(
-      column: $state.table.subtype,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<int> get schemaVersion => $state.composableBuilder(
-      column: $state.table.schemaVersion,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get plainText => $state.composableBuilder(
-      column: $state.table.plainText,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<double> get latitude => $state.composableBuilder(
-      column: $state.table.latitude,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<double> get longitude => $state.composableBuilder(
-      column: $state.table.longitude,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get geohashString => $state.composableBuilder(
-      column: $state.table.geohashString,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<int> get geohashInt => $state.composableBuilder(
-      column: $state.table.geohashInt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get category => $state.composableBuilder(
-      column: $state.table.category,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
-
+typedef $JournalProcessedTableManager = ProcessedTableManager<
+    _$JournalDb,
+    Journal,
+    JournalDbEntity,
+    $JournalFilterComposer,
+    $JournalOrderingComposer,
+    $JournalAnnotationComposer,
+    $JournalCreateCompanionBuilder,
+    $JournalUpdateCompanionBuilder,
+    (JournalDbEntity, BaseReferences<_$JournalDb, Journal, JournalDbEntity>),
+    JournalDbEntity,
+    PrefetchHooks Function()>;
 typedef $ConflictsCreateCompanionBuilder = ConflictsCompanion Function({
   required String id,
   required DateTime createdAt,
@@ -5899,21 +5925,110 @@ typedef $ConflictsUpdateCompanionBuilder = ConflictsCompanion Function({
   Value<int> rowid,
 });
 
+class $ConflictsFilterComposer extends Composer<_$JournalDb, Conflicts> {
+  $ConflictsFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<int> get schemaVersion => $composableBuilder(
+      column: $table.schemaVersion, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<int> get status => $composableBuilder(
+      column: $table.status, builder: (column) => ColumnFilters(column));
+}
+
+class $ConflictsOrderingComposer extends Composer<_$JournalDb, Conflicts> {
+  $ConflictsOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<int> get schemaVersion => $composableBuilder(
+      column: $table.schemaVersion,
+      builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<int> get status => $composableBuilder(
+      column: $table.status, builder: (column) => ColumnOrderings(column));
+}
+
+class $ConflictsAnnotationComposer extends Composer<_$JournalDb, Conflicts> {
+  $ConflictsAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get createdAt =>
+      $composableBuilder(column: $table.createdAt, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get updatedAt =>
+      $composableBuilder(column: $table.updatedAt, builder: (column) => column);
+
+  GeneratedColumn<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => column);
+
+  GeneratedColumn<int> get schemaVersion => $composableBuilder(
+      column: $table.schemaVersion, builder: (column) => column);
+
+  GeneratedColumn<int> get status =>
+      $composableBuilder(column: $table.status, builder: (column) => column);
+}
+
 class $ConflictsTableManager extends RootTableManager<
     _$JournalDb,
     Conflicts,
     Conflict,
     $ConflictsFilterComposer,
     $ConflictsOrderingComposer,
+    $ConflictsAnnotationComposer,
     $ConflictsCreateCompanionBuilder,
-    $ConflictsUpdateCompanionBuilder> {
+    $ConflictsUpdateCompanionBuilder,
+    (Conflict, BaseReferences<_$JournalDb, Conflicts, Conflict>),
+    Conflict,
+    PrefetchHooks Function()> {
   $ConflictsTableManager(_$JournalDb db, Conflicts table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer: $ConflictsFilterComposer(ComposerState(db, table)),
-          orderingComposer:
-              $ConflictsOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $ConflictsFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $ConflictsOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $ConflictsAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> id = const Value.absent(),
             Value<DateTime> createdAt = const Value.absent(),
@@ -5950,76 +6065,25 @@ class $ConflictsTableManager extends RootTableManager<
             status: status,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $ConflictsFilterComposer extends FilterComposer<_$JournalDb, Conflicts> {
-  $ConflictsFilterComposer(super.$state);
-  ColumnFilters<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<int> get schemaVersion => $state.composableBuilder(
-      column: $state.table.schemaVersion,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<int> get status => $state.composableBuilder(
-      column: $state.table.status,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $ConflictsOrderingComposer
-    extends OrderingComposer<_$JournalDb, Conflicts> {
-  $ConflictsOrderingComposer(super.$state);
-  ColumnOrderings<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<int> get schemaVersion => $state.composableBuilder(
-      column: $state.table.schemaVersion,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<int> get status => $state.composableBuilder(
-      column: $state.table.status,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
-
+typedef $ConflictsProcessedTableManager = ProcessedTableManager<
+    _$JournalDb,
+    Conflicts,
+    Conflict,
+    $ConflictsFilterComposer,
+    $ConflictsOrderingComposer,
+    $ConflictsAnnotationComposer,
+    $ConflictsCreateCompanionBuilder,
+    $ConflictsUpdateCompanionBuilder,
+    (Conflict, BaseReferences<_$JournalDb, Conflicts, Conflict>),
+    Conflict,
+    PrefetchHooks Function()>;
 typedef $MeasurableTypesCreateCompanionBuilder = MeasurableTypesCompanion
     Function({
   required String id,
@@ -6047,22 +6111,142 @@ typedef $MeasurableTypesUpdateCompanionBuilder = MeasurableTypesCompanion
   Value<int> rowid,
 });
 
+class $MeasurableTypesFilterComposer
+    extends Composer<_$JournalDb, MeasurableTypes> {
+  $MeasurableTypesFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get uniqueName => $composableBuilder(
+      column: $table.uniqueName, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get deleted => $composableBuilder(
+      column: $table.deleted, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get private => $composableBuilder(
+      column: $table.private, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<int> get version => $composableBuilder(
+      column: $table.version, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<int> get status => $composableBuilder(
+      column: $table.status, builder: (column) => ColumnFilters(column));
+}
+
+class $MeasurableTypesOrderingComposer
+    extends Composer<_$JournalDb, MeasurableTypes> {
+  $MeasurableTypesOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get uniqueName => $composableBuilder(
+      column: $table.uniqueName, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get deleted => $composableBuilder(
+      column: $table.deleted, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get private => $composableBuilder(
+      column: $table.private, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<int> get version => $composableBuilder(
+      column: $table.version, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<int> get status => $composableBuilder(
+      column: $table.status, builder: (column) => ColumnOrderings(column));
+}
+
+class $MeasurableTypesAnnotationComposer
+    extends Composer<_$JournalDb, MeasurableTypes> {
+  $MeasurableTypesAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<String> get uniqueName => $composableBuilder(
+      column: $table.uniqueName, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get createdAt =>
+      $composableBuilder(column: $table.createdAt, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get updatedAt =>
+      $composableBuilder(column: $table.updatedAt, builder: (column) => column);
+
+  GeneratedColumn<bool> get deleted =>
+      $composableBuilder(column: $table.deleted, builder: (column) => column);
+
+  GeneratedColumn<bool> get private =>
+      $composableBuilder(column: $table.private, builder: (column) => column);
+
+  GeneratedColumn<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => column);
+
+  GeneratedColumn<int> get version =>
+      $composableBuilder(column: $table.version, builder: (column) => column);
+
+  GeneratedColumn<int> get status =>
+      $composableBuilder(column: $table.status, builder: (column) => column);
+}
+
 class $MeasurableTypesTableManager extends RootTableManager<
     _$JournalDb,
     MeasurableTypes,
     MeasurableDbEntity,
     $MeasurableTypesFilterComposer,
     $MeasurableTypesOrderingComposer,
+    $MeasurableTypesAnnotationComposer,
     $MeasurableTypesCreateCompanionBuilder,
-    $MeasurableTypesUpdateCompanionBuilder> {
+    $MeasurableTypesUpdateCompanionBuilder,
+    (
+      MeasurableDbEntity,
+      BaseReferences<_$JournalDb, MeasurableTypes, MeasurableDbEntity>
+    ),
+    MeasurableDbEntity,
+    PrefetchHooks Function()> {
   $MeasurableTypesTableManager(_$JournalDb db, MeasurableTypes table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer:
-              $MeasurableTypesFilterComposer(ComposerState(db, table)),
-          orderingComposer:
-              $MeasurableTypesOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $MeasurableTypesFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $MeasurableTypesOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $MeasurableTypesAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> id = const Value.absent(),
             Value<String> uniqueName = const Value.absent(),
@@ -6111,107 +6295,28 @@ class $MeasurableTypesTableManager extends RootTableManager<
             status: status,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $MeasurableTypesFilterComposer
-    extends FilterComposer<_$JournalDb, MeasurableTypes> {
-  $MeasurableTypesFilterComposer(super.$state);
-  ColumnFilters<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get uniqueName => $state.composableBuilder(
-      column: $state.table.uniqueName,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get deleted => $state.composableBuilder(
-      column: $state.table.deleted,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get private => $state.composableBuilder(
-      column: $state.table.private,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<int> get version => $state.composableBuilder(
-      column: $state.table.version,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<int> get status => $state.composableBuilder(
-      column: $state.table.status,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $MeasurableTypesOrderingComposer
-    extends OrderingComposer<_$JournalDb, MeasurableTypes> {
-  $MeasurableTypesOrderingComposer(super.$state);
-  ColumnOrderings<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get uniqueName => $state.composableBuilder(
-      column: $state.table.uniqueName,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get deleted => $state.composableBuilder(
-      column: $state.table.deleted,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get private => $state.composableBuilder(
-      column: $state.table.private,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<int> get version => $state.composableBuilder(
-      column: $state.table.version,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<int> get status => $state.composableBuilder(
-      column: $state.table.status,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
-
+typedef $MeasurableTypesProcessedTableManager = ProcessedTableManager<
+    _$JournalDb,
+    MeasurableTypes,
+    MeasurableDbEntity,
+    $MeasurableTypesFilterComposer,
+    $MeasurableTypesOrderingComposer,
+    $MeasurableTypesAnnotationComposer,
+    $MeasurableTypesCreateCompanionBuilder,
+    $MeasurableTypesUpdateCompanionBuilder,
+    (
+      MeasurableDbEntity,
+      BaseReferences<_$JournalDb, MeasurableTypes, MeasurableDbEntity>
+    ),
+    MeasurableDbEntity,
+    PrefetchHooks Function()>;
 typedef $HabitDefinitionsCreateCompanionBuilder = HabitDefinitionsCompanion
     Function({
   required String id,
@@ -6237,22 +6342,133 @@ typedef $HabitDefinitionsUpdateCompanionBuilder = HabitDefinitionsCompanion
   Value<int> rowid,
 });
 
+class $HabitDefinitionsFilterComposer
+    extends Composer<_$JournalDb, HabitDefinitions> {
+  $HabitDefinitionsFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get name => $composableBuilder(
+      column: $table.name, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get deleted => $composableBuilder(
+      column: $table.deleted, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get private => $composableBuilder(
+      column: $table.private, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get active => $composableBuilder(
+      column: $table.active, builder: (column) => ColumnFilters(column));
+}
+
+class $HabitDefinitionsOrderingComposer
+    extends Composer<_$JournalDb, HabitDefinitions> {
+  $HabitDefinitionsOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get name => $composableBuilder(
+      column: $table.name, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get deleted => $composableBuilder(
+      column: $table.deleted, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get private => $composableBuilder(
+      column: $table.private, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get active => $composableBuilder(
+      column: $table.active, builder: (column) => ColumnOrderings(column));
+}
+
+class $HabitDefinitionsAnnotationComposer
+    extends Composer<_$JournalDb, HabitDefinitions> {
+  $HabitDefinitionsAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<String> get name =>
+      $composableBuilder(column: $table.name, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get createdAt =>
+      $composableBuilder(column: $table.createdAt, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get updatedAt =>
+      $composableBuilder(column: $table.updatedAt, builder: (column) => column);
+
+  GeneratedColumn<bool> get deleted =>
+      $composableBuilder(column: $table.deleted, builder: (column) => column);
+
+  GeneratedColumn<bool> get private =>
+      $composableBuilder(column: $table.private, builder: (column) => column);
+
+  GeneratedColumn<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => column);
+
+  GeneratedColumn<bool> get active =>
+      $composableBuilder(column: $table.active, builder: (column) => column);
+}
+
 class $HabitDefinitionsTableManager extends RootTableManager<
     _$JournalDb,
     HabitDefinitions,
     HabitDefinitionDbEntity,
     $HabitDefinitionsFilterComposer,
     $HabitDefinitionsOrderingComposer,
+    $HabitDefinitionsAnnotationComposer,
     $HabitDefinitionsCreateCompanionBuilder,
-    $HabitDefinitionsUpdateCompanionBuilder> {
+    $HabitDefinitionsUpdateCompanionBuilder,
+    (
+      HabitDefinitionDbEntity,
+      BaseReferences<_$JournalDb, HabitDefinitions, HabitDefinitionDbEntity>
+    ),
+    HabitDefinitionDbEntity,
+    PrefetchHooks Function()> {
   $HabitDefinitionsTableManager(_$JournalDb db, HabitDefinitions table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer:
-              $HabitDefinitionsFilterComposer(ComposerState(db, table)),
-          orderingComposer:
-              $HabitDefinitionsOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $HabitDefinitionsFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $HabitDefinitionsOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $HabitDefinitionsAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> id = const Value.absent(),
             Value<String> name = const Value.absent(),
@@ -6297,97 +6513,28 @@ class $HabitDefinitionsTableManager extends RootTableManager<
             active: active,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $HabitDefinitionsFilterComposer
-    extends FilterComposer<_$JournalDb, HabitDefinitions> {
-  $HabitDefinitionsFilterComposer(super.$state);
-  ColumnFilters<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get name => $state.composableBuilder(
-      column: $state.table.name,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get deleted => $state.composableBuilder(
-      column: $state.table.deleted,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get private => $state.composableBuilder(
-      column: $state.table.private,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get active => $state.composableBuilder(
-      column: $state.table.active,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $HabitDefinitionsOrderingComposer
-    extends OrderingComposer<_$JournalDb, HabitDefinitions> {
-  $HabitDefinitionsOrderingComposer(super.$state);
-  ColumnOrderings<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get name => $state.composableBuilder(
-      column: $state.table.name,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get deleted => $state.composableBuilder(
-      column: $state.table.deleted,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get private => $state.composableBuilder(
-      column: $state.table.private,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get active => $state.composableBuilder(
-      column: $state.table.active,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
-
+typedef $HabitDefinitionsProcessedTableManager = ProcessedTableManager<
+    _$JournalDb,
+    HabitDefinitions,
+    HabitDefinitionDbEntity,
+    $HabitDefinitionsFilterComposer,
+    $HabitDefinitionsOrderingComposer,
+    $HabitDefinitionsAnnotationComposer,
+    $HabitDefinitionsCreateCompanionBuilder,
+    $HabitDefinitionsUpdateCompanionBuilder,
+    (
+      HabitDefinitionDbEntity,
+      BaseReferences<_$JournalDb, HabitDefinitions, HabitDefinitionDbEntity>
+    ),
+    HabitDefinitionDbEntity,
+    PrefetchHooks Function()>;
 typedef $CategoryDefinitionsCreateCompanionBuilder
     = CategoryDefinitionsCompanion Function({
   required String id,
@@ -6413,22 +6560,134 @@ typedef $CategoryDefinitionsUpdateCompanionBuilder
   Value<int> rowid,
 });
 
+class $CategoryDefinitionsFilterComposer
+    extends Composer<_$JournalDb, CategoryDefinitions> {
+  $CategoryDefinitionsFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get name => $composableBuilder(
+      column: $table.name, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get deleted => $composableBuilder(
+      column: $table.deleted, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get private => $composableBuilder(
+      column: $table.private, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get active => $composableBuilder(
+      column: $table.active, builder: (column) => ColumnFilters(column));
+}
+
+class $CategoryDefinitionsOrderingComposer
+    extends Composer<_$JournalDb, CategoryDefinitions> {
+  $CategoryDefinitionsOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get name => $composableBuilder(
+      column: $table.name, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get deleted => $composableBuilder(
+      column: $table.deleted, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get private => $composableBuilder(
+      column: $table.private, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get active => $composableBuilder(
+      column: $table.active, builder: (column) => ColumnOrderings(column));
+}
+
+class $CategoryDefinitionsAnnotationComposer
+    extends Composer<_$JournalDb, CategoryDefinitions> {
+  $CategoryDefinitionsAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<String> get name =>
+      $composableBuilder(column: $table.name, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get createdAt =>
+      $composableBuilder(column: $table.createdAt, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get updatedAt =>
+      $composableBuilder(column: $table.updatedAt, builder: (column) => column);
+
+  GeneratedColumn<bool> get deleted =>
+      $composableBuilder(column: $table.deleted, builder: (column) => column);
+
+  GeneratedColumn<bool> get private =>
+      $composableBuilder(column: $table.private, builder: (column) => column);
+
+  GeneratedColumn<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => column);
+
+  GeneratedColumn<bool> get active =>
+      $composableBuilder(column: $table.active, builder: (column) => column);
+}
+
 class $CategoryDefinitionsTableManager extends RootTableManager<
     _$JournalDb,
     CategoryDefinitions,
     CategoryDefinitionDbEntity,
     $CategoryDefinitionsFilterComposer,
     $CategoryDefinitionsOrderingComposer,
+    $CategoryDefinitionsAnnotationComposer,
     $CategoryDefinitionsCreateCompanionBuilder,
-    $CategoryDefinitionsUpdateCompanionBuilder> {
+    $CategoryDefinitionsUpdateCompanionBuilder,
+    (
+      CategoryDefinitionDbEntity,
+      BaseReferences<_$JournalDb, CategoryDefinitions,
+          CategoryDefinitionDbEntity>
+    ),
+    CategoryDefinitionDbEntity,
+    PrefetchHooks Function()> {
   $CategoryDefinitionsTableManager(_$JournalDb db, CategoryDefinitions table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer:
-              $CategoryDefinitionsFilterComposer(ComposerState(db, table)),
-          orderingComposer:
-              $CategoryDefinitionsOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $CategoryDefinitionsFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $CategoryDefinitionsOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $CategoryDefinitionsAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> id = const Value.absent(),
             Value<String> name = const Value.absent(),
@@ -6473,97 +6732,29 @@ class $CategoryDefinitionsTableManager extends RootTableManager<
             active: active,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $CategoryDefinitionsFilterComposer
-    extends FilterComposer<_$JournalDb, CategoryDefinitions> {
-  $CategoryDefinitionsFilterComposer(super.$state);
-  ColumnFilters<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get name => $state.composableBuilder(
-      column: $state.table.name,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get deleted => $state.composableBuilder(
-      column: $state.table.deleted,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get private => $state.composableBuilder(
-      column: $state.table.private,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get active => $state.composableBuilder(
-      column: $state.table.active,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $CategoryDefinitionsOrderingComposer
-    extends OrderingComposer<_$JournalDb, CategoryDefinitions> {
-  $CategoryDefinitionsOrderingComposer(super.$state);
-  ColumnOrderings<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get name => $state.composableBuilder(
-      column: $state.table.name,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get deleted => $state.composableBuilder(
-      column: $state.table.deleted,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get private => $state.composableBuilder(
-      column: $state.table.private,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get active => $state.composableBuilder(
-      column: $state.table.active,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
-
+typedef $CategoryDefinitionsProcessedTableManager = ProcessedTableManager<
+    _$JournalDb,
+    CategoryDefinitions,
+    CategoryDefinitionDbEntity,
+    $CategoryDefinitionsFilterComposer,
+    $CategoryDefinitionsOrderingComposer,
+    $CategoryDefinitionsAnnotationComposer,
+    $CategoryDefinitionsCreateCompanionBuilder,
+    $CategoryDefinitionsUpdateCompanionBuilder,
+    (
+      CategoryDefinitionDbEntity,
+      BaseReferences<_$JournalDb, CategoryDefinitions,
+          CategoryDefinitionDbEntity>
+    ),
+    CategoryDefinitionDbEntity,
+    PrefetchHooks Function()>;
 typedef $DashboardDefinitionsCreateCompanionBuilder
     = DashboardDefinitionsCompanion Function({
   required String id,
@@ -6591,22 +6782,144 @@ typedef $DashboardDefinitionsUpdateCompanionBuilder
   Value<int> rowid,
 });
 
+class $DashboardDefinitionsFilterComposer
+    extends Composer<_$JournalDb, DashboardDefinitions> {
+  $DashboardDefinitionsFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get name => $composableBuilder(
+      column: $table.name, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get lastReviewed => $composableBuilder(
+      column: $table.lastReviewed, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get deleted => $composableBuilder(
+      column: $table.deleted, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get private => $composableBuilder(
+      column: $table.private, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get active => $composableBuilder(
+      column: $table.active, builder: (column) => ColumnFilters(column));
+}
+
+class $DashboardDefinitionsOrderingComposer
+    extends Composer<_$JournalDb, DashboardDefinitions> {
+  $DashboardDefinitionsOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get name => $composableBuilder(
+      column: $table.name, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get lastReviewed => $composableBuilder(
+      column: $table.lastReviewed,
+      builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get deleted => $composableBuilder(
+      column: $table.deleted, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get private => $composableBuilder(
+      column: $table.private, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get active => $composableBuilder(
+      column: $table.active, builder: (column) => ColumnOrderings(column));
+}
+
+class $DashboardDefinitionsAnnotationComposer
+    extends Composer<_$JournalDb, DashboardDefinitions> {
+  $DashboardDefinitionsAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<String> get name =>
+      $composableBuilder(column: $table.name, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get createdAt =>
+      $composableBuilder(column: $table.createdAt, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get updatedAt =>
+      $composableBuilder(column: $table.updatedAt, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get lastReviewed => $composableBuilder(
+      column: $table.lastReviewed, builder: (column) => column);
+
+  GeneratedColumn<bool> get deleted =>
+      $composableBuilder(column: $table.deleted, builder: (column) => column);
+
+  GeneratedColumn<bool> get private =>
+      $composableBuilder(column: $table.private, builder: (column) => column);
+
+  GeneratedColumn<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => column);
+
+  GeneratedColumn<bool> get active =>
+      $composableBuilder(column: $table.active, builder: (column) => column);
+}
+
 class $DashboardDefinitionsTableManager extends RootTableManager<
     _$JournalDb,
     DashboardDefinitions,
     DashboardDefinitionDbEntity,
     $DashboardDefinitionsFilterComposer,
     $DashboardDefinitionsOrderingComposer,
+    $DashboardDefinitionsAnnotationComposer,
     $DashboardDefinitionsCreateCompanionBuilder,
-    $DashboardDefinitionsUpdateCompanionBuilder> {
+    $DashboardDefinitionsUpdateCompanionBuilder,
+    (
+      DashboardDefinitionDbEntity,
+      BaseReferences<_$JournalDb, DashboardDefinitions,
+          DashboardDefinitionDbEntity>
+    ),
+    DashboardDefinitionDbEntity,
+    PrefetchHooks Function()> {
   $DashboardDefinitionsTableManager(_$JournalDb db, DashboardDefinitions table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer:
-              $DashboardDefinitionsFilterComposer(ComposerState(db, table)),
-          orderingComposer:
-              $DashboardDefinitionsOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $DashboardDefinitionsFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $DashboardDefinitionsOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $DashboardDefinitionsAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> id = const Value.absent(),
             Value<String> name = const Value.absent(),
@@ -6655,107 +6968,29 @@ class $DashboardDefinitionsTableManager extends RootTableManager<
             active: active,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $DashboardDefinitionsFilterComposer
-    extends FilterComposer<_$JournalDb, DashboardDefinitions> {
-  $DashboardDefinitionsFilterComposer(super.$state);
-  ColumnFilters<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get name => $state.composableBuilder(
-      column: $state.table.name,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get lastReviewed => $state.composableBuilder(
-      column: $state.table.lastReviewed,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get deleted => $state.composableBuilder(
-      column: $state.table.deleted,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get private => $state.composableBuilder(
-      column: $state.table.private,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get active => $state.composableBuilder(
-      column: $state.table.active,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $DashboardDefinitionsOrderingComposer
-    extends OrderingComposer<_$JournalDb, DashboardDefinitions> {
-  $DashboardDefinitionsOrderingComposer(super.$state);
-  ColumnOrderings<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get name => $state.composableBuilder(
-      column: $state.table.name,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get lastReviewed => $state.composableBuilder(
-      column: $state.table.lastReviewed,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get deleted => $state.composableBuilder(
-      column: $state.table.deleted,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get private => $state.composableBuilder(
-      column: $state.table.private,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get active => $state.composableBuilder(
-      column: $state.table.active,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
-
+typedef $DashboardDefinitionsProcessedTableManager = ProcessedTableManager<
+    _$JournalDb,
+    DashboardDefinitions,
+    DashboardDefinitionDbEntity,
+    $DashboardDefinitionsFilterComposer,
+    $DashboardDefinitionsOrderingComposer,
+    $DashboardDefinitionsAnnotationComposer,
+    $DashboardDefinitionsCreateCompanionBuilder,
+    $DashboardDefinitionsUpdateCompanionBuilder,
+    (
+      DashboardDefinitionDbEntity,
+      BaseReferences<_$JournalDb, DashboardDefinitions,
+          DashboardDefinitionDbEntity>
+    ),
+    DashboardDefinitionDbEntity,
+    PrefetchHooks Function()>;
 typedef $ConfigFlagsCreateCompanionBuilder = ConfigFlagsCompanion Function({
   required String name,
   required String description,
@@ -6769,22 +7004,83 @@ typedef $ConfigFlagsUpdateCompanionBuilder = ConfigFlagsCompanion Function({
   Value<int> rowid,
 });
 
+class $ConfigFlagsFilterComposer extends Composer<_$JournalDb, ConfigFlags> {
+  $ConfigFlagsFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get name => $composableBuilder(
+      column: $table.name, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get description => $composableBuilder(
+      column: $table.description, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get status => $composableBuilder(
+      column: $table.status, builder: (column) => ColumnFilters(column));
+}
+
+class $ConfigFlagsOrderingComposer extends Composer<_$JournalDb, ConfigFlags> {
+  $ConfigFlagsOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get name => $composableBuilder(
+      column: $table.name, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get description => $composableBuilder(
+      column: $table.description, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get status => $composableBuilder(
+      column: $table.status, builder: (column) => ColumnOrderings(column));
+}
+
+class $ConfigFlagsAnnotationComposer
+    extends Composer<_$JournalDb, ConfigFlags> {
+  $ConfigFlagsAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get name =>
+      $composableBuilder(column: $table.name, builder: (column) => column);
+
+  GeneratedColumn<String> get description => $composableBuilder(
+      column: $table.description, builder: (column) => column);
+
+  GeneratedColumn<bool> get status =>
+      $composableBuilder(column: $table.status, builder: (column) => column);
+}
+
 class $ConfigFlagsTableManager extends RootTableManager<
     _$JournalDb,
     ConfigFlags,
     ConfigFlag,
     $ConfigFlagsFilterComposer,
     $ConfigFlagsOrderingComposer,
+    $ConfigFlagsAnnotationComposer,
     $ConfigFlagsCreateCompanionBuilder,
-    $ConfigFlagsUpdateCompanionBuilder> {
+    $ConfigFlagsUpdateCompanionBuilder,
+    (ConfigFlag, BaseReferences<_$JournalDb, ConfigFlags, ConfigFlag>),
+    ConfigFlag,
+    PrefetchHooks Function()> {
   $ConfigFlagsTableManager(_$JournalDb db, ConfigFlags table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer:
-              $ConfigFlagsFilterComposer(ComposerState(db, table)),
-          orderingComposer:
-              $ConfigFlagsOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $ConfigFlagsFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $ConfigFlagsOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $ConfigFlagsAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> name = const Value.absent(),
             Value<String> description = const Value.absent(),
@@ -6809,47 +7105,25 @@ class $ConfigFlagsTableManager extends RootTableManager<
             status: status,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $ConfigFlagsFilterComposer
-    extends FilterComposer<_$JournalDb, ConfigFlags> {
-  $ConfigFlagsFilterComposer(super.$state);
-  ColumnFilters<String> get name => $state.composableBuilder(
-      column: $state.table.name,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get description => $state.composableBuilder(
-      column: $state.table.description,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get status => $state.composableBuilder(
-      column: $state.table.status,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $ConfigFlagsOrderingComposer
-    extends OrderingComposer<_$JournalDb, ConfigFlags> {
-  $ConfigFlagsOrderingComposer(super.$state);
-  ColumnOrderings<String> get name => $state.composableBuilder(
-      column: $state.table.name,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get description => $state.composableBuilder(
-      column: $state.table.description,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get status => $state.composableBuilder(
-      column: $state.table.status,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
-
+typedef $ConfigFlagsProcessedTableManager = ProcessedTableManager<
+    _$JournalDb,
+    ConfigFlags,
+    ConfigFlag,
+    $ConfigFlagsFilterComposer,
+    $ConfigFlagsOrderingComposer,
+    $ConfigFlagsAnnotationComposer,
+    $ConfigFlagsCreateCompanionBuilder,
+    $ConfigFlagsUpdateCompanionBuilder,
+    (ConfigFlag, BaseReferences<_$JournalDb, ConfigFlags, ConfigFlag>),
+    ConfigFlag,
+    PrefetchHooks Function()>;
 typedef $TagEntitiesCreateCompanionBuilder = TagEntitiesCompanion Function({
   required String id,
   required String tag,
@@ -6875,22 +7149,137 @@ typedef $TagEntitiesUpdateCompanionBuilder = TagEntitiesCompanion Function({
   Value<int> rowid,
 });
 
+class $TagEntitiesFilterComposer extends Composer<_$JournalDb, TagEntities> {
+  $TagEntitiesFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get tag => $composableBuilder(
+      column: $table.tag, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get type => $composableBuilder(
+      column: $table.type, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get inactive => $composableBuilder(
+      column: $table.inactive, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get private => $composableBuilder(
+      column: $table.private, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<bool> get deleted => $composableBuilder(
+      column: $table.deleted, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnFilters(column));
+}
+
+class $TagEntitiesOrderingComposer extends Composer<_$JournalDb, TagEntities> {
+  $TagEntitiesOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get tag => $composableBuilder(
+      column: $table.tag, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get type => $composableBuilder(
+      column: $table.type, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get inactive => $composableBuilder(
+      column: $table.inactive, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get private => $composableBuilder(
+      column: $table.private, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<bool> get deleted => $composableBuilder(
+      column: $table.deleted, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnOrderings(column));
+}
+
+class $TagEntitiesAnnotationComposer
+    extends Composer<_$JournalDb, TagEntities> {
+  $TagEntitiesAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<String> get tag =>
+      $composableBuilder(column: $table.tag, builder: (column) => column);
+
+  GeneratedColumn<String> get type =>
+      $composableBuilder(column: $table.type, builder: (column) => column);
+
+  GeneratedColumn<bool> get inactive =>
+      $composableBuilder(column: $table.inactive, builder: (column) => column);
+
+  GeneratedColumn<bool> get private =>
+      $composableBuilder(column: $table.private, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get createdAt =>
+      $composableBuilder(column: $table.createdAt, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get updatedAt =>
+      $composableBuilder(column: $table.updatedAt, builder: (column) => column);
+
+  GeneratedColumn<bool> get deleted =>
+      $composableBuilder(column: $table.deleted, builder: (column) => column);
+
+  GeneratedColumn<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => column);
+}
+
 class $TagEntitiesTableManager extends RootTableManager<
     _$JournalDb,
     TagEntities,
     TagDbEntity,
     $TagEntitiesFilterComposer,
     $TagEntitiesOrderingComposer,
+    $TagEntitiesAnnotationComposer,
     $TagEntitiesCreateCompanionBuilder,
-    $TagEntitiesUpdateCompanionBuilder> {
+    $TagEntitiesUpdateCompanionBuilder,
+    (TagDbEntity, BaseReferences<_$JournalDb, TagEntities, TagDbEntity>),
+    TagDbEntity,
+    PrefetchHooks Function()> {
   $TagEntitiesTableManager(_$JournalDb db, TagEntities table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer:
-              $TagEntitiesFilterComposer(ComposerState(db, table)),
-          orderingComposer:
-              $TagEntitiesOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $TagEntitiesFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $TagEntitiesOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $TagEntitiesAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> id = const Value.absent(),
             Value<String> tag = const Value.absent(),
@@ -6939,107 +7328,25 @@ class $TagEntitiesTableManager extends RootTableManager<
             serialized: serialized,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $TagEntitiesFilterComposer
-    extends FilterComposer<_$JournalDb, TagEntities> {
-  $TagEntitiesFilterComposer(super.$state);
-  ColumnFilters<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get tag => $state.composableBuilder(
-      column: $state.table.tag,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get type => $state.composableBuilder(
-      column: $state.table.type,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get inactive => $state.composableBuilder(
-      column: $state.table.inactive,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get private => $state.composableBuilder(
-      column: $state.table.private,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<bool> get deleted => $state.composableBuilder(
-      column: $state.table.deleted,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $TagEntitiesOrderingComposer
-    extends OrderingComposer<_$JournalDb, TagEntities> {
-  $TagEntitiesOrderingComposer(super.$state);
-  ColumnOrderings<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get tag => $state.composableBuilder(
-      column: $state.table.tag,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get type => $state.composableBuilder(
-      column: $state.table.type,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get inactive => $state.composableBuilder(
-      column: $state.table.inactive,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get private => $state.composableBuilder(
-      column: $state.table.private,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<bool> get deleted => $state.composableBuilder(
-      column: $state.table.deleted,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
-
+typedef $TagEntitiesProcessedTableManager = ProcessedTableManager<
+    _$JournalDb,
+    TagEntities,
+    TagDbEntity,
+    $TagEntitiesFilterComposer,
+    $TagEntitiesOrderingComposer,
+    $TagEntitiesAnnotationComposer,
+    $TagEntitiesCreateCompanionBuilder,
+    $TagEntitiesUpdateCompanionBuilder,
+    (TagDbEntity, BaseReferences<_$JournalDb, TagEntities, TagDbEntity>),
+    TagDbEntity,
+    PrefetchHooks Function()>;
 typedef $TaggedCreateCompanionBuilder = TaggedCompanion Function({
   required String id,
   required String journalId,
@@ -7053,20 +7360,82 @@ typedef $TaggedUpdateCompanionBuilder = TaggedCompanion Function({
   Value<int> rowid,
 });
 
+class $TaggedFilterComposer extends Composer<_$JournalDb, Tagged> {
+  $TaggedFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get journalId => $composableBuilder(
+      column: $table.journalId, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get tagEntityId => $composableBuilder(
+      column: $table.tagEntityId, builder: (column) => ColumnFilters(column));
+}
+
+class $TaggedOrderingComposer extends Composer<_$JournalDb, Tagged> {
+  $TaggedOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get journalId => $composableBuilder(
+      column: $table.journalId, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get tagEntityId => $composableBuilder(
+      column: $table.tagEntityId, builder: (column) => ColumnOrderings(column));
+}
+
+class $TaggedAnnotationComposer extends Composer<_$JournalDb, Tagged> {
+  $TaggedAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<String> get journalId =>
+      $composableBuilder(column: $table.journalId, builder: (column) => column);
+
+  GeneratedColumn<String> get tagEntityId => $composableBuilder(
+      column: $table.tagEntityId, builder: (column) => column);
+}
+
 class $TaggedTableManager extends RootTableManager<
     _$JournalDb,
     Tagged,
     TaggedWith,
     $TaggedFilterComposer,
     $TaggedOrderingComposer,
+    $TaggedAnnotationComposer,
     $TaggedCreateCompanionBuilder,
-    $TaggedUpdateCompanionBuilder> {
+    $TaggedUpdateCompanionBuilder,
+    (TaggedWith, BaseReferences<_$JournalDb, Tagged, TaggedWith>),
+    TaggedWith,
+    PrefetchHooks Function()> {
   $TaggedTableManager(_$JournalDb db, Tagged table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer: $TaggedFilterComposer(ComposerState(db, table)),
-          orderingComposer: $TaggedOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $TaggedFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $TaggedOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $TaggedAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> id = const Value.absent(),
             Value<String> journalId = const Value.absent(),
@@ -7091,45 +7460,25 @@ class $TaggedTableManager extends RootTableManager<
             tagEntityId: tagEntityId,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $TaggedFilterComposer extends FilterComposer<_$JournalDb, Tagged> {
-  $TaggedFilterComposer(super.$state);
-  ColumnFilters<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get journalId => $state.composableBuilder(
-      column: $state.table.journalId,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get tagEntityId => $state.composableBuilder(
-      column: $state.table.tagEntityId,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $TaggedOrderingComposer extends OrderingComposer<_$JournalDb, Tagged> {
-  $TaggedOrderingComposer(super.$state);
-  ColumnOrderings<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get journalId => $state.composableBuilder(
-      column: $state.table.journalId,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get tagEntityId => $state.composableBuilder(
-      column: $state.table.tagEntityId,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
-
+typedef $TaggedProcessedTableManager = ProcessedTableManager<
+    _$JournalDb,
+    Tagged,
+    TaggedWith,
+    $TaggedFilterComposer,
+    $TaggedOrderingComposer,
+    $TaggedAnnotationComposer,
+    $TaggedCreateCompanionBuilder,
+    $TaggedUpdateCompanionBuilder,
+    (TaggedWith, BaseReferences<_$JournalDb, Tagged, TaggedWith>),
+    TaggedWith,
+    PrefetchHooks Function()>;
 typedef $LinkedEntriesCreateCompanionBuilder = LinkedEntriesCompanion Function({
   required String id,
   required String fromId,
@@ -7147,22 +7496,103 @@ typedef $LinkedEntriesUpdateCompanionBuilder = LinkedEntriesCompanion Function({
   Value<int> rowid,
 });
 
+class $LinkedEntriesFilterComposer
+    extends Composer<_$JournalDb, LinkedEntries> {
+  $LinkedEntriesFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get fromId => $composableBuilder(
+      column: $table.fromId, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get toId => $composableBuilder(
+      column: $table.toId, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get type => $composableBuilder(
+      column: $table.type, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnFilters(column));
+}
+
+class $LinkedEntriesOrderingComposer
+    extends Composer<_$JournalDb, LinkedEntries> {
+  $LinkedEntriesOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get fromId => $composableBuilder(
+      column: $table.fromId, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get toId => $composableBuilder(
+      column: $table.toId, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get type => $composableBuilder(
+      column: $table.type, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => ColumnOrderings(column));
+}
+
+class $LinkedEntriesAnnotationComposer
+    extends Composer<_$JournalDb, LinkedEntries> {
+  $LinkedEntriesAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<String> get fromId =>
+      $composableBuilder(column: $table.fromId, builder: (column) => column);
+
+  GeneratedColumn<String> get toId =>
+      $composableBuilder(column: $table.toId, builder: (column) => column);
+
+  GeneratedColumn<String> get type =>
+      $composableBuilder(column: $table.type, builder: (column) => column);
+
+  GeneratedColumn<String> get serialized => $composableBuilder(
+      column: $table.serialized, builder: (column) => column);
+}
+
 class $LinkedEntriesTableManager extends RootTableManager<
     _$JournalDb,
     LinkedEntries,
     LinkedDbEntry,
     $LinkedEntriesFilterComposer,
     $LinkedEntriesOrderingComposer,
+    $LinkedEntriesAnnotationComposer,
     $LinkedEntriesCreateCompanionBuilder,
-    $LinkedEntriesUpdateCompanionBuilder> {
+    $LinkedEntriesUpdateCompanionBuilder,
+    (LinkedDbEntry, BaseReferences<_$JournalDb, LinkedEntries, LinkedDbEntry>),
+    LinkedDbEntry,
+    PrefetchHooks Function()> {
   $LinkedEntriesTableManager(_$JournalDb db, LinkedEntries table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer:
-              $LinkedEntriesFilterComposer(ComposerState(db, table)),
-          orderingComposer:
-              $LinkedEntriesOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $LinkedEntriesFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $LinkedEntriesOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $LinkedEntriesAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> id = const Value.absent(),
             Value<String> fromId = const Value.absent(),
@@ -7195,66 +7625,25 @@ class $LinkedEntriesTableManager extends RootTableManager<
             serialized: serialized,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $LinkedEntriesFilterComposer
-    extends FilterComposer<_$JournalDb, LinkedEntries> {
-  $LinkedEntriesFilterComposer(super.$state);
-  ColumnFilters<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get fromId => $state.composableBuilder(
-      column: $state.table.fromId,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get toId => $state.composableBuilder(
-      column: $state.table.toId,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get type => $state.composableBuilder(
-      column: $state.table.type,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $LinkedEntriesOrderingComposer
-    extends OrderingComposer<_$JournalDb, LinkedEntries> {
-  $LinkedEntriesOrderingComposer(super.$state);
-  ColumnOrderings<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get fromId => $state.composableBuilder(
-      column: $state.table.fromId,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get toId => $state.composableBuilder(
-      column: $state.table.toId,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get type => $state.composableBuilder(
-      column: $state.table.type,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get serialized => $state.composableBuilder(
-      column: $state.table.serialized,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
+typedef $LinkedEntriesProcessedTableManager = ProcessedTableManager<
+    _$JournalDb,
+    LinkedEntries,
+    LinkedDbEntry,
+    $LinkedEntriesFilterComposer,
+    $LinkedEntriesOrderingComposer,
+    $LinkedEntriesAnnotationComposer,
+    $LinkedEntriesCreateCompanionBuilder,
+    $LinkedEntriesUpdateCompanionBuilder,
+    (LinkedDbEntry, BaseReferences<_$JournalDb, LinkedEntries, LinkedDbEntry>),
+    LinkedDbEntry,
+    PrefetchHooks Function()>;
 
 class $JournalDbManager {
   final _$JournalDb _db;
diff --git a/lib/database/editor_db.g.dart b/lib/database/editor_db.g.dart
index 8fc2eb32b..6e19d51bc 100644
--- a/lib/database/editor_db.g.dart
+++ b/lib/database/editor_db.g.dart
@@ -426,22 +426,113 @@ typedef $EditorDraftsUpdateCompanionBuilder = EditorDraftsCompanion Function({
   Value<int> rowid,
 });
 
+class $EditorDraftsFilterComposer extends Composer<_$EditorDb, EditorDrafts> {
+  $EditorDraftsFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get entryId => $composableBuilder(
+      column: $table.entryId, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get status => $composableBuilder(
+      column: $table.status, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get lastSaved => $composableBuilder(
+      column: $table.lastSaved, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get delta => $composableBuilder(
+      column: $table.delta, builder: (column) => ColumnFilters(column));
+}
+
+class $EditorDraftsOrderingComposer extends Composer<_$EditorDb, EditorDrafts> {
+  $EditorDraftsOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get entryId => $composableBuilder(
+      column: $table.entryId, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get status => $composableBuilder(
+      column: $table.status, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get lastSaved => $composableBuilder(
+      column: $table.lastSaved, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get delta => $composableBuilder(
+      column: $table.delta, builder: (column) => ColumnOrderings(column));
+}
+
+class $EditorDraftsAnnotationComposer
+    extends Composer<_$EditorDb, EditorDrafts> {
+  $EditorDraftsAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<String> get entryId =>
+      $composableBuilder(column: $table.entryId, builder: (column) => column);
+
+  GeneratedColumn<String> get status =>
+      $composableBuilder(column: $table.status, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get createdAt =>
+      $composableBuilder(column: $table.createdAt, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get lastSaved =>
+      $composableBuilder(column: $table.lastSaved, builder: (column) => column);
+
+  GeneratedColumn<String> get delta =>
+      $composableBuilder(column: $table.delta, builder: (column) => column);
+}
+
 class $EditorDraftsTableManager extends RootTableManager<
     _$EditorDb,
     EditorDrafts,
     EditorDraftState,
     $EditorDraftsFilterComposer,
     $EditorDraftsOrderingComposer,
+    $EditorDraftsAnnotationComposer,
     $EditorDraftsCreateCompanionBuilder,
-    $EditorDraftsUpdateCompanionBuilder> {
+    $EditorDraftsUpdateCompanionBuilder,
+    (
+      EditorDraftState,
+      BaseReferences<_$EditorDb, EditorDrafts, EditorDraftState>
+    ),
+    EditorDraftState,
+    PrefetchHooks Function()> {
   $EditorDraftsTableManager(_$EditorDb db, EditorDrafts table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer:
-              $EditorDraftsFilterComposer(ComposerState(db, table)),
-          orderingComposer:
-              $EditorDraftsOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $EditorDraftsFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $EditorDraftsOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $EditorDraftsAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> id = const Value.absent(),
             Value<String> entryId = const Value.absent(),
@@ -478,76 +569,28 @@ class $EditorDraftsTableManager extends RootTableManager<
             delta: delta,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $EditorDraftsFilterComposer
-    extends FilterComposer<_$EditorDb, EditorDrafts> {
-  $EditorDraftsFilterComposer(super.$state);
-  ColumnFilters<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get entryId => $state.composableBuilder(
-      column: $state.table.entryId,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get status => $state.composableBuilder(
-      column: $state.table.status,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get lastSaved => $state.composableBuilder(
-      column: $state.table.lastSaved,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get delta => $state.composableBuilder(
-      column: $state.table.delta,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $EditorDraftsOrderingComposer
-    extends OrderingComposer<_$EditorDb, EditorDrafts> {
-  $EditorDraftsOrderingComposer(super.$state);
-  ColumnOrderings<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get entryId => $state.composableBuilder(
-      column: $state.table.entryId,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get status => $state.composableBuilder(
-      column: $state.table.status,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get lastSaved => $state.composableBuilder(
-      column: $state.table.lastSaved,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get delta => $state.composableBuilder(
-      column: $state.table.delta,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
+typedef $EditorDraftsProcessedTableManager = ProcessedTableManager<
+    _$EditorDb,
+    EditorDrafts,
+    EditorDraftState,
+    $EditorDraftsFilterComposer,
+    $EditorDraftsOrderingComposer,
+    $EditorDraftsAnnotationComposer,
+    $EditorDraftsCreateCompanionBuilder,
+    $EditorDraftsUpdateCompanionBuilder,
+    (
+      EditorDraftState,
+      BaseReferences<_$EditorDb, EditorDrafts, EditorDraftState>
+    ),
+    EditorDraftState,
+    PrefetchHooks Function()>;
 
 class $EditorDbManager {
   final _$EditorDb _db;
diff --git a/lib/database/fts5_db.g.dart b/lib/database/fts5_db.g.dart
index 2aada05c0..5ee820f1e 100644
--- a/lib/database/fts5_db.g.dart
+++ b/lib/database/fts5_db.g.dart
@@ -386,22 +386,100 @@ typedef $JournalFtsUpdateCompanionBuilder = JournalFtsCompanion Function({
   Value<int> rowid,
 });
 
+class $JournalFtsFilterComposer extends Composer<_$Fts5Db, JournalFts> {
+  $JournalFtsFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get plainText => $composableBuilder(
+      column: $table.plainText, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get title => $composableBuilder(
+      column: $table.title, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get summary => $composableBuilder(
+      column: $table.summary, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get tags => $composableBuilder(
+      column: $table.tags, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get uuid => $composableBuilder(
+      column: $table.uuid, builder: (column) => ColumnFilters(column));
+}
+
+class $JournalFtsOrderingComposer extends Composer<_$Fts5Db, JournalFts> {
+  $JournalFtsOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get plainText => $composableBuilder(
+      column: $table.plainText, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get title => $composableBuilder(
+      column: $table.title, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get summary => $composableBuilder(
+      column: $table.summary, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get tags => $composableBuilder(
+      column: $table.tags, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get uuid => $composableBuilder(
+      column: $table.uuid, builder: (column) => ColumnOrderings(column));
+}
+
+class $JournalFtsAnnotationComposer extends Composer<_$Fts5Db, JournalFts> {
+  $JournalFtsAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get plainText =>
+      $composableBuilder(column: $table.plainText, builder: (column) => column);
+
+  GeneratedColumn<String> get title =>
+      $composableBuilder(column: $table.title, builder: (column) => column);
+
+  GeneratedColumn<String> get summary =>
+      $composableBuilder(column: $table.summary, builder: (column) => column);
+
+  GeneratedColumn<String> get tags =>
+      $composableBuilder(column: $table.tags, builder: (column) => column);
+
+  GeneratedColumn<String> get uuid =>
+      $composableBuilder(column: $table.uuid, builder: (column) => column);
+}
+
 class $JournalFtsTableManager extends RootTableManager<
     _$Fts5Db,
     JournalFts,
     JournalFt,
     $JournalFtsFilterComposer,
     $JournalFtsOrderingComposer,
+    $JournalFtsAnnotationComposer,
     $JournalFtsCreateCompanionBuilder,
-    $JournalFtsUpdateCompanionBuilder> {
+    $JournalFtsUpdateCompanionBuilder,
+    (JournalFt, BaseReferences<_$Fts5Db, JournalFts, JournalFt>),
+    JournalFt,
+    PrefetchHooks Function()> {
   $JournalFtsTableManager(_$Fts5Db db, JournalFts table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer:
-              $JournalFtsFilterComposer(ComposerState(db, table)),
-          orderingComposer:
-              $JournalFtsOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $JournalFtsFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $JournalFtsOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $JournalFtsAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> plainText = const Value.absent(),
             Value<String> title = const Value.absent(),
@@ -434,65 +512,25 @@ class $JournalFtsTableManager extends RootTableManager<
             uuid: uuid,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $JournalFtsFilterComposer extends FilterComposer<_$Fts5Db, JournalFts> {
-  $JournalFtsFilterComposer(super.$state);
-  ColumnFilters<String> get plainText => $state.composableBuilder(
-      column: $state.table.plainText,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get title => $state.composableBuilder(
-      column: $state.table.title,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get summary => $state.composableBuilder(
-      column: $state.table.summary,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get tags => $state.composableBuilder(
-      column: $state.table.tags,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get uuid => $state.composableBuilder(
-      column: $state.table.uuid,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $JournalFtsOrderingComposer
-    extends OrderingComposer<_$Fts5Db, JournalFts> {
-  $JournalFtsOrderingComposer(super.$state);
-  ColumnOrderings<String> get plainText => $state.composableBuilder(
-      column: $state.table.plainText,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get title => $state.composableBuilder(
-      column: $state.table.title,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get summary => $state.composableBuilder(
-      column: $state.table.summary,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get tags => $state.composableBuilder(
-      column: $state.table.tags,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get uuid => $state.composableBuilder(
-      column: $state.table.uuid,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
+typedef $JournalFtsProcessedTableManager = ProcessedTableManager<
+    _$Fts5Db,
+    JournalFts,
+    JournalFt,
+    $JournalFtsFilterComposer,
+    $JournalFtsOrderingComposer,
+    $JournalFtsAnnotationComposer,
+    $JournalFtsCreateCompanionBuilder,
+    $JournalFtsUpdateCompanionBuilder,
+    (JournalFt, BaseReferences<_$Fts5Db, JournalFts, JournalFt>),
+    JournalFt,
+    PrefetchHooks Function()>;
 
 class $Fts5DbManager {
   final _$Fts5Db _db;
diff --git a/lib/database/logging_db.g.dart b/lib/database/logging_db.g.dart
index 4ccb3a0ea..83e80e250 100644
--- a/lib/database/logging_db.g.dart
+++ b/lib/database/logging_db.g.dart
@@ -568,22 +568,136 @@ typedef $LogEntriesUpdateCompanionBuilder = LogEntriesCompanion Function({
   Value<int> rowid,
 });
 
+class $LogEntriesFilterComposer extends Composer<_$LoggingDb, LogEntries> {
+  $LogEntriesFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get domain => $composableBuilder(
+      column: $table.domain, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get subDomain => $composableBuilder(
+      column: $table.subDomain, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get type => $composableBuilder(
+      column: $table.type, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get level => $composableBuilder(
+      column: $table.level, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get message => $composableBuilder(
+      column: $table.message, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get stacktrace => $composableBuilder(
+      column: $table.stacktrace, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get data => $composableBuilder(
+      column: $table.data, builder: (column) => ColumnFilters(column));
+}
+
+class $LogEntriesOrderingComposer extends Composer<_$LoggingDb, LogEntries> {
+  $LogEntriesOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get domain => $composableBuilder(
+      column: $table.domain, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get subDomain => $composableBuilder(
+      column: $table.subDomain, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get type => $composableBuilder(
+      column: $table.type, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get level => $composableBuilder(
+      column: $table.level, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get message => $composableBuilder(
+      column: $table.message, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get stacktrace => $composableBuilder(
+      column: $table.stacktrace, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get data => $composableBuilder(
+      column: $table.data, builder: (column) => ColumnOrderings(column));
+}
+
+class $LogEntriesAnnotationComposer extends Composer<_$LoggingDb, LogEntries> {
+  $LogEntriesAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<String> get createdAt =>
+      $composableBuilder(column: $table.createdAt, builder: (column) => column);
+
+  GeneratedColumn<String> get domain =>
+      $composableBuilder(column: $table.domain, builder: (column) => column);
+
+  GeneratedColumn<String> get subDomain =>
+      $composableBuilder(column: $table.subDomain, builder: (column) => column);
+
+  GeneratedColumn<String> get type =>
+      $composableBuilder(column: $table.type, builder: (column) => column);
+
+  GeneratedColumn<String> get level =>
+      $composableBuilder(column: $table.level, builder: (column) => column);
+
+  GeneratedColumn<String> get message =>
+      $composableBuilder(column: $table.message, builder: (column) => column);
+
+  GeneratedColumn<String> get stacktrace => $composableBuilder(
+      column: $table.stacktrace, builder: (column) => column);
+
+  GeneratedColumn<String> get data =>
+      $composableBuilder(column: $table.data, builder: (column) => column);
+}
+
 class $LogEntriesTableManager extends RootTableManager<
     _$LoggingDb,
     LogEntries,
     LogEntry,
     $LogEntriesFilterComposer,
     $LogEntriesOrderingComposer,
+    $LogEntriesAnnotationComposer,
     $LogEntriesCreateCompanionBuilder,
-    $LogEntriesUpdateCompanionBuilder> {
+    $LogEntriesUpdateCompanionBuilder,
+    (LogEntry, BaseReferences<_$LoggingDb, LogEntries, LogEntry>),
+    LogEntry,
+    PrefetchHooks Function()> {
   $LogEntriesTableManager(_$LoggingDb db, LogEntries table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer:
-              $LogEntriesFilterComposer(ComposerState(db, table)),
-          orderingComposer:
-              $LogEntriesOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $LogEntriesFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $LogEntriesOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $LogEntriesAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> id = const Value.absent(),
             Value<String> createdAt = const Value.absent(),
@@ -632,106 +746,25 @@ class $LogEntriesTableManager extends RootTableManager<
             data: data,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $LogEntriesFilterComposer
-    extends FilterComposer<_$LoggingDb, LogEntries> {
-  $LogEntriesFilterComposer(super.$state);
-  ColumnFilters<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get domain => $state.composableBuilder(
-      column: $state.table.domain,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get subDomain => $state.composableBuilder(
-      column: $state.table.subDomain,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get type => $state.composableBuilder(
-      column: $state.table.type,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get level => $state.composableBuilder(
-      column: $state.table.level,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get message => $state.composableBuilder(
-      column: $state.table.message,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get stacktrace => $state.composableBuilder(
-      column: $state.table.stacktrace,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get data => $state.composableBuilder(
-      column: $state.table.data,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $LogEntriesOrderingComposer
-    extends OrderingComposer<_$LoggingDb, LogEntries> {
-  $LogEntriesOrderingComposer(super.$state);
-  ColumnOrderings<String> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get domain => $state.composableBuilder(
-      column: $state.table.domain,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get subDomain => $state.composableBuilder(
-      column: $state.table.subDomain,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get type => $state.composableBuilder(
-      column: $state.table.type,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get level => $state.composableBuilder(
-      column: $state.table.level,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get message => $state.composableBuilder(
-      column: $state.table.message,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get stacktrace => $state.composableBuilder(
-      column: $state.table.stacktrace,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get data => $state.composableBuilder(
-      column: $state.table.data,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
+typedef $LogEntriesProcessedTableManager = ProcessedTableManager<
+    _$LoggingDb,
+    LogEntries,
+    LogEntry,
+    $LogEntriesFilterComposer,
+    $LogEntriesOrderingComposer,
+    $LogEntriesAnnotationComposer,
+    $LogEntriesCreateCompanionBuilder,
+    $LogEntriesUpdateCompanionBuilder,
+    (LogEntry, BaseReferences<_$LoggingDb, LogEntries, LogEntry>),
+    LogEntry,
+    PrefetchHooks Function()>;
 
 class $LoggingDbManager {
   final _$LoggingDb _db;
diff --git a/lib/database/settings_db.g.dart b/lib/database/settings_db.g.dart
index 29182b704..69d47e375 100644
--- a/lib/database/settings_db.g.dart
+++ b/lib/database/settings_db.g.dart
@@ -276,20 +276,82 @@ typedef $SettingsUpdateCompanionBuilder = SettingsCompanion Function({
   Value<int> rowid,
 });
 
+class $SettingsFilterComposer extends Composer<_$SettingsDb, Settings> {
+  $SettingsFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get configKey => $composableBuilder(
+      column: $table.configKey, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get value => $composableBuilder(
+      column: $table.value, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnFilters(column));
+}
+
+class $SettingsOrderingComposer extends Composer<_$SettingsDb, Settings> {
+  $SettingsOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get configKey => $composableBuilder(
+      column: $table.configKey, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get value => $composableBuilder(
+      column: $table.value, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnOrderings(column));
+}
+
+class $SettingsAnnotationComposer extends Composer<_$SettingsDb, Settings> {
+  $SettingsAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get configKey =>
+      $composableBuilder(column: $table.configKey, builder: (column) => column);
+
+  GeneratedColumn<String> get value =>
+      $composableBuilder(column: $table.value, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get updatedAt =>
+      $composableBuilder(column: $table.updatedAt, builder: (column) => column);
+}
+
 class $SettingsTableManager extends RootTableManager<
     _$SettingsDb,
     Settings,
     SettingsItem,
     $SettingsFilterComposer,
     $SettingsOrderingComposer,
+    $SettingsAnnotationComposer,
     $SettingsCreateCompanionBuilder,
-    $SettingsUpdateCompanionBuilder> {
+    $SettingsUpdateCompanionBuilder,
+    (SettingsItem, BaseReferences<_$SettingsDb, Settings, SettingsItem>),
+    SettingsItem,
+    PrefetchHooks Function()> {
   $SettingsTableManager(_$SettingsDb db, Settings table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer: $SettingsFilterComposer(ComposerState(db, table)),
-          orderingComposer: $SettingsOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $SettingsFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $SettingsOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $SettingsAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<String> configKey = const Value.absent(),
             Value<String> value = const Value.absent(),
@@ -314,45 +376,25 @@ class $SettingsTableManager extends RootTableManager<
             updatedAt: updatedAt,
             rowid: rowid,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $SettingsFilterComposer extends FilterComposer<_$SettingsDb, Settings> {
-  $SettingsFilterComposer(super.$state);
-  ColumnFilters<String> get configKey => $state.composableBuilder(
-      column: $state.table.configKey,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get value => $state.composableBuilder(
-      column: $state.table.value,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $SettingsOrderingComposer
-    extends OrderingComposer<_$SettingsDb, Settings> {
-  $SettingsOrderingComposer(super.$state);
-  ColumnOrderings<String> get configKey => $state.composableBuilder(
-      column: $state.table.configKey,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get value => $state.composableBuilder(
-      column: $state.table.value,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
+typedef $SettingsProcessedTableManager = ProcessedTableManager<
+    _$SettingsDb,
+    Settings,
+    SettingsItem,
+    $SettingsFilterComposer,
+    $SettingsOrderingComposer,
+    $SettingsAnnotationComposer,
+    $SettingsCreateCompanionBuilder,
+    $SettingsUpdateCompanionBuilder,
+    (SettingsItem, BaseReferences<_$SettingsDb, Settings, SettingsItem>),
+    SettingsItem,
+    PrefetchHooks Function()>;
 
 class $SettingsDbManager {
   final _$SettingsDb _db;
diff --git a/lib/database/sync_db.g.dart b/lib/database/sync_db.g.dart
index cac436e18..479202bbf 100644
--- a/lib/database/sync_db.g.dart
+++ b/lib/database/sync_db.g.dart
@@ -442,22 +442,130 @@ typedef $$OutboxTableUpdateCompanionBuilder = OutboxCompanion Function({
   Value<String?> filePath,
 });
 
+class $$OutboxTableFilterComposer
+    extends Composer<_$SyncDatabase, $OutboxTable> {
+  $$OutboxTableFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<int> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<int> get status => $composableBuilder(
+      column: $table.status, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<int> get retries => $composableBuilder(
+      column: $table.retries, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get message => $composableBuilder(
+      column: $table.message, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get subject => $composableBuilder(
+      column: $table.subject, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get filePath => $composableBuilder(
+      column: $table.filePath, builder: (column) => ColumnFilters(column));
+}
+
+class $$OutboxTableOrderingComposer
+    extends Composer<_$SyncDatabase, $OutboxTable> {
+  $$OutboxTableOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<int> get id => $composableBuilder(
+      column: $table.id, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get createdAt => $composableBuilder(
+      column: $table.createdAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<DateTime> get updatedAt => $composableBuilder(
+      column: $table.updatedAt, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<int> get status => $composableBuilder(
+      column: $table.status, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<int> get retries => $composableBuilder(
+      column: $table.retries, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get message => $composableBuilder(
+      column: $table.message, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get subject => $composableBuilder(
+      column: $table.subject, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get filePath => $composableBuilder(
+      column: $table.filePath, builder: (column) => ColumnOrderings(column));
+}
+
+class $$OutboxTableAnnotationComposer
+    extends Composer<_$SyncDatabase, $OutboxTable> {
+  $$OutboxTableAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<int> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get createdAt =>
+      $composableBuilder(column: $table.createdAt, builder: (column) => column);
+
+  GeneratedColumn<DateTime> get updatedAt =>
+      $composableBuilder(column: $table.updatedAt, builder: (column) => column);
+
+  GeneratedColumn<int> get status =>
+      $composableBuilder(column: $table.status, builder: (column) => column);
+
+  GeneratedColumn<int> get retries =>
+      $composableBuilder(column: $table.retries, builder: (column) => column);
+
+  GeneratedColumn<String> get message =>
+      $composableBuilder(column: $table.message, builder: (column) => column);
+
+  GeneratedColumn<String> get subject =>
+      $composableBuilder(column: $table.subject, builder: (column) => column);
+
+  GeneratedColumn<String> get filePath =>
+      $composableBuilder(column: $table.filePath, builder: (column) => column);
+}
+
 class $$OutboxTableTableManager extends RootTableManager<
     _$SyncDatabase,
     $OutboxTable,
     OutboxItem,
     $$OutboxTableFilterComposer,
     $$OutboxTableOrderingComposer,
+    $$OutboxTableAnnotationComposer,
     $$OutboxTableCreateCompanionBuilder,
-    $$OutboxTableUpdateCompanionBuilder> {
+    $$OutboxTableUpdateCompanionBuilder,
+    (OutboxItem, BaseReferences<_$SyncDatabase, $OutboxTable, OutboxItem>),
+    OutboxItem,
+    PrefetchHooks Function()> {
   $$OutboxTableTableManager(_$SyncDatabase db, $OutboxTable table)
       : super(TableManagerState(
           db: db,
           table: table,
-          filteringComposer:
-              $$OutboxTableFilterComposer(ComposerState(db, table)),
-          orderingComposer:
-              $$OutboxTableOrderingComposer(ComposerState(db, table)),
+          createFilteringComposer: () =>
+              $$OutboxTableFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $$OutboxTableOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $$OutboxTableAnnotationComposer($db: db, $table: table),
           updateCompanionCallback: ({
             Value<int> id = const Value.absent(),
             Value<DateTime> createdAt = const Value.absent(),
@@ -498,96 +606,25 @@ class $$OutboxTableTableManager extends RootTableManager<
             subject: subject,
             filePath: filePath,
           ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
         ));
 }
 
-class $$OutboxTableFilterComposer
-    extends FilterComposer<_$SyncDatabase, $OutboxTable> {
-  $$OutboxTableFilterComposer(super.$state);
-  ColumnFilters<int> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<int> get status => $state.composableBuilder(
-      column: $state.table.status,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<int> get retries => $state.composableBuilder(
-      column: $state.table.retries,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get message => $state.composableBuilder(
-      column: $state.table.message,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get subject => $state.composableBuilder(
-      column: $state.table.subject,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-
-  ColumnFilters<String> get filePath => $state.composableBuilder(
-      column: $state.table.filePath,
-      builder: (column, joinBuilders) =>
-          ColumnFilters(column, joinBuilders: joinBuilders));
-}
-
-class $$OutboxTableOrderingComposer
-    extends OrderingComposer<_$SyncDatabase, $OutboxTable> {
-  $$OutboxTableOrderingComposer(super.$state);
-  ColumnOrderings<int> get id => $state.composableBuilder(
-      column: $state.table.id,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get createdAt => $state.composableBuilder(
-      column: $state.table.createdAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<DateTime> get updatedAt => $state.composableBuilder(
-      column: $state.table.updatedAt,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<int> get status => $state.composableBuilder(
-      column: $state.table.status,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<int> get retries => $state.composableBuilder(
-      column: $state.table.retries,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get message => $state.composableBuilder(
-      column: $state.table.message,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get subject => $state.composableBuilder(
-      column: $state.table.subject,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-
-  ColumnOrderings<String> get filePath => $state.composableBuilder(
-      column: $state.table.filePath,
-      builder: (column, joinBuilders) =>
-          ColumnOrderings(column, joinBuilders: joinBuilders));
-}
+typedef $$OutboxTableProcessedTableManager = ProcessedTableManager<
+    _$SyncDatabase,
+    $OutboxTable,
+    OutboxItem,
+    $$OutboxTableFilterComposer,
+    $$OutboxTableOrderingComposer,
+    $$OutboxTableAnnotationComposer,
+    $$OutboxTableCreateCompanionBuilder,
+    $$OutboxTableUpdateCompanionBuilder,
+    (OutboxItem, BaseReferences<_$SyncDatabase, $OutboxTable, OutboxItem>),
+    OutboxItem,
+    PrefetchHooks Function()>;
 
 class $SyncDatabaseManager {
   final _$SyncDatabase _db;
diff --git a/lib/features/tasks/state/checklist_item_controller.g.dart b/lib/features/tasks/state/checklist_item_controller.g.dart
index 7c0540279..a0fbeebb5 100644
--- a/lib/features/tasks/state/checklist_item_controller.g.dart
+++ b/lib/features/tasks/state/checklist_item_controller.g.dart
@@ -7,7 +7,7 @@ part of 'checklist_item_controller.dart';
 // **************************************************************************
 
 String _$checklistItemControllerHash() =>
-    r'8d81f430ebf816dd6fcc5d4be2fc111216f268d5';
+    r'cf89592805757d76a4a99acd0f686a8dd07709df';
 
 /// Copied from Dart SDK
 class _SystemHash {
diff --git a/macos/Podfile.lock b/macos/Podfile.lock
index 5258d456f..63929d467 100644
--- a/macos/Podfile.lock
+++ b/macos/Podfile.lock
@@ -198,7 +198,7 @@ SPEC CHECKSUMS:
   ffmpeg_kit_flutter: 5bd75928cf88ec177cea410b027681e4bfe09452
   file_selector_macos: cc3858c981fe6889f364731200d6232dac1d812d
   flutter_image_compress_macos: c26c3c13ea0f28ae6dea4e139b3292e7729f99f1
-  flutter_local_notifications: 4b427ffabf278fc6ea9484c97505e231166927a5
+  flutter_local_notifications: 7062189aabf7f50938a7b8b6614ffa97656eb0bf
   flutter_native_timezone: 3a4724189c47dea215bb3e168e555e18308d312c
   flutter_secure_storage_macos: 59459653abe1adb92abbc8ea747d79f8d19866c9
   FlutterMacOS: 8f6f14fa908a6fb3fba0cd85dbd81ec4b251fb24
diff --git a/pubspec.lock b/pubspec.lock
index 691c34aef..b0dc595db 100644
--- a/pubspec.lock
+++ b/pubspec.lock
@@ -274,10 +274,10 @@ packages:
     dependency: transitive
     description:
       name: charcode
-      sha256: fb98c0f6d12c920a02ee2d998da788bca066ca5f148492b7085ee23372b12306
+      sha256: fb0f1107cac15a5ea6ef0a6ef71a807b9e4267c713bb93e00e92d737cc8dbd8a
       url: "https://pub.dev"
     source: hosted
-    version: "1.3.1"
+    version: "1.4.0"
   checked_yaml:
     dependency: transitive
     description:
@@ -563,18 +563,18 @@ packages:
     dependency: "direct main"
     description:
       name: drift
-      sha256: "4e0ffee40d23f0b809e6cff1ad202886f51d629649073ed42d9cd1d194ea943e"
+      sha256: df027d168a2985a2e9da900adeba2ab0136f0d84436592cf3cd5135f82c8579c
       url: "https://pub.dev"
     source: hosted
-    version: "2.19.1+1"
+    version: "2.21.0"
   drift_dev:
     dependency: "direct dev"
     description:
       name: drift_dev
-      sha256: ac7647c6cedca99724ca300cff9181f6dd799428f8ed71f94159ed0528eaec26
+      sha256: "623649abe932fc17bd32e578e7e05f7ac5e7dd0b33e6c8669a0634105d1389bf"
       url: "https://pub.dev"
     source: hosted
-    version: "2.19.1"
+    version: "2.21.2"
   easy_debounce:
     dependency: "direct main"
     description:
@@ -739,18 +739,18 @@ packages:
     dependency: "direct main"
     description:
       name: flex_color_scheme
-      sha256: "32914024a4f404d90ff449f58d279191675b28e7c08824046baf06826e99d984"
+      sha256: ad9695ebdf7e2709b0311cac6a8f887984666e56884eecafa008d236ec3fc0c7
       url: "https://pub.dev"
     source: hosted
-    version: "7.3.1"
+    version: "8.0.1"
   flex_seed_scheme:
     dependency: transitive
     description:
       name: flex_seed_scheme
-      sha256: "4cee2f1d07259f77e8b36f4ec5f35499d19e74e17c7dce5b819554914082bc01"
+      sha256: "7639d2c86268eff84a909026eb169f008064af0fb3696a651b24b0fa24a40334"
       url: "https://pub.dev"
     source: hosted
-    version: "1.5.0"
+    version: "3.4.1"
   flutter:
     dependency: "direct main"
     description: flutter
@@ -942,26 +942,26 @@ packages:
     dependency: "direct main"
     description:
       name: flutter_local_notifications
-      sha256: "674173fd3c9eda9d4c8528da2ce0ea69f161577495a9cc835a2a4ecd7eadeb35"
+      sha256: ef41ae901e7529e52934feba19ed82827b11baa67336829564aeab3129460610
       url: "https://pub.dev"
     source: hosted
-    version: "17.2.4"
+    version: "18.0.1"
   flutter_local_notifications_linux:
     dependency: transitive
     description:
       name: flutter_local_notifications_linux
-      sha256: c49bd06165cad9beeb79090b18cd1eb0296f4bf4b23b84426e37dd7c027fc3af
+      sha256: "8f685642876742c941b29c32030f6f4f6dacd0e4eaecb3efbb187d6a3812ca01"
       url: "https://pub.dev"
     source: hosted
-    version: "4.0.1"
+    version: "5.0.0"
   flutter_local_notifications_platform_interface:
     dependency: transitive
     description:
       name: flutter_local_notifications_platform_interface
-      sha256: "85f8d07fe708c1bdcf45037f2c0109753b26ae077e9d9e899d55971711a4ea66"
+      sha256: "6c5b83c86bf819cdb177a9247a3722067dd8cc6313827ce7c77a4b238a26fd52"
       url: "https://pub.dev"
     source: hosted
-    version: "7.2.0"
+    version: "8.0.0"
   flutter_localizations:
     dependency: "direct main"
     description: flutter
@@ -987,10 +987,10 @@ packages:
     dependency: "direct dev"
     description:
       name: flutter_native_splash
-      sha256: ee5c9bd2b74ea8676442fd4ab876b5d41681df49276488854d6c81a5377c0ef1
+      sha256: "1152ab0067ca5a2ebeb862fe0a762057202cceb22b7e62692dcbabf6483891bb"
       url: "https://pub.dev"
     source: hosted
-    version: "2.4.2"
+    version: "2.4.3"
   flutter_native_timezone:
     dependency: "direct main"
     description:
@@ -1600,10 +1600,10 @@ packages:
     dependency: "direct dev"
     description:
       name: json_serializable
-      sha256: ea1432d167339ea9b5bb153f0571d0039607a873d6e04e0117af043f14a1fd4b
+      sha256: c2fcb3920cf2b6ae6845954186420fca40bc0a8abcc84903b7801f17d7050d7c
       url: "https://pub.dev"
     source: hosted
-    version: "6.8.0"
+    version: "6.9.0"
   just_audio:
     dependency: transitive
     description:
@@ -1800,10 +1800,10 @@ packages:
     dependency: "direct main"
     description:
       name: matrix
-      sha256: e06783394db3a49dbcd98a45803cac7d735a2fb1e3aafef65ddf01e72e16fc83
+      sha256: "94a66e563b89fabbeb67f24428f05f4547c6ee98878ec20f647530cbfb6f04db"
       url: "https://pub.dev"
     source: hosted
-    version: "0.34.0"
+    version: "0.35.0"
   media_kit:
     dependency: "direct main"
     description:
@@ -2417,10 +2417,10 @@ packages:
     dependency: transitive
     description:
       name: riverpod_analyzer_utils
-      sha256: dc53a659cb543b203cdc35cd4e942ed08ea893eb6ef12029301323bdf18c5d95
+      sha256: c6b8222b2b483cb87ae77ad147d6408f400c64f060df7a225b127f4afef4f8c8
       url: "https://pub.dev"
     source: hosted
-    version: "0.5.7"
+    version: "0.5.8"
   riverpod_annotation:
     dependency: "direct main"
     description:
@@ -2433,18 +2433,18 @@ packages:
     dependency: "direct dev"
     description:
       name: riverpod_generator
-      sha256: "54458dac2fea976990dc9ed379060db6ae5c8790143f1963fedd0fb99980a326"
+      sha256: "63546d70952015f0981361636bf8f356d9cfd9d7f6f0815e3c07789a41233188"
       url: "https://pub.dev"
     source: hosted
-    version: "2.6.2"
+    version: "2.6.3"
   riverpod_lint:
     dependency: "direct main"
     description:
       name: riverpod_lint
-      sha256: "326efc199b87f21053b9a2afbf2aea26c41b3bf6f8ba346ce69126ee17d16ebd"
+      sha256: "83e4caa337a9840469b7b9bd8c2351ce85abad80f570d84146911b32086fbd99"
       url: "https://pub.dev"
     source: hosted
-    version: "2.6.2"
+    version: "2.6.3"
   rxdart:
     dependency: "direct main"
     description:
@@ -2774,10 +2774,10 @@ packages:
     dependency: transitive
     description:
       name: sqlparser
-      sha256: "3be52b4968fc2f098ba735863404756d2fe3ea0729cf006a5b5612618f74ca04"
+      sha256: d77749237609784e337ec36c979d41f6f38a7b279df98622ae23929c8eb954a4
       url: "https://pub.dev"
     source: hosted
-    version: "0.37.1"
+    version: "0.39.2"
   stack_trace:
     dependency: transitive
     description:
@@ -2910,10 +2910,10 @@ packages:
     dependency: "direct main"
     description:
       name: timezone
-      sha256: "2236ec079a174ce07434e89fcd3fcda430025eb7692244139a9cf54fdcf1fc7d"
+      sha256: ffc9d5f4d1193534ef051f9254063fa53d588609418c84299956c3db9383587d
       url: "https://pub.dev"
     source: hosted
-    version: "0.9.4"
+    version: "0.10.0"
   timing:
     dependency: transitive
     description:
diff --git a/pubspec.yaml b/pubspec.yaml
index 022676721..9479d89d8 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,7 +1,7 @@
 name: lotti
 description: Achieve your goals and keep your data private with Lotti.
 publish_to: 'none'
-version: 0.9.532+2737
+version: 0.9.533+2739
 
 msix_config:
   display_name: LottiApp
@@ -37,7 +37,7 @@ dependencies:
       ref: ce9a6b6
 
   device_info_plus: ^11.0.0
-  drift: 2.19.1+1
+  drift: ^2.21.0
   easy_debounce: ^2.0.2+1
   enum_to_string: ^2.0.1
   equatable: ^2.0.3
@@ -45,7 +45,7 @@ dependencies:
 
   ffmpeg_kit_flutter: ^6.0.3
   fl_chart: ^0.69.0
-  flex_color_scheme: ^7.1.2
+  flex_color_scheme: ^8.0.1
   flutter:
     sdk: flutter
 
@@ -63,7 +63,7 @@ dependencies:
 
   flutter_image_compress: ^2.0.3
   flutter_linkify: ^6.0.0
-  flutter_local_notifications: ^17.0.0
+  flutter_local_notifications: ^18.0.1
 
   flutter_localizations:
     sdk: flutter
@@ -105,7 +105,7 @@ dependencies:
   latlong2: ^0.9.0
   location: ^7.0.0
   material_design_icons_flutter: ^7.0.7096
-  matrix: ^0.34.0
+  matrix: ^0.35.0
   media_kit: ^1.0.2
   media_kit_libs_android_audio: ^1.0.3
   media_kit_libs_ios_audio: ^1.0.4
@@ -142,7 +142,7 @@ dependencies:
   sqflite_common_ffi: ^2.3.3
   sqlite3: ^2.4.5
   sqlite3_flutter_libs: ^0.5.15
-  timezone: ^0.9.1
+  timezone: ^0.10.0
   tinycolor2: ^3.0.0
   url_launcher: ^6.1.2
   uuid: ^4.3.3