@deveye/types 0.15.2 → 0.16.0

package/src/domain/report.ts

@@ -1,19 +1,14 @@
 import { z } from 'zod';
 
 /**
- * "Latest known state" report for a device — distinct from the time-series
- * metric snapshots. It carries slow-moving signals (OS info, security posture)
- * that don't belong in the per-cycle metric stream.
+ * "Latest known state" report for a device, distinct from the metric snapshots:
+ * slow-moving signals (OS info, security posture). The agent emits one on
+ * connect and then periodically; the server keeps only the most recent per
+ * device (`devices.report_json`) and fans it out live.
  *
- * The agent emits one on connect and then periodically. The server persists only
- * the most recent report per device (`devices.report_json`) and fans it out live.
- *
- * Every security field is nullable: collectors are best-effort and shell out to
- * OS tools that may be absent or require privileges. `null` means "unknown".
- *
- * Processes are *not* in the report: they ride along with each metric snapshot
- * (`metricSnapshotSchema.processes`) so every graph point has the process list of
- * that exact instant, and are historised under the same `ts`.
+ * Every security field is nullable: collectors are best-effort, `null` means
+ * "unknown". Processes are not in the report: they ride along with each metric
+ * snapshot (`metricSnapshotSchema.processes`).
  */
 
 /**
@@ -30,25 +25,18 @@ import { z } from 'zod';
 export const reportProcessSchema = z.object({
     name: z.string().min(1).max(128),
     /**
-     * Chemin de l'exécutable, et **seconde moitié de la clé d'agrégation**.
-     *
-     * Agréger sur le seul nom fusionnait deux binaires homonymes rangés à des
-     * endroits différents — exactement ce derrière quoi un imposteur se cache.
-     * La clé est donc `(name, execPath)`, et deux `nginx` de chemins distincts
-     * forment désormais deux entrées, ce qui est l'information utile.
-     *
-     * `null` = inconnu : agent trop ancien pour le renvoyer, ou chemin illisible
-     * faute de droits. Les règles qui en dépendent restent alors muettes plutôt
-     * que de conclure dans le vide (invariant 6 de Monitoring).
+     * Chemin de l'exécutable, seconde moitié de la clé d'agrégation
+     * `(name, execPath)` : deux binaires homonymes de chemins distincts sont
+     * deux entrées, ce derrière quoi un imposteur se cache. `null` = inconnu
+     * (agent trop ancien, ou chemin illisible faute de droits) ; les règles qui
+     * en dépendent restent alors muettes.
      */
     execPath: z.string().max(512).nullable().default(null),
     /**
      * L'exécutable a été effacé du disque mais le processus tourne toujours
-     * (`/proc/<pid>/exe` pointe vers un chemin suffixé « (deleted) »).
-     *
-     * Un des indicateurs les plus francs d'un implant résident en mémoire, et il
-     * ne coûte rien : le lien symbolique est déjà lu pour `execPath`. `null` là
-     * où la plateforme ne l'expose pas (macOS, Windows).
+     * (`/proc/<pid>/exe` suffixé « (deleted) ») : un des indicateurs les plus
+     * francs d'un implant résident en mémoire. `null` là où la plateforme ne
+     * l'expose pas (macOS, Windows).
      */
     deleted: z.boolean().nullable().default(null),
     /** Number of PIDs aggregated under this name. */
