feat(nodedex): add user-defined node groups with many-to-many membership

Introduce two new SQLite tables (`nodedex_groups` and `nodedex_node_groups`) to support local user-defined node grouping. Groups can have a name, color, icon, and sort order; membership is a many-to-many join keyed on `node_num` and `group_id`. Timestamps and a `deleted_at_ms` column are included for future Cloud Sync readiness.

Add migration logic from schema version 14→15 that creates these tables and indexes. Update `NodeDexTables` constants and bump `nodedexSchemaVersion` to 15.

Also add corresponding UI text localizations (IT, PT, JA, FR, DE, etc.) for group management dialogs, including buttons, counters, and placeholder labels.

Author: gotnull

lib/features/nodedex/models/node_group.dart

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: 2025-2026 gotnull (developer@socialmesh.app)
+
+import 'package:flutter/material.dart';
+
+// A user-defined grouping of nodes (e.g. "Repeaters", "My Team").
+//
+// Groups are a local organisation concept with no Meshtastic radio
+// equivalent; they are persisted in nodedex.db alongside the other per-node
+// user metadata (social tag, note, local nickname). Row mapping lives in
+// NodeGroupsStore so this model stays free of any database coupling.
+//
+// [colorValue] is an ARGB int rendered via `Color(colorValue)` (mirroring the
+// Routes feature). [iconKey] is a stable string key into [kNodeGroupIcons] --
+// never a raw code point, so Flutter's icon tree-shaking stays intact in
+// release builds.
+@immutable
+class NodeGroup {
+  final String id;
+  final String name;
+  final int colorValue;
+  final String iconKey;
+  final int sortOrder;
+  final int createdAtMs;
+  final int updatedAtMs;
+
+  const NodeGroup({
+    required this.id,
+    required this.name,
+    required this.colorValue,
+    required this.iconKey,
+    this.sortOrder = 0,
+    required this.createdAtMs,
+    required this.updatedAtMs,
+  });
+
+  /// The group's swatch colour.
+  Color get color => Color(colorValue);
+
+  /// The group's icon, resolved from the curated const set. Falls back to a
+  /// neutral label icon when the key is unknown (e.g. written by a newer build).
+  IconData get icon => kNodeGroupIcons[iconKey] ?? kNodeGroupFallbackIcon;
+
+  NodeGroup copyWith({
+    String? name,
+    int? colorValue,
+    String? iconKey,
+    int? sortOrder,
+    int? updatedAtMs,
+  }) {
+    return NodeGroup(
+      id: id,
+      name: name ?? this.name,
+      colorValue: colorValue ?? this.colorValue,
+      iconKey: iconKey ?? this.iconKey,
+      sortOrder: sortOrder ?? this.sortOrder,
+      createdAtMs: createdAtMs,
+      updatedAtMs: updatedAtMs ?? this.updatedAtMs,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is NodeGroup &&
+          other.id == id &&
+          other.name == name &&
+          other.colorValue == colorValue &&
+          other.iconKey == iconKey &&
+          other.sortOrder == sortOrder &&
+          other.createdAtMs == createdAtMs &&
+          other.updatedAtMs == updatedAtMs;
+
+  @override
+  int get hashCode => Object.hash(
+    id,
+    name,
+    colorValue,
+    iconKey,
+    sortOrder,
+    createdAtMs,
+    updatedAtMs,
+  );
+}
+
+/// Fallback icon used when a stored [NodeGroup.iconKey] is not recognised.
+const IconData kNodeGroupFallbackIcon = Icons.label_outline;
+
+/// Default icon key for newly created groups.
+const String kNodeGroupDefaultIconKey = 'label';
+
+/// Curated set of group icons, keyed by a stable string stored in the DB.
+///
+/// Every value is a `const IconData`, so icon tree-shaking is preserved in
+/// release builds. Add new entries to the END with a new key; never repurpose
+/// an existing key (stored rows reference it).
+const Map<String, IconData> kNodeGroupIcons = {
+  'label': Icons.label,
+  'star': Icons.star,
+  'home': Icons.home,
+  'work': Icons.work,
+  'group': Icons.group,
+  'favorite': Icons.favorite,
+  'router': Icons.router,
+  'sensors': Icons.sensors,
+  'hub': Icons.hub,
+  'place': Icons.place,
+  'shield': Icons.shield,
+  'bolt': Icons.bolt,
+  'terrain': Icons.terrain,
+  'directions_car': Icons.directions_car,
+  'flag': Icons.flag,
+  'bookmark': Icons.bookmark,
+  'antenna': Icons.settings_input_antenna,
+  'campaign': Icons.campaign,
+};

lib/features/nodedex/providers/node_groups_provider.dart

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: 2025-2026 gotnull (developer@socialmesh.app)
+
+// Node Groups state — reactive layer over NodeGroupsStore (nodedex.db).
+//
+// Exposes the list of user-defined groups plus the node->group membership
+// map, and mutation methods (create / update / delete / assign). Mirrors the
+// AsyncNotifier-with-persistence pattern used by nodeFavoritesProvider.
+
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+import '../../../core/logging.dart';
+import '../models/node_group.dart';
+import '../services/nodedex_groups_store.dart';
+import 'nodedex_providers.dart';
+
+/// Immutable snapshot of all groups and current membership.
+class NodeGroupsState {
+  final List<NodeGroup> groups;
+
+  /// nodeNum -> set of groupIds the node belongs to.
+  final Map<int, Set<String>> membership;
+
+  const NodeGroupsState({this.groups = const [], this.membership = const {}});
+
+  /// The set of group ids a given node belongs to (never null).
+  Set<String> groupsForNode(int nodeNum) =>
+      membership[nodeNum] ?? const <String>{};
+
+  /// How many nodes are assigned to [groupId].
+  int nodeCount(String groupId) =>
+      membership.values.where((ids) => ids.contains(groupId)).length;
+
+  /// Whether any group has been created.
+  bool get isEmpty => groups.isEmpty;
+}
+
+/// Builds a [NodeGroupsStore] over the shared NodeDex database, ensuring the
+/// database is initialized first (via [nodeDexStoreProvider]).
+final nodeGroupsStoreProvider = FutureProvider<NodeGroupsStore>((ref) async {
+  // Awaiting the entry store guarantees the shared NodeDexDatabase is open.
+  await ref.watch(nodeDexStoreProvider.future);
+  final db = ref.watch(nodeDexDatabaseProvider);
+  return NodeGroupsStore(db);
+});
+
+/// Reactive node-groups state with mutation methods.
+class NodeGroupsNotifier extends AsyncNotifier<NodeGroupsState> {
+  Future<NodeGroupsStore> get _storeFuture =>
+      ref.read(nodeGroupsStoreProvider.future);
+
+  @override
+  Future<NodeGroupsState> build() async {
+    final store = await ref.watch(nodeGroupsStoreProvider.future);
+    return _load(store);
+  }
+
+  Future<NodeGroupsState> _load(NodeGroupsStore store) async {
+    final groups = await store.loadGroups();
+    final membership = await store.loadMembership();
+    return NodeGroupsState(groups: groups, membership: membership);
+  }
+
+  Future<void> _reload() async {
+    final store = await _storeFuture;
+    state = await AsyncValue.guard(() => _load(store));
+  }
+
+  int get _nowMs => DateTime.now().millisecondsSinceEpoch;
+
+  /// Generate a collision-resistant local id for a new group.
+  String _newGroupId() =>
+      'g${DateTime.now().microsecondsSinceEpoch.toRadixString(36)}';
+
+  /// Create a new group; returns the created group.
+  Future<NodeGroup> createGroup({
+    required String name,
+    required int colorValue,
+    required String iconKey,
+  }) async {
+    final store = await _storeFuture;
+    final now = _nowMs;
+    final existing = state.asData?.value.groups ?? const <NodeGroup>[];
+    final group = NodeGroup(
+      id: _newGroupId(),
+      name: name.trim(),
+      colorValue: colorValue,
+      iconKey: iconKey,
+      sortOrder: existing.length,
+      createdAtMs: now,
+      updatedAtMs: now,
+    );
+    await store.upsertGroup(group);
+    await _reload();
+    AppLogging.nodes('[NodeGroups] created group ${group.id} "${group.name}"');
+    return group;
+  }
+
+  /// Update an existing group (name / colour / icon / sort order). The
+  /// updated timestamp is refreshed automatically.
+  Future<void> updateGroup(NodeGroup group) async {
+    final store = await _storeFuture;
+    await store.upsertGroup(group.copyWith(updatedAtMs: _nowMs));
+    await _reload();
+  }
+
+  /// Delete a group and clear all of its membership.
+  Future<void> deleteGroup(String groupId) async {
+    final store = await _storeFuture;
+    await store.deleteGroup(groupId);
+    await _reload();
+  }
+
+  /// Persist reordered groups (assigns sortOrder by list position).
+  Future<void> reorderGroups(List<NodeGroup> ordered) async {
+    final store = await _storeFuture;
+    final now = _nowMs;
+    for (var i = 0; i < ordered.length; i++) {
+      await store.upsertGroup(
+        ordered[i].copyWith(sortOrder: i, updatedAtMs: now),
+      );
+    }
+    await _reload();
+  }
+
+  /// Replace the full set of groups a node belongs to.
+  Future<void> setNodeGroups(int nodeNum, Set<String> groupIds) async {
+    final store = await _storeFuture;
+    await store.setNodeGroups(nodeNum, groupIds, nowMs: _nowMs);
+    await _reload();
+  }
+
+  /// Add one node to one group.
+  Future<void> addNodeToGroup(int nodeNum, String groupId) async {
+    final store = await _storeFuture;
+    await store.addNodeToGroup(nodeNum, groupId, nowMs: _nowMs);
+    await _reload();
+  }
+
+  /// Remove one node from one group.
+  Future<void> removeNodeFromGroup(int nodeNum, String groupId) async {
+    final store = await _storeFuture;
+    await store.removeNodeFromGroup(nodeNum, groupId);
+    await _reload();
+  }
+}
+
+final nodeGroupsProvider =
+    AsyncNotifierProvider<NodeGroupsNotifier, NodeGroupsState>(
+      NodeGroupsNotifier.new,
+    );