@deveye/types 0.15.1 → 0.16.0

package/src/domain/live.ts

@@ -53,17 +53,10 @@ export function segmentValue(segment: string): string {
 }
 
 /**
- * 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.
+ * L'état du curseur, tel que le navigateur le dessine à celui qui le tient.
+ * Transmis avec la position parce qu'il porte l'intention (cliquer, lire,
+ * déplacer). Sept familles seulement : la plupart des curseurs CSS ne se
+ * distinguent pas à seize pixels.
  */
 export const liveCursorKindSchema = z.enum([
     'default',
@@ -83,26 +76,14 @@ export const liveCursorKindSchema = z.enum([
 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.
+ * Position du curseur dans la surface de la vue. Unités mixtes à dessein :
+ *  - `x` est relatif (0..1) à la largeur de la surface, bornée à 1240 px : seule
+ *    une fraction reste juste quand les deux fenêtres divergent ;
+ *  - `y` est en pixels absolus du contenu, défilement compris : le contenu est
+ *    le même des deux côtés, alors qu'une fraction de la hauteur se décalerait
+ *    dès qu'une liste est chargée plus loin d'un côté.
+ * Les bornes de `x` dépassent [0, 1] : le pointeur vit aussi dans les marges,
+ * et l'écrêter ferait disparaître le curseur d'un pair sur la même page.
  */
 export const liveCursorSchema = z.object({
     x: z.number().min(-10).max(10),
@@ -112,13 +93,11 @@ export const liveCursorSchema = z.object({
 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.
+ * Un pair tel qu'il est diffusé. Ni pseudo ni avatar : `users.avatar` est une
+ * URL de données pouvant atteindre 1,5 Mo, et le roster repart à chaque
+ * changement de chemin ; le client résout les deux par `userId` contre les
+ * membres de l'espace. 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. */
@@ -141,50 +120,32 @@ export type LivePeer = z.infer<typeof livePeerSchema>;
  */
 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.
+     * L'accueil de l'espace : disposition et apparence. Ensemble parce qu'ils
+     * se relisent ensemble (`workspace.activate` rend les deux), et sous
+     * l'espace et non `account` : le thème est un réglage de l'espace.
      */
     '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.
+     * Les canaux d'alerte de l'espace et les routes qui pointent dessus. Un
+     * sujet à part : les canaux se relisent depuis les réglages de n'importe
+     * quelle fonctionnalité, et un canal change pour toutes à la fois alors que
+     * `mutates` est déclaré par commande.
      */
     '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é.
+ * Un module vaut **un** sujet, qui est son id, plus les sujets secondaires que
+ * son manifest déclare (`topics`, validés au boot : `projectsChat` bat les
+ * messages sans faire re-solliciter le tableau). Ces sujets-là ne figurent pas
+ * ici : l'app les lit dans les manifests installés. 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>;
@@ -218,7 +179,6 @@ export const TOPIC_FEATURE: Record<NativeLiveTopic, WorkspaceFeatureId | null> =
     uptime: 'uptime',
     mail: 'mail',
     projects: 'projects',
-    projectsChat: 'projects',
     git: 'git',
     deploy: 'deploy',
     database: 'database',
@@ -229,28 +189,17 @@ export const TOPIC_FEATURE: Record<NativeLiveTopic, WorkspaceFeatureId | null> =
     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`.
+    // Aucun droit de feature à vérifier : la relecture déclenchée est gardée
+    // côté commande. 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.
+ * Le droit qu'exige la racine d'un chemin, pour décider si un pair est montré
+ * là où il est ou renvoyé à « ailleurs » : une feature (montré à qui a `read`
+ * dessus), `'public'` (tout membre), `'private'` (jamais montré). Les vues de
+ * compte et d'administration tombent dans `'private'` : `null` voudrait dire
+ * « visible par tous » et ferait fuiter « untel est dans Sécurité ».
  */
 export type LivePathGate = FeatureId | 'public' | 'private';
 

package/src/domain/metrics.ts

@@ -49,11 +49,9 @@ export const metricSnapshotSchema = z.object({
     batteryCharging: z.boolean().nullable().default(null),
     /**
      * Programs running at this instant, heaviest first, aggregated by name.
-     * `null` means "not carried by this row" — either the device's capture mode
-     * is `off`, or the snapshot sat long enough in the agent's offline queue for
-     * the detail to be trimmed (graphs keep full fidelity, process detail is
-     * bounded). Persisted separately (`device_process_samples`) under this row's
-     * `timestamp`, so it is *not* echoed back by `metrics.query`.
+     * `null` = not carried by this row (capture mode `off`, or trimmed from a
+     * long offline queue). Persisted separately (`device_process_samples`)
+     * under this row's `timestamp`, so `metrics.query` does not echo it back.
      */
     processes: z.array(reportProcessSchema).max(2000).nullable().default(null),
     /**
@@ -67,10 +65,10 @@ export const metricSnapshotSchema = z.object({
 export type MetricSnapshot = z.infer<typeof metricSnapshotSchema>;
 
 /**
- * Batch of snapshots pushed by an agent over the agent WebSocket. Bounded to
- * keep payloads small and allow draining an offline queue in chunks. The agent
- * additionally caps a batch by serialized size, since a snapshot now carries its
- * process list and 100 of them would make a multi-megabyte frame.
+ * Batch of snapshots pushed by an agent over the agent WebSocket. Bounded so an
+ * offline queue drains in chunks; the agent additionally caps a batch by
+ * serialized size, since 100 snapshots with process lists would make a
+ * multi-megabyte frame.
  */
 export const metricsBatchSchema = z.object({
     deviceId: z.uuid(),
@@ -88,11 +86,9 @@ export const metricsResolutionSchema = z.enum(['raw', 'minute', 'hour']);
 export type MetricsResolution = z.infer<typeof metricsResolutionSchema>;
 
 /**
- * A point read back from `device_metrics` — a live snapshot minus its process
- * list, which lives in its own table and is read through `metrics.processesAt`.
- * Keeping it out of the series is deliberate: a graph window holds hundreds of
- * points, and carrying every process list along would cost megabytes for data
- * the graphs never read.
+ * A point read back from `device_metrics`: a snapshot minus its process list,
+ * which lives in its own table (`metrics.processesAt`). A graph window holds
+ * hundreds of points; carrying every process list along would cost megabytes.
  */
 export const metricSeriesPointSchema = metricSnapshotSchema.omit({
     processes: true,

package/src/domain/notifications.ts

@@ -4,64 +4,27 @@ import { NOTIFYING_FEATURES } from './featureRegistry';
 import { externalFeatureIdSchema } from './workspaceRole';
 
 /**
- * Les canaux d'alerte d'un espace — **une liste, et des liaisons vers elle**.
+ * Les canaux d'alerte d'un espace : une liste, et des liaisons vers elle.
  *
- * ## Ce que le modèle précédent ne savait pas faire
+ * Un canal est une destination nommée (type, libellé, cible) qui appartient à
+ * une fonctionnalité : c'est une source de cette fonctionnalité, gérée dans
+ * ses réglages. Deux features qui préviennent le même salon le déclarent deux
+ * fois, et chacune se corrige à un seul endroit.
  *
- * Il portait deux canaux binaires — un mail, un webhook — par couple
- * `(espace, feature)`. Trois conséquences, toutes rencontrées :
- *
- * 1. **Le même salon Discord était redéclaré cinq fois.** Le corriger demandait
- *    d'ouvrir cinq écrans, et en oublier un ne se voyait qu'à la première alerte
- *    qui n'arrivait plus.
- * 2. **Deux destinataires étaient impossibles.** Une équipe pour la production,
- *    une autre pour la recette : il fallait choisir.
- * 3. **Aucun routage par élément.** Toutes les bases d'un espace prévenaient les
- *    mêmes gens, quel que soit le projet derrière.
- *
- * ## La forme retenue
- *
- * Un **canal** est une destination nommée : un type, un libellé, une cible. Il
- * appartient à **une fonctionnalité** (091) : c'est une source de cette
- * fonctionnalité, au même titre qu'un jeton Dokploy pour le Déploiement, et il
- * se gère dans ses réglages à elle. La 087 l'avait fait vivre à l'échelle de
- * l'espace, partagé par les cinq émetteurs ; on retrouvait alors une liste
- * commune gérée depuis cinq endroits, l'inverse du patron des sources. Le prix
- * assumé du retour : deux features qui préviennent le même salon le déclarent
- * deux fois. On en déclare autant qu'on veut, et on les corrige **à un seul
- * endroit** : les réglages de leur fonctionnalité.
- *
- * Une **route** dit qui écrit vers quels canaux, et la sélection vit **sur
- * l'élément** (092) : chaque cible coche un ou plusieurs canaux de sa feature
- * dans ses propres réglages, et sans sélection rien ne part. L'héritage
- * d'une « route de la fonctionnalité » a été essayé (087) puis retiré : cocher
- * un canal à l'échelle de la feature ne visait aucun élément nommable, et les
- * cases des éléments, grisées tant qu'ils « suivaient » la feature, semblaient
- * ne jamais pouvoir se cocher. Une route de fonctionnalité (`itemId` absent)
- * ne subsiste que pour les émetteurs **sans éléments** (Sentinelle), dont les
- * alertes ne visent rien de plus fin.
- *
- * Ce qui n'a pas changé, et qui compte : **tout est éteint par défaut.** Sans
- * canal ni route, rien ne part. Une fonctionnalité qui se met à écrire à des
- * gens sans qu'ils l'aient demandé reste le travers que ce modèle refuse.
+ * Une route dit qui écrit vers quels canaux ; la sélection vit sur l'élément.
+ * Une route de fonctionnalité (`itemId` absent) ne subsiste que pour les
+ * émetteurs sans éléments (Sentinelle). Tout est éteint par défaut : sans
+ * canal ni route, rien ne part.
  */
 
 /**
- * Le type d'un canal, et ce qu'il change à l'envoi.
- *
- * `webhook` et `discord` **séparent ce que l'URL devinait**. Le module d'envoi
- * reconnaissait Discord en analysant l'adresse, ce qui marchait mais décidait à
- * la place de l'utilisateur : un point d'entrée maison hébergé derrière un
- * domaine Discord aurait reçu des embeds au lieu de son texte, et rien ne
- * permettait de demander l'inverse. C'est désormais une déclaration.
- *
- *  - `email`   — un compte Mail « open » de l'espace expédie vers une adresse.
- *  - `webhook` — un POST JSON générique : le message lisible est répété dans
- *    `content` (Discord) et `text` (Slack), les champs structurés suivent pour
- *    un point d'entrée maison. Aucune des trois têtes ne gêne les autres.
- *  - `discord` — la mise en page riche de Discord (embeds, couleurs, champs),
- *    et pour le déploiement le **suivi vivant** : un seul message qui se met à
- *    jour du début à la fin.
+ * Le type d'un canal, et ce qu'il change à l'envoi. `webhook` et `discord`
+ * sont une déclaration, jamais devinés d'après l'URL.
+ *  - `email`   : un compte Mail « open » de l'espace expédie vers une adresse.
+ *  - `webhook` : un POST JSON générique, le message lisible répété dans
+ *    `content` (Discord) et `text` (Slack), les champs structurés à côté.
+ *  - `discord` : embeds, couleurs, champs, et le suivi vivant d'un déploiement
+ *    (un seul message mis à jour du début à la fin).
  */
 export const notificationChannelKindSchema = z.enum(['email', 'webhook', 'discord']);
 export type NotificationChannelKind = z.infer<typeof notificationChannelKindSchema>;
@@ -69,12 +32,9 @@ export type NotificationChannelKind = z.infer<typeof notificationChannelKindSche
 export const NOTIFICATION_CHANNEL_KINDS = notificationChannelKindSchema.options;
 
 /**
- * Les fonctionnalités **natives** qui savent prévenir.
- *
- * Enum fermé plutôt que chaîne libre : c'est lui qui garde une route d'être
- * posée sur une fonctionnalité qui n'écrira jamais. Il double le drapeau
- * `notifies` du registre, et le contrôle en bas de fichier interdit qu'ils
- * divergent.
+ * Les fonctionnalités natives qui savent prévenir. Enum fermé : c'est lui qui
+ * garde une route d'être posée sur une fonctionnalité qui n'écrira jamais. Il
+ * double `notifies` du registre ; le contrôle en bas de fichier les tient égaux.
  */
 export const nativeNotificationFeatureSchema = z.enum([
     'uptime',
@@ -102,11 +62,9 @@ export const NOTIFICATION_TARGET_MAX = 2048;
 export const NOTIFICATION_EMAIL_MAX = 320;
 
 /**
- * Un canal tel que le client le reçoit.
- *
- * `target` sort **en clair** : c'est une adresse que son auteur a saisie et doit
- * pouvoir relire pour la corriger. Elle est chiffrée au repos (étage ouvert),
- * comme l'étaient déjà les réglages qu'elle remplace.
+ * Un canal tel que le client le reçoit. `target` sort en clair : c'est une
+ * adresse que son auteur a saisie et doit pouvoir relire. Chiffrée au repos
+ * (étage ouvert).
  */
 export const notificationChannelSchema = z.object({
     id: z.number().int().positive(),
@@ -115,35 +73,25 @@ export const notificationChannelSchema = z.object({
     label: z.string().min(1).max(NOTIFICATION_LABEL_MAX),
     /**
      * Adresse destinataire (`email`) ou URL appelée en POST (`webhook`,
-     * `discord`) : **vide pour qui n'a pas la gestion des canaux de la
-     * fonctionnalité** (le champ `channels` de son grant, migration 093).
-     *
-     * La liste est lisible avec la fonctionnalité, parce qu'il faut voir les
-     * destinations pour router vers l'une d'elles. Leur *contenu* ne l'est
-     * pas : confier le réglage d'Uptime ne confie pas l'adresse de l'astreinte
-     * ni l'URL du salon de production. On voit donc « Astreinte · e-mail », on
-     * peut y router, et on ne peut ni la lire ni la modifier.
+     * `discord`). Vide pour qui n'a pas la gestion des canaux de la
+     * fonctionnalité (`channels` du grant) : la liste est lisible avec la
+     * fonctionnalité, pour router, mais confier le réglage d'Uptime ne confie
+     * pas l'adresse de l'astreinte.
      */
     target: z.string().max(NOTIFICATION_TARGET_MAX),
     /** Le compte Mail expéditeur ; `null` hors des canaux `email`. */
     mailAccountId: z.number().int().positive().nullable(),
     /**
-     * Ce canal partirait-il **maintenant** ?
-     *
-     * Faux quand le compte expéditeur manque, a disparu, est désactivé ou n'est
-     * pas au palier « open ». L'interface le dit au lieu de laisser croire à un
-     * canal actif — l'avertissement n'existait à l'origine que dans Uptime, et
-     * son absence ailleurs faisait passer un canal muet pour un canal réglé.
+     * Ce canal partirait-il maintenant ? Faux quand le compte expéditeur
+     * manque, a disparu, est désactivé ou n'est pas au palier « open ».
      */
     ready: z.boolean(),
     /** Éteint sans être supprimé : ses routes restent, rien ne part. */
     enabled: z.boolean(),
     position: z.number().int().nonnegative(),
     /**
-     * Combien de routes le désignent — ce que l'écran affiche en « utilisé par
-     * N ». Compté côté serveur : le client n'a pas les routes des éléments sous
-     * la main, et les demander toutes pour afficher un nombre serait une
-     * requête par ligne.
+     * Combien de routes le désignent (« utilisé par N »). Compté côté serveur :
+     * le client n'a pas les routes des éléments sous la main.
      */
     usageCount: z.number().int().nonnegative()
 });
@@ -172,13 +120,7 @@ export const notificationRouteTargetSchema = z.object({
 });
 export type NotificationRouteTarget = z.infer<typeof notificationRouteTargetSchema>;
 
-/**
- * Où écrit une cible : sa sélection de canaux, rien de plus.
- *
- * Vide, elle ne prévient personne — il n'y a plus d'héritage à distinguer
- * (092), donc plus de drapeau `inherits` : une sélection vide et une sélection
- * jamais faite disent la même chose, le silence.
- */
+/** Où écrit une cible : sa sélection de canaux. Vide, elle ne prévient personne. */
 export const notificationRouteSchema = z.object({
     channelIds: z.array(z.number().int().positive())
 });
@@ -191,21 +133,15 @@ export const notificationRouteInputSchema = notificationRouteTargetSchema.extend
 export type NotificationRouteInput = z.infer<typeof notificationRouteInputSchema>;
 
 /**
- * Ce que rend un envoi d'essai : parti, ou pourquoi non.
- *
- * `sent: false` avec un `error` n'est pas une exception — « aucun canal activé »
- * est une réponse, pas une panne, et la remonter comme telle laisserait l'écran
- * afficher « échec » là où il n'y a rien à échouer.
+ * Ce que rend un envoi d'essai : parti, ou pourquoi non. `sent: false` avec un
+ * `error` n'est pas une exception : « aucun canal activé » est une réponse.
  */
 export const notificationTestSchema = z.object({ sent: z.boolean(), error: z.string().nullable() });
 export type NotificationTest = z.infer<typeof notificationTestSchema>;
 
 /**
- * Ce qu'une suppression de canal emporte avec elle.
- *
- * Rendu **avant** la suppression pour que la confirmation nomme ce qui va
- * cesser de prévenir, plutôt que de demander « êtes-vous sûr ? » sans dire de
- * quoi. Une liste vide veut dire qu'aucune route ne le désigne.
+ * Ce qu'une suppression de canal emporte, rendu avant la suppression pour que
+ * la confirmation nomme ce qui va cesser de prévenir. Liste vide = aucune route.
  */
 export const notificationChannelUsageSchema = z.object({
     channelId: z.number().int().positive(),
@@ -224,7 +160,7 @@ export type NotificationChannelUsage = z.infer<typeof notificationChannelUsageSc
 export interface NotificationChannelRow {
     id: number;
     workspace_id: number;
-    /** La fonctionnalité propriétaire : un canal est une source de SA feature (091). */
+    /** La fonctionnalité propriétaire : un canal est une source de sa feature. */
     feature: NotificationFeature;
     kind: NotificationChannelKind;
     label_enc: string;
@@ -245,16 +181,9 @@ export interface NotificationRouteRow {
 }
 
 /**
- * Contrôle de cohérence, au chargement du module.
- *
- * `notifies` dans le registre et cet enum répondent à la même question ; les
- * tenir séparés est un choix (l'un décrit, l'autre valide), les laisser diverger
- * n'en est pas un. Une fonctionnalité marquée `notifies` mais absente de l'enum
- * afficherait un onglet Notifications dont toutes les commandes seraient
- * refusées — un écran qui ment, découvert à la première alerte attendue.
- *
- * Même esprit que le contrôle des sujets `mutates` côté serveur : attraper
- * l'oubli au démarrage plutôt qu'en production.
+ * Contrôle de cohérence au chargement : une fonctionnalité marquée `notifies`
+ * mais absente de l'enum afficherait un onglet Notifications dont toutes les
+ * commandes seraient refusées.
  */
 {
     const registry = [...NOTIFYING_FEATURES].sort().join(', ');

package/src/domain/project.ts

@@ -1,168 +1,9 @@
 import { z } from 'zod';
 
 /**
- * Projets : le suivi d'un travail, de ses premières phases à son déploiement.
- *
- * Découpage du stockage (voir `Docs/SECURITY_MODEL.md`). En **clair** tout ce
- * dont le serveur a besoin pour lister, trier, compter et router sans rien
- * déchiffrer — `workspace_id`, `status`, `security_tier`, `sort_order`, les
- * dates, `archived_at`. **Chiffré** tout ce qui identifie : titre, description,
- * étiquettes, version.
- *
- * Comme le mail, et contrairement à Uptime ou au coffre, l'étage de chiffrement
- * n'est pas fixé par la feature mais **choisi par projet** (`securityTier`) :
- * un projet `open` peut être synchronisé en tâche de fond (dépôt git,
- * déploiement) ; un projet `guarded` ne se déchiffre que pendant une session
- * vivante et déverrouillée, et perd donc ses intégrations automatiques.
- */
-
-export const PROJECT_TITLE_MAX_LENGTH = 120;
-export const PROJECT_DESCRIPTION_MAX_LENGTH = 4000;
-export const PROJECT_VERSION_MAX_LENGTH = 40;
-export const PROJECT_TAG_LABEL_MAX_LENGTH = 32;
-export const PROJECT_MAX_TAGS = 24;
-
-/**
- * Borne de l'icône d'un projet, en caractères de son URL de données.
- *
- * ~400 ko : de quoi loger confortablement une vignette carrée redimensionnée
- * par le client, sans laisser une charge utile WS grossir au gré de ce qu'on
- * dépose. L'icône vit **dans le payload chiffré** comme le titre : elle
- * identifie le projet autant qu'un nom, et un projet confidentiel ne doit pas
- * la laisser lire.
- */
-export const PROJECT_ICON_MAX_LENGTH = 400_000;
-
-/** Vide = icône par défaut. Sinon, une URL de données d'image. */
-export const projectIconSchema = z
-    .string()
-    .max(PROJECT_ICON_MAX_LENGTH)
-    .refine((v) => v === '' || /^data:image\/(png|jpeg|webp);base64,[A-Za-z0-9+/]+=*$/.test(v), {
-        message: 'L’icône doit être une image encodée en base64.'
-    });
-
-/** Quel coffre chiffre l'arbre du projet. Voir l'en-tête de ce fichier. */
-export const projectSecurityTierSchema = z.enum(['open', 'guarded']);
-export type ProjectSecurityTier = z.infer<typeof projectSecurityTierSchema>;
-
-/**
- * Où en est le projet. Volontairement court : c'est un état de pilotage, pas un
- * workflow — le détail de l'avancement vit dans les colonnes du kanban.
+ * Où en est un projet : un état de pilotage, pas un workflow (l'avancement vit
+ * dans les colonnes du kanban). Seul vocabulaire de Projets gardé ici, parce que
+ * d'autres features le parlent (`ProjectUsage.status`, `sdk/providers.ts`).
  */
 export const projectStatusSchema = z.enum(['draft', 'active', 'paused', 'done']);
 export type ProjectStatus = z.infer<typeof projectStatusSchema>;
-
-/**
- * D'où vient le numéro de version affiché.
- *  - `manual` — saisi à la main dans le profil du projet ;
- *  - `github_release` — la dernière release publiée du dépôt lié. Le champ
- *    devient alors en lecture seule dans l'interface, et un projet `guarded` ne
- *    peut pas le choisir (sa synchronisation de fond est impossible).
- */
-export const projectVersionSourceSchema = z.enum(['manual', 'github_release']);
-export type ProjectVersionSource = z.infer<typeof projectVersionSourceSchema>;
-
-/**
- * Les deux familles d'étiquettes, cumulables sur un même projet :
- *  - `type` — ce que le projet *est* (app mobile, site web, service…) ;
- *  - `tech` — ce avec quoi il est fait (react, react native, express, vite…).
- *
- * Le libellé est libre plutôt qu'énuméré : une pile technique se renouvelle plus
- * vite qu'un schéma, et une valeur inconnue ne doit jamais faire disparaître un
- * projet de la liste. Les étiquettes voyagent **dans le payload chiffré** — le
- * filtrage se fait donc côté client, ce qui suffit largement à cette échelle.
- */
-export const projectTagKindSchema = z.enum(['type', 'tech']);
-export type ProjectTagKind = z.infer<typeof projectTagKindSchema>;
-
-export const projectTagSchema = z.object({
-    kind: projectTagKindSchema,
-    label: z.string().min(1).max(PROJECT_TAG_LABEL_MAX_LENGTH)
-});
-export type ProjectTag = z.infer<typeof projectTagSchema>;
-
-export const projectSchema = z.object({
-    id: z.number().int().positive(),
-    title: z.string().max(PROJECT_TITLE_MAX_LENGTH),
-    /** Vignette du projet ; vide = l'icône par défaut de la feature. */
-    icon: projectIconSchema,
-    description: z.string().max(PROJECT_DESCRIPTION_MAX_LENGTH),
-    tags: z.array(projectTagSchema).max(PROJECT_MAX_TAGS),
-    version: z.string().max(PROJECT_VERSION_MAX_LENGTH),
-    versionSource: projectVersionSourceSchema,
-    status: projectStatusSchema,
-    securityTier: projectSecurityTierSchema,
-    /** Bornes de la fenêtre du projet, en secondes unix. Facultatives. */
-    startDate: z.number().int().nullable(),
-    dueDate: z.number().int().nullable(),
-    sortOrder: z.number().int().nonnegative(),
-    /**
-     * Qui l'a créé : attribution, jamais une frontière d'accès. `null` quand le
-     * compte a été supprimé depuis — un départ n'emporte pas le travail d'un
-     * espace partagé (cf. `ON DELETE SET NULL` dans la migration).
-     */
-    authorUserId: z.number().int().positive().nullable(),
-    archived: z.boolean(),
-    created: z.number().int(),
-    updated: z.number().int()
-});
-export type Project = z.infer<typeof projectSchema>;
-
-/**
- * La ligne du portefeuille : le projet, plus ce que le serveur sait compter
- * **sans déchiffrer** (colonnes en clair uniquement).
- *
- * `masked: true` désigne un projet `guarded` dont le corps n'a pas pu être
- * déchiffré parce que la session est verrouillée. La ligne reste listée, avec
- * ses compteurs — on doit pouvoir voir qu'un projet existe, et le déverrouiller
- * en connaissance de cause, sans que la liste entière disparaisse. Même parti
- * pris que les notes privées.
- */
-export const projectSummarySchema = z.object({
-    project: projectSchema,
-    masked: z.boolean(),
-    /** Cartes actives (non archivées) et celles assises dans une colonne de fin. */
-    cardTotal: z.number().int().nonnegative(),
-    cardDone: z.number().int().nonnegative(),
-    /** Cartes actives dont l'échéance est dépassée. */
-    cardOverdue: z.number().int().nonnegative(),
-    /** Prochaine échéance à venir, toutes cartes confondues. */
-    nextDueDate: z.number().int().nullable(),
-    /** Messages non lus par l'appelant sur tout le projet. */
-    unread: z.number().int().nonnegative()
-});
-export type ProjectSummary = z.infer<typeof projectSummarySchema>;
-
-/**
- * Ce que le client peut poser sur un projet. La version n'y est pas quand elle
- * est pilotée par les releases : `project.setVersion` la traite à part, pour que
- * l'édition du profil ne puisse pas écraser en silence une valeur synchronisée.
- */
-export const projectDraftSchema = z.object({
-    title: z.string().min(1).max(PROJECT_TITLE_MAX_LENGTH),
-    icon: projectIconSchema,
-    description: z.string().max(PROJECT_DESCRIPTION_MAX_LENGTH),
-    tags: z.array(projectTagSchema).max(PROJECT_MAX_TAGS),
-    status: projectStatusSchema,
-    startDate: z.number().int().nullable(),
-    dueDate: z.number().int().nullable()
-});
-export type ProjectDraft = z.infer<typeof projectDraftSchema>;
-
-/** Ligne SQL (serveur uniquement). `content` porte le payload chiffré. */
-export interface ProjectRow {
-    id: number;
-    workspace_id: number;
-    /** Auteur. En espace partagé il dit qui a créé la ligne, rien de plus. */
-    user_id: number | null;
-    status: ProjectStatus;
-    security_tier: ProjectSecurityTier;
-    version_source: ProjectVersionSource;
-    sort_order: number;
-    start_date: number | null;
-    due_date: number | null;
-    archived_at: number | null;
-    content: string;
-    created: number;
-    updated: number;
-}