@@ -98,9 +86,8 @@ export const processKindSchema = z.enum(['top', 'all']);
 export type ProcessKind = z.infer<typeof processKindSchema>;
 
 /**
- * A stored process list at one instant. **Read model only**: the agent no longer
- * emits it on its own — processes travel inside `metricSnapshotSchema.processes`
- * so a graph point and its process list always share one `ts`. This is what
+ * A stored process list at one instant. Read model only: processes travel
+ * inside `metricSnapshotSchema.processes`, and this is what
  * `metrics.processesAt` returns when reading history back.
  */
 export const processSampleSchema = z.object({
@@ -134,12 +121,9 @@ export const deviceSecuritySchema = z.object({
     /** Count of pending OS updates (null when not collected, e.g. macOS). */
     pendingUpdates: z.number().int().nonnegative().nullable(),
     /**
-     * Correctifs de **sécurité** en attente, distingués du total.
-     *
-     * La distinction porte toute la valeur du signal : quarante mises à jour
-     * dont aucune de sécurité n'est qu'un retard d'entretien, tandis qu'une
-     * seule faille non corrigée est une porte. Ces champs sont facultatifs et
-     * défaillent à `null` — un agent antérieur à Sentinelle n'en dit rien, et
+     * Correctifs de sécurité en attente, distingués du total : quarante mises à
+     * jour sans sécurité ne sont qu'un retard d'entretien, une seule faille non
+     * corrigée est une porte. `null` quand l'agent ne le dit pas, et
      * `posture.updates_stale` reste alors muette.
      */
     pendingSecurityUpdates: z.number().int().nonnegative().nullable().default(null),
@@ -226,20 +210,10 @@ export const agentInfoSchema = z.object({
     /** True when launched by a service manager (so a self-update just exits to be relaunched). */
     managed: z.boolean().default(false),
     /**
-     * Ce que cet agent sait relever, déclaré par lui-même.
-     *
-     * Sans cette liste, rien ne distingue « la sonde a échoué » d'« un agent
-     * trop ancien pour l'avoir ». Les deux rendent `null`, et l'interface
-     * afficherait le même vide pour deux situations qui n'appellent pas la même
-     * réaction — mettre l'agent à jour, ou aller regarder la machine.
-     *
-     * On ne peut pas s'en remettre à la version : elle est injectée à la
-     * compilation par la CI et vaut `0.0.0` sur une construction locale. Une
-     * capacité déclarée est de toute façon plus honnête qu'un numéro dont on
-     * déduirait ce qu'il contient.
-     *
-     * Vide par défaut : un agent antérieur à Sentinelle ne dit rien, et c'est
-     * exactement ce qu'il faut comprendre.
+     * Ce que cet agent sait relever, déclaré par lui-même : distingue « la
+     * sonde a échoué » d'« un agent trop ancien pour l'avoir », que la version
+     * ne dit pas (elle vaut `0.0.0` sur une construction locale). Vide par
+     * défaut : un agent qui ne dit rien n'a pas ces sondes.
      */
     probes: z.array(z.string().max(32)).max(16).default([])
 });
@@ -320,11 +294,9 @@ export const deviceHardwareSchema = z.object({
         .catch([])
         .default([]),
     /**
-     * Network interfaces (best-effort; may be empty). A container host can expose
-     * dozens of virtual `veth*`/`br-*` devices, so an over-long list is *truncated*
-     * (and any residual error degrades to `[]`) rather than rejecting the whole
-     * report — one noisy field must never drop the agent's entire posture, which is
-     * validated at the agent socket's ingress (`deviceReportSchema`).
+     * Network interfaces (best-effort). A container host can expose dozens of
+     * virtual `veth*`/`br-*` devices, so an over-long list is truncated (and a
+     * residual error degrades to `[]`) rather than rejecting the whole report.
      */
     network: z
         .preprocess(
@@ -352,15 +324,9 @@ export const deviceReportSchema = z.object({
     security: deviceSecuritySchema,
     /** Per-disk usage (deduped across shared APFS volumes). Empty if unknown. */
     disks: z.array(reportDiskSchema).default([]),
-    /**
-     * The agent's runtime identity (privilege level + account). `null` on legacy
-     * reports stored before this field existed; the agent always sends it now.
-     */
+    /** The agent's runtime identity. `null` on reports stored before this field existed. */
     agent: agentInfoSchema.nullable().default(null),
-    /**
-     * Static hardware inventory (CPU, RAM, GPU, network, bluetooth). `null` on
-     * legacy reports stored before this field existed; the agent always sends it.
-     */
+    /** Static hardware inventory. `null` on reports stored before this field existed. */
     hardware: deviceHardwareSchema.nullable().default(null),
     /**
      * Listening sockets, one entry per bind address. `null` = not collected
@@ -378,25 +344,16 @@ export const deviceReportSchema = z.object({
 
 export type DeviceReport = z.infer<typeof deviceReportSchema>;
 
-// ─────────────────────── relevés Sentinelle (persistance, auth) ──────────────
-//
-// Deux relevés de plus, volontairement **hors** de `deviceReportSchema`.
-//
-// Le rapport est un « dernier état connu » : le serveur n'en garde qu'un par
-// appareil, écrasé à chaque envoi. Cela convient à la posture, pas à ces
-// deux-là. Le manifeste de persistance est trop gros pour être réécrit en
-// entier chaque heure dans `devices.report_json`, et la fenêtre
-// d'authentification est **additive** — l'écraser perdrait des tentatives, ce
-// qui est précisément ce qu'on cherche à compter.
+// Relevés Sentinelle, volontairement hors de `deviceReportSchema` : le rapport
+// est un « dernier état connu » écrasé à chaque envoi, alors que le manifeste
+// de persistance est trop gros pour être réécrit chaque heure et que la
+// fenêtre d'authentification est additive (l'écraser perdrait des tentatives).
 
 /**
- * Une entrée d'une surface de persistance : l'endroit où un programme s'installe
- * pour survivre au redémarrage.
- *
- * **Jamais le contenu du fichier** — seulement son empreinte et ses métadonnées.
- * C'est ce qui rend la sonde acceptable sur une machine partagée : elle prouve
- * qu'un fichier a changé sans jamais révéler ce qu'il contient, et un `sha256`
- * suffit entièrement au diff que le serveur en fait.
+ * Une entrée d'une surface de persistance : l'endroit où un programme
+ * s'installe pour survivre au redémarrage. Jamais le contenu du fichier,
+ * seulement son empreinte et ses métadonnées : la sonde prouve qu'un fichier a
+ * changé sans révéler ce qu'il contient.
  */
 export const persistenceEntrySchema = z.object({
     /** Famille d'origine : `cron`, `systemd`, `launchd`, `authorized_keys`, `sudoers`, `run_key`, `scheduled_task`… */
@@ -430,11 +387,9 @@ export const integrityReportSchema = z.object({
 export type IntegrityReport = z.infer<typeof integrityReportSchema>;
 
 /**
- * Une adresse et ce qu'elle a tenté, sur la fenêtre écoulée.
- *
- * `users` porte les comptes **visés**, pas les comptes d'utilisateurs suivis :
- * savoir qu'une adresse chinoise a essayé `root`, `admin` puis `oracle` est ce
- * qui distingue un balayage automatique d'une erreur de frappe.
+ * Une adresse et ce qu'elle a tenté sur la fenêtre écoulée. `users` porte les
+ * comptes visés : `root`, `admin` puis `oracle` distingue un balayage d'une
+ * erreur de frappe.
  */
 export const authSourceSchema = z.object({
     address: z.string().min(1).max(64),
@@ -458,13 +413,10 @@ export const AUTH_SOURCE_LIMIT = 50;
 export const AUTH_LOGIN_LIMIT = 50;
 
 /**
- * Les issues d'authentification sur une fenêtre glissante.
- *
- * Des **compteurs**, pas un flux de journal : l'agent lit les journaux, en
- * extrait des totaux et une liste bornée d'adresses, et n'envoie que cela. Ce
- * n'est pas une optimisation de taille, c'est la frontière de la feature — un
- * flux brut aurait remonté des lignes de commande sudo et des noms de service,
- * c'est-à-dire l'activité des gens.
+ * Les issues d'authentification sur une fenêtre glissante. Des compteurs, pas
+ * un flux de journal : c'est la frontière de la feature, un flux brut aurait
+ * remonté des lignes de commande sudo et des noms de service, c'est-à-dire
+ * l'activité des gens.
  */
 export const authWindowSchema = z.object({
     /** Bornes de la fenêtre, unix ms. `from` = fin de la fenêtre précédente. */
@@ -483,9 +435,8 @@ export const authWindowSchema = z.object({
     topSources: z.array(authSourceSchema).max(AUTH_SOURCE_LIMIT).default([]),
     logins: z.array(authLoginSchema).max(AUTH_LOGIN_LIMIT).default([]),
     /**
-     * La source n'a pas pu être lue (pas de journal, pas les droits). Distinguer
-     * « zéro tentative » de « je n'ai pas pu regarder » : sans ce drapeau, une
-     * machine aveugle passerait pour une machine tranquille.
+     * La source n'a pas pu être lue (pas de journal, pas les droits) : sans ce
+     * drapeau, une machine aveugle passerait pour une machine tranquille.
      */
     unavailable: z.boolean().default(false)
 });

package/src/domain/secrecy.ts

@@ -26,11 +26,9 @@ export const secrecyStatusSchema = z.object({
      */
     reAuthInterval: z.number().int().min(0).nullable(),
     /**
-     * Epoch ms at which the current grace window expires (when the cached DEK
-     * will be flushed if no further activity slides it forward). `null` when the
-     * session isn't unlocked, when the feature is off, or in "validate on every
-     * action" mode — i.e. whenever there is no countdown to display. Lets the
-     * topbar timer widget render a live progress bar without guessing the window.
+     * Epoch ms at which the grace window expires (cached DEK flushed unless
+     * activity slides it forward). `null` when there is no countdown: session
+     * locked, feature off, or "validate on every action" mode.
      */
     unlockedUntil: z.number().int().nullable()
 });

package/src/domain/sharing.ts

@@ -1,37 +1,19 @@
 import { z } from 'zod';
 
-import { featureAccessSchema, workspaceFeatureIdSchema } from './workspaceRole';
+import { featureAccessSchema, featureIdSchema } from './workspaceRole';
 
 /**
- * Rendre un élément visible depuis un autre espace, **sans le déplacer**.
+ * Rendre un élément visible depuis un autre espace, sans le déplacer.
  *
- * ## L'invariant, avant tout le reste
+ * Invariant : un élément partagé ne change jamais de clé. Il reste chiffré sous
+ * celle de son espace d'origine et, servi ailleurs, est déchiffré avec le codec
+ * ouvert de cet espace-là (levier L3 de `WORKSPACES.md`). Partager est une
+ * projection, pas un transfert. Seule la clé de l'étage ouvert étant résoluble
+ * par le serveur seul, un élément de l'étage gardé ne peut pas être partagé
+ * (voir `shareTier` dans le registre).
  *
- * Un élément partagé **ne change jamais de clé**. Il reste chiffré sous celle de
- * son espace d'origine ; servi ailleurs, il est déchiffré avec le codec ouvert
- * de cet espace-là. C'est le prolongement direct du levier L3 de
- * `WORKSPACES.md`, « chaque espace a sa clé, et un blob n'en change jamais »,
- * et la raison pour laquelle ce chantier ne re-chiffre rien.
- *
- * `WORKSPACES.md` §10 range **déplacer** un élément hors périmètre, précisément
- * parce que ce serait la seule opération à exiger un déchiffrement clé A puis un
- * re-chiffrement clé B sous session vivante. Partager ne l'exige pas : c'est une
- * **projection**, pas un transfert. L'élément a un seul domicile, et des
- * fenêtres ailleurs.
- *
- * ## Ce qui en découle, et qu'il faut assumer
- *
- * Seule la clé de l'étage ouvert est résoluble par le serveur seul. Un élément
- * de l'étage gardé ne peut donc pas être partagé — pas par prudence, par
- * impossibilité mécanique. Voir `shareTier` dans le registre.
- *
- * ## On ne partage qu'avec soi-même
- *
- * La liste proposée est celle des espaces **dont l'appelant est membre**. Ce
- * n'est pas une restriction d'interface mais la règle : partager vers un espace
- * où l'on n'entre pas reviendrait à y déposer une donnée sans pouvoir en
- * répondre, et à contourner l'appartenance — qui est la frontière absolue du
- * modèle (`WORKSPACES.md` §3).
+ * On ne partage qu'avec les espaces dont l'appelant est membre : l'appartenance
+ * est la frontière absolue du modèle (`WORKSPACES.md` §3).
  */
 
 export const itemShareSchema = z.object({
@@ -42,25 +24,19 @@ export const itemShareSchema = z.object({
     isHome: z.boolean(),
     shared: z.boolean(),
     /**
-     * L'appelant peut régler, **depuis ici**, ce que chaque rôle de cet espace
-     * voit de l'élément (`share.grantList` / `share.grantSet` avec ce
-     * `workspaceId`).
-     *
-     * Vrai quand l'élément y est visible, que l'espace est partagé (un espace
-     * personnel n'a pas de rôles) et que l'appelant y tient `workspace.roles`.
-     * C'est ce qui permet de gérer les permissions de toutes les fenêtres
-     * depuis l'onglet Partage, sans changer d'espace.
+     * L'appelant peut régler d'ici ce que chaque rôle de cet espace voit de
+     * l'élément (`share.grantList` / `share.grantSet` avec ce `workspaceId`) :
+     * l'élément y est visible, l'espace est partagé et l'appelant y tient
+     * `workspace.roles`.
      */
     grantsManageable: z.boolean()
 });
 export type ItemShare = z.infer<typeof itemShareSchema>;
 
 /**
- * Pourquoi un élément ne peut pas être partagé, quand c'est le cas.
- *
- * Une phrase plutôt qu'un booléen : « impossible » sans raison donne à chercher
- * un réglage qui n'existe pas. Ici la cause est toujours structurelle, et la
- * dire évite qu'on la prenne pour une panne.
+ * Pourquoi un élément ne peut pas être partagé. Une raison plutôt qu'un
+ * booléen : la cause est toujours structurelle, et la dire évite qu'on la
+ * prenne pour une panne.
  */
 export const shareBlockerSchema = z.enum([
     /** La fonctionnalité entière vit à l'étage gardé, ou n'a pas de sens ici. */
@@ -86,16 +62,10 @@ export const itemShareStateSchema = z.object({
 export type ItemShareState = z.infer<typeof itemShareStateSchema>;
 
 /**
- * Ce qu'un rôle peut faire sur **un** élément.
- *
- * Volontairement **restrictif seulement** : `none` ou `read` abaissent ce que le
- * rôle a sur la fonctionnalité, jamais l'inverse. Le droit de feature reste le
- * plafond, ici comme pour les droits fins.
- *
- * L'alternative — permettre d'élever — a été écartée : l'accès effectif à une
- * fonctionnalité deviendrait « le maximum entre le rôle et le meilleur droit
- * d'élément », donc une requête de plus dans la résolution d'accès, et surtout
- * un écran des rôles qui ne dirait plus à lui seul qui voit quoi.
+ * Ce qu'un rôle peut faire sur un élément. Restrictif seulement : `none` ou
+ * `read` abaissent ce que le rôle a sur la fonctionnalité, jamais l'inverse ;
+ * le droit de feature reste le plafond, et l'écran des rôles dit à lui seul
+ * qui voit quoi.
  */
 export const itemAccessSchema = z.enum(['none', 'read']);
 export type ItemAccess = z.infer<typeof itemAccessSchema>;
@@ -108,13 +78,9 @@ export const itemRoleGrantSchema = z.object({
 export type ItemRoleGrant = z.infer<typeof itemRoleGrantSchema>;
 
 /**
- * Un rôle d'un espace, vu depuis l'écran des restrictions d'un élément.
- *
- * Porte tout ce que l'écran affiche, pour qu'il n'ait **aucun** recoupement à
- * faire : l'identité du rôle, ce que la fonctionnalité lui donne (le droit
- * *hérité*, affiché même quand aucune exception n'est posée — une vue
- * d'ensemble qui ne montre que les exceptions oblige à deviner le reste), et
- * l'exception posée s'il y en a une.
+ * Un rôle d'un espace, vu depuis l'écran des restrictions d'un élément : son
+ * identité, le droit hérité de la fonctionnalité (affiché même sans exception)
+ * et l'exception posée s'il y en a une.
  */
 export const itemRoleGrantViewSchema = z.object({
     roleId: z.number().int().positive(),
@@ -138,24 +104,21 @@ export const itemGrantStateSchema = z.object({
 });
 export type ItemGrantState = z.infer<typeof itemGrantStateSchema>;
 
-/** La cible d'un partage ou d'une restriction. */
+/**
+ * La cible d'un partage ou d'une restriction. `featureIdSchema` et non l'enum
+ * natif : les éléments d'un module se projettent comme ceux d'une native.
+ */
 export const itemRefSchema = z.object({
-    feature: workspaceFeatureIdSchema,
+    feature: featureIdSchema,
     itemId: z.number().int().positive()
 });
 export type ItemRef = z.infer<typeof itemRefSchema>;
 
 /**
- * Une référence qu'on voit sans pouvoir la lire.
- *
- * Le cas : un élément partagé vers B pointe une donnée de A — un compte mail, un
- * appareil, un canal d'alerte. Un membre de B qui n'est pas membre de A doit
- * **savoir que le lien existe** sans en connaître le contenu. Le masquer
- * entièrement ferait croire à un élément mal réglé ; le montrer ferait fuiter
- * l'espace d'origine.
- *
- * Il peut la **retirer** si ses droits le permettent — retirer un lien ne
- * demande pas de le lire. Il ne peut ni le voir ni le modifier.
+ * Une référence qu'on voit sans pouvoir la lire : un élément partagé vers B
+ * pointe une donnée de A (compte mail, appareil, canal). Un membre de B non
+ * membre de A doit savoir que le lien existe sans en connaître le contenu ; il
+ * peut le retirer si ses droits le permettent, ni le voir ni le modifier.
  */
 export const foreignRefSchema = z.object({
     kind: z.literal('inaccessible'),

package/src/domain/syncProtocol.ts

@@ -32,13 +32,10 @@ export const SYNC_FINGERPRINT_SEP = '\u0001';
 export const syncScanModeSchema = z.enum(['auto', 'full']);
 export type SyncScanMode = z.infer<typeof syncScanModeSchema>;
 /**
- * Empreinte d'un index : `{nombre}.{octets}.{sha256hex}`.
- *
- * Le pli est un XOR des hachages par ligne, donc INDÉPENDANT DE L'ORDRE, et
- * c'est délibéré : un tri obligerait Rust (ordre octet UTF-8) et TypeScript
- * (ordre unité UTF-16) à s'accorder sur les caractères hors BMP, ce qu'ils ne
- * font pas. Un seul emoji dans un nom de fichier aurait alors désactivé le
- * chemin rapide pour toujours, sans que rien ne le signale.
+ * Empreinte d'un index : `{nombre}.{octets}.{sha256hex}`. Le pli est un XOR des
+ * hachages par ligne, donc INDÉPENDANT DE L'ORDRE, à dessein : un tri obligerait
+ * Rust (ordre octet UTF-8) et TypeScript (ordre unité UTF-16) à s'accorder sur
+ * les caractères hors BMP, ce qu'ils ne font pas.
  */
 export const syncIndexFingerprintSchema = z.string().regex(/^\d+\.\d+\.[0-9a-f]{64}$/);
 /** SHA-256 hexadécimal (du clair d'un fichier, ou d'un chemin normalisé). */
@@ -93,11 +90,7 @@ export const cloudSyncProgressSchema = z.object({
     bytesDone: z.number().int().nonnegative(),
     /** Fichier en cours de transfert, pour la ligne discrète de l'UI. */
     currentPath: z.string().max(SYNC_REL_PATH_MAX).nullable(),
-    /**
-     * Avancement DANS le fichier en cours. Sans ça, un fichier de plusieurs Go
-     * laissait la barre parfaitement figée du début à la fin de son transfert :
-     * les octets n'étaient comptés qu'une fois le fichier terminé.
-     */
+    /** Avancement dans le fichier en cours, pour qu'un gros fichier ne fige pas la barre. */
     currentBytes: z.number().int().nonnegative(),
     currentTotal: z.number().int().nonnegative(),
     direction: syncDirectionSchema.nullable(),

package/src/domain/user.ts

@@ -30,14 +30,12 @@ export const userColorSchema = z.enum([
 ]);
 export type UserColor = z.infer<typeof userColorSchema>;
 
-/** L'ordre fait foi : `defaultUserColor` et la migration 059 l'indexent tous deux. */
+/** L'ordre fait foi : il est indexé par `defaultUserColor` et en base. */
 export const USER_COLORS = userColorSchema.options;
 
 /**
- * Teinte attribuée d'office à un compte, depuis son identifiant. Deux comptes
- * créés à la suite n'ont pas la même, et aucun compte n'existe sans couleur —
- * la migration 059 colorie l'existant, `usersRepo.create` fait de même à
- * l'inscription.
+ * Teinte attribuée d'office à un compte depuis son identifiant : deux comptes
+ * créés à la suite n'ont pas la même.
  */
 export function defaultUserColor(userId: number): UserColor {
     return USER_COLORS[Math.abs(userId) % USER_COLORS.length];
@@ -76,17 +74,13 @@ export const userSecuritySchema = z.object({
 export type UserSecurity = z.infer<typeof userSecuritySchema>;
 
 /**
- * Drapeaux de compte, rangés dans `users.settings` — un simple sac de chaînes.
- *
- * L'**absence** d'un drapeau est sa valeur par défaut : un compte créé avant
- * qu'un drapeau existe se comporte donc comme le reste, sans migration ni
- * rattrapage. C'est ce qui fait de cette colonne le bon endroit pour un réglage
- * booléen privé, là où une colonne dédiée (le modèle de `color`) se justifie
- * quand la valeur n'est pas binaire ou qu'elle intéresse d'autres comptes.
+ * Drapeaux de compte, rangés dans `users.settings` (un sac de chaînes).
+ * L'absence d'un drapeau est sa valeur par défaut : aucune migration quand un
+ * drapeau apparaît.
  *
  * - `hideLiveCursors` : ne pas afficher les curseurs des autres membres. La
- *   coupure est **réciproque** — le client cesse aussi d'émettre le sien (voir
- *   `live/LiveProvider.tsx`), si bien qu'on ne peut pas regarder sans être vu.
+ *   coupure est réciproque : le client cesse aussi d'émettre le sien, on ne
+ *   peut pas regarder sans être vu.
  */
 export const userSettingFlagSchema = z.enum(['hideLiveCursors']);
 export type UserSettingFlag = z.infer<typeof userSettingFlagSchema>;

package/src/domain/workspace.ts

@@ -8,9 +8,6 @@ import { minimalUserSchema } from './user';
  *   quittable ni supprimable, jamais partageable. C'est le repli implicite quand
  *   une commande ne vise aucun espace en particulier.
  * - `shared` : créé à la demande, plusieurs membres, rôles et invitations.
- *
- * Les deux sont de vraies lignes de `workspaces` : il n'existe plus d'espace
- * virtuel d'id 0.
  */
 export const workspaceKindSchema = z.enum(['personal', 'shared']);
 export type WorkspaceKind = z.infer<typeof workspaceKindSchema>;