@deveye/types 0.15.0

package/src/domain/home.ts

@@ -0,0 +1,314 @@
+import { z } from 'zod';
+import {
+    externalFeatureIdSchema,
+    featureIdSchema,
+    isExternalFeatureId,
+    type ExternalFeatureId,
+    type FeatureId
+} from './workspaceRole';
+
+/**
+ * Disposition de l'accueil (par espace). La grille est composée de **sections**
+ * ordonnées, chacune tenant des **tuiles** ordonnées de n'importe quels genres —
+ * appareil, fonctionnalité, raccourci, dossier. Les sections sont entièrement
+ * modulaires : aucune par défaut, ajoutées / retirées / réordonnées librement.
+ * Leur intitulé est facultatif — sans lui, la section se rend comme un simple
+ * groupe légèrement espacé, sans titre.
+ *
+ * Stockée en clair : métadonnée de personnalisation non sensible (comme le
+ * thème), jamais de charge zero-knowledge.
+ */
+
+/** Les seize tuiles de fonctionnalités natives. */
+export const nativeHomeFeatureIdSchema = z.enum([
+    'monitoring',
+    'sentinel',
+    'weather',
+    'password',
+    'notes',
+    'cloudsync',
+    'uptime',
+    'mail',
+    'projects',
+    'git',
+    'deploy',
+    'database',
+    'backup',
+    'finance',
+    'audience',
+    'osint'
+]);
+export type NativeHomeFeatureId = z.infer<typeof nativeHomeFeatureIdSchema>;
+
+/**
+ * Une tuile de fonctionnalité posable sur la grille : native, ou module externe
+ * (préfixe `x-`, voir `workspaceRole.ts`). Surensemble pur : les dispositions
+ * persistées parsent inchangées, et une tuile `x-` dont le module a disparu
+ * parse aussi : la grille l'ignore au rendu tant que rien ne porte cet id.
+ */
+export const homeFeatureIdSchema = z.union([nativeHomeFeatureIdSchema, externalFeatureIdSchema]);
+export type HomeFeatureId = NativeHomeFeatureId | ExternalFeatureId;
+
+/**
+ * Compact widgets that can be pinned to the top-right of the navbar. Like the
+ * grid features they are individually add/remove/reorderable; the default set is
+ * empty (the navbar shows none until the user adds some).
+ *  - `weather`  → current temperature of the primary city.
+ *  - `devices`  → online / total device count.
+ *  - `secrecy`  → password-encryption lock state + re-validation countdown.
+ *  - `uptime`   → services up / total monitored.
+ *  - `live`     → qui d'autre est dans l'espace, et où (bulles cliquables).
+ */
+export const nativeHomeTopbarWidgetIdSchema = z.enum([
+    'weather',
+    'devices',
+    'secrecy',
+    'uptime',
+    'live'
+]);
+export type NativeHomeTopbarWidgetId = z.infer<typeof nativeHomeTopbarWidgetIdSchema>;
+
+/**
+ * Un module peut épingler SON widget de topbar : son id de feature sert d'id
+ * de widget. Surensemble pur, comme les tuiles : les dispositions persistées
+ * parsent inchangées, un id sans widget est ignoré au rendu.
+ */
+export const homeTopbarWidgetIdSchema = z.union([nativeHomeTopbarWidgetIdSchema, featureIdSchema]);
+export type HomeTopbarWidgetId = NativeHomeTopbarWidgetId | FeatureId;
+
+/**
+ * Shortcut preview type, auto-detected from the URL's domain (the user never
+ * picks it manually). Each value has a server-side adapter under
+ * `src/Services/shortcutTemplates/` — dedicated logic where a real source exists
+ * (GitHub API, YouTube/Spotify/SoundCloud/TikTok oEmbed, Wikipedia REST, npm
+ * registry), and the generic Open Graph + favicon adapter for the rest. `link`
+ * is that generic adapter; unknown domains fall back to it.
+ */
+export const shortcutTemplateSchema = z.enum([
+    'link',
+    'github',
+    'youtube',
+    'twitch',
+    'twitter',
+    'instagram',
+    'tiktok',
+    'reddit',
+    'linkedin',
+    'spotify',
+    'soundcloud',
+    'discord',
+    'wikipedia',
+    'medium',
+    'npm',
+    'dribbble',
+    'pinterest',
+    'facebook'
+]);
+export type ShortcutTemplate = z.infer<typeof shortcutTemplateSchema>;
+
+/** Max length of a shortcut URL kept in the layout. */
+export const SHORTCUT_URL_MAX_LENGTH = 2048;
+
+/** Un lien épinglé par l'utilisateur : une tuile qui porte son propre objet. */
+export const shortcutItemSchema = z.object({
+    /** Stable client-generated id, used as the React / drag key. */
+    id: z.string().min(1).max(64),
+    /** Unknown/legacy templates degrade to a generic link rather than dropping the tile. */
+    template: shortcutTemplateSchema.catch('link'),
+    url: z.string().url().max(SHORTCUT_URL_MAX_LENGTH),
+    /** Optional: empty → the tile falls back to the fetched name (account, og:title…). */
+    title: z.string().max(80),
+    description: z.string().max(200).optional(),
+    /** Optional icon class name (e.g. `other`); falls back per template. */
+    icon: z.string().max(40).optional()
+});
+export type ShortcutItem = z.infer<typeof shortcutItemSchema>;
+
+/**
+ * Combien de tuiles tient une section, et combien de fonctionnalités tient un
+ * dossier.
+ *
+ * Exporté, et pas seulement écrit dans le schéma : le client doit refuser
+ * **avant** d'écrire. Une disposition qui dépasse le plafond ne passe plus la
+ * validation, donc le serveur la rejette et le client la relit vide au
+ * démarrage suivant, ce qui revient à un accueil effacé sans un mot. Le
+ * plafond des dossiers n'est atteignable par aucun geste (il y a moins de
+ * fonctionnalités que ça, et aucune ne peut être rangée deux fois), celui des
+ * tuiles l'est en créant des dossiers à la chaîne.
+ */
+export const HOME_SECTION_MAX_TILES = 60;
+export const HOME_FOLDER_MAX_ITEMS = 20;
+
+/**
+ * Un dossier de la grille : plusieurs fonctionnalités derrière une seule tuile.
+ *
+ * Il vit dans une section au milieu des tuiles ordinaires, parce que c'en est
+ * une : même carte, même place dans la grille, même glisser-déposer. Ce qui
+ * change est ce qui se passe au clic (côté client, les cartes qu'il tient se
+ * déploient par-dessus l'accueil).
+ *
+ * Il ne range que des **fonctionnalités**, là où une section range tout : une
+ * carte d'appareil et un raccourci sont déjà des tuiles courtes, les empiler
+ * derrière une tuile de pleine hauteur coûterait plus de place qu'il n'en
+ * gagnerait. C'est la seule asymétrie qui reste après l'unification, et elle
+ * est de mise en page, pas de modèle.
+ *
+ * Les fonctionnalités qu'il tient comptent comme **posées sur l'accueil** : le
+ * sélecteur d'ajout les exclut, exactement comme celles qui ont leur propre
+ * tuile. Une fonctionnalité n'est donc jamais à deux endroits à la fois, et la
+ * règle « pas deux fois la même » reste une seule règle.
+ */
+export const homeFolderSchema = z.object({
+    /** Discriminant : c'est lui qui distingue un dossier d'un raccourci. */
+    kind: z.literal('folder'),
+    /** Id stable généré par le client : clé React, id de glissé, cible des mutations. */
+    id: z.string().min(1).max(64),
+    /** Intitulé porté par la carte. Vide, l'affichage retombe sur « Dossier ». */
+    title: z.string().max(40),
+    items: z.array(homeFeatureIdSchema).max(HOME_FOLDER_MAX_ITEMS)
+});
+export type HomeFolder = z.infer<typeof homeFolderSchema>;
+
+/**
+ * Une tuile de l'accueil — appareil, fonctionnalité, raccourci ou dossier.
+ *
+ * ## Un seul genre de section, donc un seul genre de tuile
+ *
+ * Les sections étaient auparavant typées (« appareils », « fonctionnalités »,
+ * « raccourcis ») et ne tenaient qu'une sorte de tuile. Ça obligeait à choisir
+ * le genre **avant** d'avoir quelque chose à poser, à ouvrir une popup pour
+ * ajouter une section, et à trois sélecteurs d'ajout différents. Une section
+ * n'est plus qu'une rangée de tuiles ; c'est la tuile qui sait ce qu'elle est.
+ *
+ * ## Chaque tuile garde l'écriture qu'elle avait
+ *
+ * Un appareil et une fonctionnalité **sont** leur identifiant (l'entité vit
+ * ailleurs) ; un raccourci et un dossier portent l'objet lui-même, parce que
+ * rien d'autre ne les décrit. Les deux familles d'identifiants ne peuvent pas
+ * se confondre — les fonctionnalités forment un enum fermé, les appareils sont
+ * des UUID — et c'est {@link homeTileKind} qui tranche, en un seul endroit.
+ *
+ * Conséquence utile : les dispositions écrites avant l'unification restent
+ * valides telles quelles. Leurs sections portent encore un champ `kind`, qui
+ * tombe à la lecture comme n'importe quelle clé inconnue, et la première
+ * écriture le fait disparaître. Rien à migrer, rien à rattraper au chargement.
+ */
+export const homeTileSchema = z.union([
+    homeFolderSchema,
+    shortcutItemSchema,
+    homeFeatureIdSchema,
+    z.uuid()
+]);
+export type HomeTile = z.infer<typeof homeTileSchema>;
+
+/** Ce que porte une tuile. Une seule lecture de la forme, partagée par tous. */
+export type HomeTileKind = 'device' | 'feature' | 'shortcut' | 'folder';
+
+/**
+ * Les fonctionnalités **natives**, pour distinguer leur identifiant d'un id
+ * d'appareil. Les externes se reconnaissent à leur préfixe (`isExternalFeatureId`),
+ * pas à une liste : la liste dépend de l'installation, le préfixe non.
+ */
+export const HOME_FEATURE_IDS = nativeHomeFeatureIdSchema.options;
+
+/**
+ * Le genre d'une tuile.
+ *
+ * **Le seul endroit qui connaisse la forme de l'union** : tout le reste passe
+ * par lui ou par les gardes ci-dessous, donc changer la représentation ne se
+ * paye qu'ici.
+ */
+export function homeTileKind(tile: HomeTile): HomeTileKind {
+    if (typeof tile !== 'string') return 'kind' in tile ? 'folder' : 'shortcut';
+    if (isExternalFeatureId(tile)) return 'feature';
+    return (HOME_FEATURE_IDS as readonly string[]).includes(tile) ? 'feature' : 'device';
+}
+
+/** Cette tuile est-elle un dossier ? */
+export function isHomeFolder(tile: HomeTile): tile is HomeFolder {
+    return homeTileKind(tile) === 'folder';
+}
+
+/** Cette tuile est-elle un raccourci ? */
+export function isShortcutTile(tile: HomeTile): tile is ShortcutItem {
+    return homeTileKind(tile) === 'shortcut';
+}
+
+/** Cette tuile est-elle une fonctionnalité ? */
+export function isFeatureTile(tile: HomeTile): tile is HomeFeatureId {
+    return homeTileKind(tile) === 'feature';
+}
+
+/**
+ * L'identité d'une tuile : sa clé React, son id de glissé, la cible des
+ * mutations. Un raccourci et un dossier portent leur `id`, un appareil et une
+ * fonctionnalité **sont** le leur.
+ */
+export function homeTileId(tile: HomeTile): string {
+    return typeof tile === 'string' ? tile : tile.id;
+}
+
+/** Fields every section carries. */
+const sectionBase = {
+    /** Stable client-generated id: React key, drag id, and mutation target. */
+    id: z.string().min(1).max(64),
+    /** User-chosen heading; absent → the section renders untitled on the home. */
+    title: z.string().max(40).optional(),
+    /**
+     * The section can be folded away from the home.
+     *
+     * Absent (the default) → it always shows, and there is nothing to click:
+     * a chevron on a section nobody wants to fold is one more thing to ignore.
+     */
+    collapsible: z.boolean().optional(),
+    /**
+     * It starts folded.
+     *
+     * Only meaningful alongside `collapsible` — a section that cannot be
+     * unfolded but starts folded would simply be invisible. The home enforces
+     * that pairing rather than trusting the flag on its own.
+     */
+    collapsed: z.boolean().optional()
+};
+
+/**
+ * Une section : une rangée ordonnée de tuiles, de n'importe quels genres.
+ *
+ * Elle ne se distingue plus par ce qu'elle tient — un appareil, une
+ * fonctionnalité et un raccourci cohabitent dans la même — mais par son seul
+ * `id`. Une ligne peut donc mêler une carte de pleine hauteur et des cartes
+ * courtes : c'est assumé, la grille aligne les hauts et laisse les cartes
+ * courtes à leur taille.
+ */
+export const homeSectionSchema = z.object({
+    ...sectionBase,
+    items: z.array(homeTileSchema).max(HOME_SECTION_MAX_TILES)
+});
+export type HomeSection = z.infer<typeof homeSectionSchema>;
+
+export const homeLayoutSchema = z.object({
+    /** Navbar mini-widgets — not a grid section, edited in the navbar itself. */
+    topbar: z.array(homeTopbarWidgetIdSchema).max(10),
+    /** Ordered grid sections. Empty by default: a fresh home shows none. */
+    sections: z.array(homeSectionSchema).max(12)
+});
+export type HomeLayout = z.infer<typeof homeLayoutSchema>;
+
+/**
+ * Normalized preview returned for a rich shortcut template, so the client has a
+ * single renderer regardless of the source. `ok: false` means the source could
+ * not be fetched/parsed — the tile still works as a plain link.
+ */
+export const shortcutPreviewSchema = z.object({
+    ok: z.boolean(),
+    title: z.string().nullable(),
+    subtitle: z.string().nullable(),
+    imageUrl: z.string().url().nullable(),
+    stats: z.array(z.object({ label: z.string(), value: z.string() })).max(4),
+    /**
+     * Optional live/online status, rendered as a small green/red dot in the tile
+     * corner (e.g. Twitch live vs offline). Omitted when not applicable.
+     */
+    status: z.enum(['online', 'offline']).optional()
+});
+export type ShortcutPreview = z.infer<typeof shortcutPreviewSchema>;

package/src/domain/live.ts

@@ -0,0 +1,272 @@
+import { z } from 'zod';
+import { userColorSchema } from './user';
+import {
+    externalFeatureIdSchema,
+    isExternalFeatureId,
+    workspaceFeatureIdSchema,
+    type FeatureId,
+    type WorkspaceFeatureId
+} from './workspaceRole';
+
+/**
+ * La présence en direct : qui est dans l'espace, où, et ce qui vient d'y changer.
+ *
+ * Le mot « presence » est déjà pris dans ce dépôt par la présence des *agents*
+ * (`domain/presence.ts`, `DEVICE_PRESENCE_EVENT`) : ici le vocabulaire de code
+ * est **live**, et « Présence » n'est que le mot de l'interface.
+ */
+
+/**
+ * Un segment de localisation, sous la forme `kind:value`.
+ *
+ * Le `kind` identifie le **niveau** (`view`, `account`, `folder`…), la valeur
+ * identifie le nœud à ce niveau. La valeur peut elle-même contenir des
+ * deux-points — une vue d'appareil est `view:device:<uuid>` — donc **on découpe
+ * au premier deux-points, jamais avec un `split` complet.**
+ */
+export const livePathSegmentSchema = z
+    .string()
+    .min(3)
+    .max(96)
+    .regex(/^[a-z][a-z0-9]*:[A-Za-z0-9_:.-]{1,80}$/, 'Segment attendu sous la forme kind:value');
+
+/**
+ * Le chemin complet, de la racine vers la feuille. `[]` = l'accueil.
+ *
+ * Plafonné à six niveaux : c'est deux de plus que la feature la plus profonde
+ * (Mail : vue → compte → dossier → message), et ça borne le coût de la
+ * projection par destinataire quoi qu'envoie un client.
+ */
+export const livePathSchema = z.array(livePathSegmentSchema).max(6);
+export type LivePath = z.infer<typeof livePathSchema>;
+
+/** Le `kind` d'un segment, sans sa valeur. */
+export function segmentKind(segment: string): string {
+    const i = segment.indexOf(':');
+    return i === -1 ? segment : segment.slice(0, i);
+}
+
+/** La valeur d'un segment, deux-points internes compris. */
+export function segmentValue(segment: string): string {
+    const i = segment.indexOf(':');
+    return i === -1 ? '' : segment.slice(i + 1);
+}
+
+/**
+ * L'**état** du curseur, tel que le navigateur le dessine à celui qui le tient.
+ *
+ * Transmis avec la position parce qu'il porte l'intention : une flèche qui
+ * devient main dit « il s'apprête à cliquer », un curseur de texte dit « il
+ * lit ou il sélectionne », une main fermée dit « il déplace quelque chose ».
+ * Sans lui, tous les pairs seraient perpétuellement en flèche neutre, et le
+ * geste d'en face resterait illisible.
+ *
+ * Volontairement **court** : l'ensemble des curseurs CSS compte une trentaine de
+ * valeurs, dont la plupart ne se distinguent pas à seize pixels. Sept familles
+ * suffisent, et c'est autant de dessins à tenir.
+ */
+export const liveCursorKindSchema = z.enum([
+    'default',
+    /** `pointer` — quelque chose de cliquable est sous le curseur. */
+    'pointer',
+    /** `text` — du texte lisible ou sélectionnable. */
+    'text',
+    /** `grab` — saisissable, mais pas encore saisi. */
+    'grab',
+    /** `grabbing` / `move` — quelque chose est en train d'être déplacé. */
+    'grabbing',
+    /** Les `*-resize` — une poignée de redimensionnement. */
+    'resize',
+    /** `not-allowed` / `no-drop` — l'action est refusée ici. */
+    'blocked'
+]);
+export type LiveCursorKind = z.infer<typeof liveCursorKindSchema>;
+
+/**
+ * Position du curseur dans la **surface** de la vue (le corps de la popup, ou la
+ * grille de l'accueil quand rien n'est ouvert).
+ *
+ * Unités volontairement mixtes, parce que les deux axes n'ont pas le même sens :
+ *
+ *  - `x` est **relatif** (0..1) à la largeur de la surface. La popup est bornée
+ *    à 1240 px : au-delà les deux fenêtres ont la même boîte, en dessous elles
+ *    divergent, et seule une fraction reste juste.
+ *  - `y` est en **pixels absolus du contenu**, défilement compris. Le contenu
+ *    est le même des deux côtés (même liste, mêmes lignes) : « le pair est sur
+ *    le 14ᵉ message » est le sens qu'on veut, alors qu'une fraction de la
+ *    hauteur totale se décalerait dès qu'une liste est chargée plus loin d'un
+ *    côté que de l'autre.
+ *
+ * Les bornes de `x` dépassent [0, 1] très largement, et à dessein : le pointeur
+ * vit aussi **à côté** de la boîte de contenu — ses marges, les bords de l'écran
+ * — et l'y écrêter ferait disparaître le curseur d'un pair alors qu'on est
+ * toujours sur la même page. Sur un écran très large, ces marges représentent
+ * plusieurs fois la largeur du contenu ; les bornes ne sont donc qu'un garde-fou
+ * contre l'absurde, et seul le cadre de la fenêtre décide de ce qui s'affiche.
+ */
+export const liveCursorSchema = z.object({
+    x: z.number().min(-10).max(10),
+    y: z.number().min(-100_000).max(100_000),
+    kind: liveCursorKindSchema
+});
+export type LiveCursor = z.infer<typeof liveCursorSchema>;
+
+/**
+ * Un pair tel qu'il est diffusé.
+ *
+ * Ni pseudo ni avatar : `users.avatar` est une URL de données pouvant atteindre
+ * 1,5 Mo (`AVATAR_MAX_LENGTH`), et le roster repart à chaque changement de
+ * chemin. Le client résout les deux par `userId` contre les membres de l'espace,
+ * que la session lui a déjà donnés. Seule la **couleur** voyage, parce qu'elle
+ * doit changer à l'instant où son propriétaire la change.
+ */
+export const livePeerSchema = z.object({
+    /** Identité de la *connexion*, pas du compte : deux onglets = deux pairs. */
+    connId: z.string().min(1),
+    userId: z.number().int().positive(),
+    color: userColorSchema,
+    workspaceId: z.number().int().positive(),
+    /** Tronqué à `[]` si le destinataire n'a pas le droit de voir ce lieu. */
+    path: livePathSchema,
+    cursor: liveCursorSchema.nullable()
+});
+export type LivePeer = z.infer<typeof livePeerSchema>;
+
+/**
+ * Ce qui vient de changer dans un espace, à la maille de la feature.
+ *
+ * Volontairement grossier : le client ne tient aucun cache normalisé, il
+ * re-sollicite. Un sujet plus fin ne ferait qu'ajouter de la synchronisation
+ * sans rien économiser.
+ */
+export const nativeLiveTopicSchema = z.enum([
+    ...workspaceFeatureIdSchema.options,
+    /**
+     * Les messages des projets, séparés de `projects` exprès.
+     *
+     * Une feature vaut normalement un sujet, mais un fil de discussion bat à une
+     * toute autre cadence que la structure qui le porte : sans cette coupure,
+     * chaque message ferait re-solliciter le tableau, la frise et le portefeuille
+     * entiers. `TOPIC_FEATURE` le rattache au même droit — c'est bien la même
+     * feature, vue à deux vitesses.
+     */
+    'projectsChat',
+    /** Membres, rôles, nom, logo de l'espace. */
+    'workspace',
+    /**
+     * L'accueil de l'espace : sa **disposition** et son **apparence**.
+     *
+     * Les deux voyagent ensemble parce qu'ils se relisent ensemble — une seule
+     * commande (`workspace.activate`) les rend tous les deux, donc les séparer
+     * en deux sujets ne ferait que doubler les allers-retours pour un même
+     * rafraîchissement. Ce sont aussi des réglages **de l'espace** : `account`
+     * ne conviendrait pas au thème, il ne sort jamais de l'espace personnel.
+     */
+    'home',
+    /** Réglages de compte (avatar, couleur, thème, chiffrement). */
+    'account',
+    /**
+     * Les canaux d'alerte de l'espace, et les routes qui pointent dessus.
+     *
+     * Un sujet à lui, et non `workspace` : les canaux se relisent depuis
+     * l'écran de réglages de n'importe quelle fonctionnalité, et les rattacher
+     * au sujet de l'espace ferait re-solliciter la liste des membres, les rôles
+     * et le nom à chaque fois qu'on coche une case. Ni `uptime` ni ses voisins
+     * ne conviennent non plus : une route change pour **une** fonctionnalité,
+     * mais un canal change pour toutes à la fois, et `mutates` est déclaré par
+     * commande, pas par argument.
+     */
+    'notify'
+]);
+export type NativeLiveTopic = z.infer<typeof nativeLiveTopicSchema>;
+
+/**
+ * Un module externe vaut **un** sujet, qui est son id : la coupure fine de
+ * `projectsChat` reste un privilège natif, un module re-sollicite tout ce qu'il
+ * expose. Le préfixe `x-` garantit qu'un sujet externe ne percute ni une
+ * feature native ni un sujet réservé.
+ */
+export const liveTopicSchema = z.union([nativeLiveTopicSchema, externalFeatureIdSchema]);
+export type LiveTopic = z.infer<typeof liveTopicSchema>;
+
+/**
+ * La feature dont relève un sujet, natif ou externe. Seule porte d'entrée à
+ * garder : la table `TOPIC_FEATURE` ne connaît que les sujets natifs, et un
+ * sujet externe **est** sa feature.
+ */
+export function topicFeatureOf(topic: LiveTopic): FeatureId | null {
+    if (isExternalFeatureId(topic)) return topic;
+    return TOPIC_FEATURE[topic as NativeLiveTopic];
+}
+
+/**
+ * La feature dont un sujet relève, ou `null` quand il n'en relève d'aucune.
+ *
+ * `null` **n'est pas** « visible par personne » mais « aucun droit de feature à
+ * vérifier » : l'appartenance à l'espace suffit. Les trois qui y tombent le
+ * méritent — la liste des membres est visible de tous les membres, la
+ * disposition de l'accueil est commune, et `account` n'est jamais diffusé que
+ * dans un espace personnel, c'est-à-dire à ses propres autres onglets.
+ */
+export const TOPIC_FEATURE: Record<NativeLiveTopic, WorkspaceFeatureId | null> = {
+    devices: 'devices',
+    sentinel: 'sentinel',
+    weather: 'weather',
+    password: 'password',
+    notes: 'notes',
+    cloudsync: 'cloudsync',
+    uptime: 'uptime',
+    mail: 'mail',
+    projects: 'projects',
+    projectsChat: 'projects',
+    git: 'git',
+    deploy: 'deploy',
+    database: 'database',
+    backup: 'backup',
+    finance: 'finance',
+    audience: 'audience',
+    osint: 'osint',
+    workspace: null,
+    home: null,
+    account: null,
+    // Aucun droit de feature à vérifier : la diffusion ne dit que « quelque
+    // chose a changé », et la relecture qu'elle déclenche est gardée côté
+    // commande (droits de la fonctionnalité et gestion de ses canaux). Même
+    // nature que `workspace`.
+    notify: null
+};
+
+/**
+ * Le droit qu'exige la **racine** d'un chemin, pour décider si un pair est
+ * montré là où il est ou renvoyé à « ailleurs ».
+ *
+ * Trois issues :
+ *  - une feature → montré au destinataire qui a `read` dessus ;
+ *  - `'public'`  → montré à tout membre (aujourd'hui : personne, gardé pour un
+ *    éventuel lieu commun) ;
+ *  - `'private'` → **jamais montré**, à personne.
+ *
+ * Les vues de compte et d'administration (Profil, Sécurité, Journaux,
+ * Utilisateurs, Gestion de l'espace) tombent dans `'private'`. `featureBehind`
+ * côté client leur rend `null` parce qu'elles ont leurs propres gardes ; ici
+ * `null` voudrait dire « visible par tous », ce qui ferait fuiter « untel est
+ * dans Sécurité ». D'où le troisième cas, plutôt qu'une réutilisation directe.
+ */
+export type LivePathGate = FeatureId | 'public' | 'private';
+
+const DEVICE_VIEW_PREFIX = 'device:';
+
+export function livePathGate(rootSegment: string | undefined): LivePathGate {
+    if (!rootSegment) return 'public';
+    if (segmentKind(rootSegment) !== 'view') return 'private';
+    const viewId = segmentValue(rootSegment);
+    const asFeature = workspaceFeatureIdSchema.safeParse(viewId);
+    if (asFeature.success) return asFeature.data;
+    // Une vue de module externe est gardée par le droit du module, comme une
+    // feature native : même règle, reconnue au préfixe plutôt qu'à l'enum.
+    if (isExternalFeatureId(viewId)) return viewId;
+    // La page Appareils et chaque vue d'appareil relèvent du même droit — miroir
+    // exact de `featureBehind` côté client.
+    if (viewId === 'clients' || viewId.startsWith(DEVICE_VIEW_PREFIX)) return 'devices';
+    return 'private';
+}