@deveye/types 0.15.0

package/src/domain/project.ts

@@ -0,0 +1,168 @@
+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.
+ */
+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;
+}

package/src/domain/projectBoard.ts

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+
+/**
+ * Le tableau d'un projet : ses colonnes, et les « blocs » qui y circulent.
+ *
+ * Découpage clair / chiffré, comme partout dans ce module. En **clair** tout ce
+ * qui sert à ordonner, filtrer et compter sans clé — `column_id`, `sort_order`,
+ * `assignee_user_id`, `priority`, les dates, `archived_at`, `message_count`.
+ * **Chiffré** le titre, la description et la liste de sous-tâches.
+ *
+ * `assignee_user_id` reste en clair à dessein : c'est ce qui rend « toutes mes
+ * tâches, tous projets confondus » possible en une requête, et le serveur
+ * connaît déjà l'appartenance à l'espace — il n'apprend rien de neuf.
+ */
+
+export const PROJECT_COLUMN_NAME_MAX_LENGTH = 48;
+export const PROJECT_MAX_COLUMNS = 12;
+export const PROJECT_CARD_TITLE_MAX_LENGTH = 160;
+export const PROJECT_CARD_DESCRIPTION_MAX_LENGTH = 4000;
+export const PROJECT_CHECKLIST_LABEL_MAX_LENGTH = 160;
+export const PROJECT_MAX_CHECKLIST_ITEMS = 50;
+
+/**
+ * Priorité d'une carte.
+ *
+ * **L'indice dans ce tableau est la valeur stockée** (`project_cards.priority`,
+ * un TINYINT) : `none` = 0 … `high` = 3. Un enum de chaînes côté fil pour que le
+ * code soit lisible, un entier en base pour que le tri reste du SQL. Ne jamais
+ * réordonner ces valeurs — ce serait réétiqueter toutes les cartes existantes.
+ */
+export const projectPrioritySchema = z.enum(['none', 'low', 'normal', 'high']);
+export type ProjectPriority = z.infer<typeof projectPrioritySchema>;
+export const PROJECT_PRIORITIES = projectPrioritySchema.options;
+
+/** Une sous-tâche. `id` est engendré par le client : c'est sa clé de rendu. */
+export const projectChecklistItemSchema = z.object({
+    id: z.string().min(1).max(64),
+    label: z.string().max(PROJECT_CHECKLIST_LABEL_MAX_LENGTH),
+    done: z.boolean()
+});
+export type ProjectChecklistItem = z.infer<typeof projectChecklistItemSchema>;
+
+export const projectColumnSchema = z.object({
+    id: z.number().int().positive(),
+    projectId: z.number().int().positive(),
+    name: z.string().max(PROJECT_COLUMN_NAME_MAX_LENGTH),
+    sortOrder: z.number().int().nonnegative(),
+    /**
+     * Cette colonne vaut « terminé ». En clair, et c'est ce qui rend
+     * l'avancement d'un projet calculable en SQL sans déchiffrer son nom.
+     */
+    countsAsDone: z.boolean(),
+    /** Limite de travail en cours ; `null` = aucune. Indicative, jamais bloquante. */
+    wipLimit: z.number().int().positive().nullable()
+});
+export type ProjectColumn = z.infer<typeof projectColumnSchema>;
+
+export const projectCardSchema = z.object({
+    id: z.number().int().positive(),
+    projectId: z.number().int().positive(),
+    columnId: z.number().int().positive(),
+    title: z.string().max(PROJECT_CARD_TITLE_MAX_LENGTH),
+    description: z.string().max(PROJECT_CARD_DESCRIPTION_MAX_LENGTH),
+    checklist: z.array(projectChecklistItemSchema).max(PROJECT_MAX_CHECKLIST_ITEMS),
+    sortOrder: z.number().int().nonnegative(),
+    priority: projectPrioritySchema,
+    /** `null` quand le compte a été supprimé depuis (voir la migration). */
+    authorUserId: z.number().int().positive().nullable(),
+    /** Membre de l'espace à qui la carte est attribuée ; `null` = personne. */
+    assigneeUserId: z.number().int().positive().nullable(),
+    startDate: z.number().int().nullable(),
+    dueDate: z.number().int().nullable(),
+    estimateMinutes: z.number().int().nonnegative().nullable(),
+    milestoneId: z.number().int().positive().nullable(),
+    archived: z.boolean(),
+    archivedAt: z.number().int().nullable(),
+    /** Total des messages du fil, et ce que l'appelant n'a pas encore lu. */
+    messageCount: z.number().int().nonnegative(),
+    unread: z.number().int().nonnegative(),
+    created: z.number().int(),
+    updated: z.number().int()
+});
+export type ProjectCard = z.infer<typeof projectCardSchema>;
+
+/** Ce que le client peut poser sur une carte. */
+export const projectCardDraftSchema = z.object({
+    title: z.string().min(1).max(PROJECT_CARD_TITLE_MAX_LENGTH),
+    description: z.string().max(PROJECT_CARD_DESCRIPTION_MAX_LENGTH),
+    checklist: z.array(projectChecklistItemSchema).max(PROJECT_MAX_CHECKLIST_ITEMS),
+    priority: projectPrioritySchema,
+    assigneeUserId: z.number().int().positive().nullable(),
+    startDate: z.number().int().nullable(),
+    dueDate: z.number().int().nullable(),
+    estimateMinutes: z.number().int().nonnegative().nullable()
+});
+export type ProjectCardDraft = z.infer<typeof projectCardDraftSchema>;
+
+/** Ligne SQL (serveur uniquement). */
+export interface ProjectColumnRow {
+    id: number;
+    project_id: number;
+    workspace_id: number;
+    sort_order: number;
+    counts_as_done: number;
+    wip_limit: number | null;
+    content: string;
+    created: number;
+}
+
+/** Ligne SQL (serveur uniquement). */
+export interface ProjectCardRow {
+    id: number;
+    project_id: number;
+    workspace_id: number;
+    column_id: number;
+    sort_order: number;
+    author_user_id: number | null;
+    assignee_user_id: number | null;
+    priority: number;
+    start_date: number | null;
+    due_date: number | null;
+    estimate_minutes: number | null;
+    milestone_id: number | null;
+    archived_at: number | null;
+    message_count: number;
+    last_message_at: number | null;
+    content: string;
+    created: number;
+    updated: number;
+}

package/src/domain/projectChat.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+
+/**
+ * Le fil de discussion d'une carte.
+ *
+ * Découpage clair / chiffré, comme le reste du module : le **texte** est
+ * chiffré sous l'étage du projet ; l'auteur, l'horodatage et les mentions
+ * restent en colonnes claires.
+ *
+ * Les mentions en clair, c'est délibéré : ce sont des identifiants de membres
+ * de l'espace, que le serveur connaît déjà par `workspace_members`. Les garder
+ * lisibles est ce qui permet de compter « mes mentions non lues » sans
+ * déchiffrer un seul message.
+ */
+
+export const PROJECT_MESSAGE_MAX_LENGTH = 4000;
+
+/** Combien de messages une page de fil rend au plus. */
+export const PROJECT_MESSAGE_PAGE_SIZE = 60;
+
+export const projectMessageSchema = z.object({
+    id: z.number().int().positive(),
+    cardId: z.number().int().positive(),
+    /** `null` quand le compte a été supprimé depuis : le message, lui, reste. */
+    authorUserId: z.number().int().positive().nullable(),
+    text: z.string().max(PROJECT_MESSAGE_MAX_LENGTH),
+    mentions: z.array(z.number().int().positive()),
+    created: z.number().int(),
+    /** Horodatage de la dernière retouche, ou `null` si jamais modifié. */
+    edited: z.number().int().nullable()
+});
+export type ProjectMessage = z.infer<typeof projectMessageSchema>;
+
+/** Ligne SQL (serveur uniquement). */
+export interface ProjectMessageRow {
+    id: number;
+    card_id: number;
+    project_id: number;
+    workspace_id: number;
+    author_user_id: number | null;
+    /** Tableau JSON d'identifiants de membres, ou `null`. */
+    mentions: string | null;
+    created: number;
+    edited: number | null;
+    content: string;
+}

package/src/domain/projectHistory.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+
+/**
+ * L'historique d'un projet : la frise verticale de tout ce qui lui est arrivé.
+ *
+ * C'est le pendant du principe « rien ne se supprime, tout s'archive ». Un bloc
+ * archivé quitte l'espace de travail mais reste ici, consultable en lecture
+ * seule ; un renommage, un changement de version ou de statut y laisse aussi sa
+ * trace. L'historique est donc la mémoire du projet, pas un journal technique —
+ * ce dernier existe déjà, c'est l'audit (`ctx.audit`, page Journaux).
+ *
+ * Découpage clair / chiffré : le **type**, l'auteur, l'horodatage et la
+ * référence à l'objet concerné sont en clair (ils servent à trier et à router
+ * sans clé) ; le libellé et le avant/après sont chiffrés — ce sont eux qui
+ * portent le contenu.
+ */
+
+export const PROJECT_EVENT_LABEL_MAX_LENGTH = 200;
+export const PROJECT_EVENT_PAGE_SIZE = 50;
+
+/**
+ * Ce qui mérite d'entrer dans l'histoire d'un projet.
+ *
+ * Volontairement court : une frise qui consigne tout ne se lit plus. Y figurent
+ * les changements qu'on cherche des mois plus tard — « quand a-t-on archivé
+ * ça ? », « depuis quand est-on en v2 ? » — et rien du va-et-vient quotidien
+ * des cartes entre colonnes.
+ */
+export const projectEventKindSchema = z.enum([
+    'project.created',
+    'project.renamed',
+    'project.version',
+    'project.status',
+    'project.securityTier',
+    'project.archived',
+    'project.restored',
+    'card.archived',
+    'card.restored',
+    'milestone.reached',
+    'deploy.triggered',
+    'deploy.succeeded',
+    'deploy.failed'
+]);
+export type ProjectEventKind = z.infer<typeof projectEventKindSchema>;
+
+/** Ce que la référence désigne, pour que la frise sache quoi ouvrir. */
+export const projectEventRefSchema = z.enum(['card', 'milestone']);
+export type ProjectEventRef = z.infer<typeof projectEventRefSchema>;
+
+export const projectEventSchema = z.object({
+    id: z.number().int().positive(),
+    projectId: z.number().int().positive(),
+    /** `null` = une tâche de fond, ou un compte supprimé depuis. */
+    actorUserId: z.number().int().positive().nullable(),
+    /**
+     * Un type inconnu ne fait pas disparaître la ligne : un client plus ancien
+     * qu'un serveur doit encore pouvoir lire la frise, quitte à afficher une
+     * entrée générique. Même parti pris que `shortcutTemplateSchema`.
+     */
+    kind: projectEventKindSchema.catch('project.status'),
+    refType: projectEventRefSchema.nullable(),
+    refId: z.number().int().positive().nullable(),
+    label: z.string().max(PROJECT_EVENT_LABEL_MAX_LENGTH),
+    /** Avant / après, quand le changement en a un (renommage, version, statut). */
+    from: z.string().max(PROJECT_EVENT_LABEL_MAX_LENGTH).nullable(),
+    to: z.string().max(PROJECT_EVENT_LABEL_MAX_LENGTH).nullable(),
+    created: z.number().int()
+});
+export type ProjectEvent = z.infer<typeof projectEventSchema>;
+
+/** Ligne SQL (serveur uniquement). */
+export interface ProjectEventRow {
+    id: number;
+    project_id: number;
+    workspace_id: number;
+    actor_user_id: number | null;
+    kind: string;
+    ref_type: string | null;
+    ref_id: number | null;
+    created: number;
+    content: string;
+}

package/src/domain/projectLink.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { projectCardSchema } from './projectBoard';
+
+/**
+ * Ce qui relie un projet au reste de DevEye, et ce qui relie une personne à ses
+ * tâches à travers tous les projets.
+ *
+ * Deux notions transverses réunies ici parce qu'elles répondent à la même
+ * question posée dans les deux sens : « qu'est-ce qui touche ce projet ? » et
+ * « qu'est-ce qui me touche, moi, dans tous les projets ? ».
+ */
+
+/**
+ * Ce qui relie un projet à un service surveillé.
+ *
+ * On ne stocke que l'identifiant : la cible garde ses propres droits, et rien
+ * d'identifiant n'a besoin d'être chiffré. Un membre sans accès à Uptime voit
+ * qu'il y a des services rattachés sans pouvoir les nommer — c'est la feature
+ * visée qui tranche, pas celle-ci.
+ *
+ * La liaison est **non exclusive dans les deux sens** : un projet suit plusieurs
+ * services, et un même service peut être suivi par plusieurs projets. Même forme
+ * que la liaison au dépôt git, et pour la même raison — ce sont deux objets
+ * d'espace, pas des propriétés d'un projet.
+ */
+
+/**
+ * Une tâche qui m'est attribuée, vue depuis l'extérieur de son projet.
+ *
+ * `masked` marque une carte d'un projet confidentiel verrouillé : elle est
+ * comptée et située, mais son titre reste illisible. La faire disparaître
+ * donnerait une liste de tâches fausse, ce qui est pire que de dire « il y a
+ * quelque chose ici que tu ne peux pas lire maintenant ».
+ */
+export const myTaskSchema = z.object({
+    card: projectCardSchema,
+    projectId: z.number().int().positive(),
+    projectTitle: z.string(),
+    masked: z.boolean()
+});
+export type MyTask = z.infer<typeof myTaskSchema>;
+
+/**
+ * Combien d'éléments chaque intégration d'un projet a à montrer.
+ *
+ * Des **compteurs seulement** : ils décident si l'écran a quelque chose à
+ * ouvrir, pas ce qu'il montrera. Un projet neuf n'a ni dépôt, ni base, ni site,
+ * ni déploiement — lui présenter quatre onglets vides revient à lui demander de
+ * fouiller pour trouver le vide. Zéro fait donc disparaître l'onglet, et le
+ * geste d'ajout se replie dans un menu unique.
+ *
+ * Les clés portent le nom de la **feature d'espace** pointée (`git`,
+ * `database`, `audience`), pas celui de l'onglet qui les affiche : ce sont les
+ * mêmes identifiants que les droits (`workspaceFeatureIdSchema`), et c'est ce
+ * qui permet à l'appelant de demander « ai-je le droit d'y ajouter ? » sans
+ * table de correspondance.
+ *
+ * Un compte ne dit rien de ce que l'appelant a le droit de **lire** : les
+ * liaisons relèvent de `projects`, leur contenu de la feature visée. Un membre
+ * sans accès à Git voit donc l'onglet Git et, dedans, la phrase qui explique ce
+ * qui lui manque — plutôt qu'un onglet escamoté qui lui cacherait l'existence
+ * même du lien.
+ */
+export const projectLinkCountsSchema = z.object({
+    /** Dépôts reliés. */
+    git: z.number().int().nonnegative(),
+    /** Bases de données reliées. */
+    database: z.number().int().nonnegative(),
+    /** Sites suivis reliés. */
+    audience: z.number().int().nonnegative(),
+    /**
+     * La cible de déploiement (0 ou 1) **plus** les services surveillés
+     * rattachés. Les deux vivent dans le même onglet : compter la seule cible
+     * ferait disparaître un onglet qui a encore de quoi répondre à « est-ce en
+     * ligne ? ».
+     */
+    deploy: z.number().int().nonnegative()
+});
+export type ProjectLinkCounts = z.infer<typeof projectLinkCountsSchema>;
+
+/** Ligne SQL (serveur uniquement). */
+export interface ProjectUptimeLinkRow {
+    project_id: number;
+    service_id: number;
+    workspace_id: number;
+    created: number;
+}

package/src/domain/projectPlan.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+
+/**
+ * La planification d'un projet : ses jalons, et les dépendances entre cartes.
+ *
+ * Ce sont les deux choses que le kanban ne sait pas dire. Un tableau montre
+ * *où en est* chaque carte ; une frise montre *quand*, et ce qui attend quoi.
+ *
+ * Découpage clair / chiffré habituel : les dates, l'atteinte et le graphe des
+ * dépendances sont en colonnes claires — c'est ce qui permet de dessiner la
+ * frise et de détecter un cycle sans déchiffrer quoi que ce soit. Seuls le nom
+ * et la description d'un jalon sont chiffrés.
+ */
+
+export const PROJECT_MILESTONE_NAME_MAX_LENGTH = 80;
+export const PROJECT_MILESTONE_DESCRIPTION_MAX_LENGTH = 1000;
+
+export const projectMilestoneSchema = z.object({
+    id: z.number().int().positive(),
+    projectId: z.number().int().positive(),
+    name: z.string().max(PROJECT_MILESTONE_NAME_MAX_LENGTH),
+    description: z.string().max(PROJECT_MILESTONE_DESCRIPTION_MAX_LENGTH),
+    /** Échéance visée, en secondes unix. Un jalon est toujours daté. */
+    dueDate: z.number().int(),
+    /** Horodatage d'atteinte, ou `null` s'il est encore devant nous. */
+    reachedAt: z.number().int().nullable(),
+    sortOrder: z.number().int().nonnegative()
+});
+export type ProjectMilestone = z.infer<typeof projectMilestoneSchema>;
+
+export const projectMilestoneDraftSchema = z.object({
+    name: z.string().min(1).max(PROJECT_MILESTONE_NAME_MAX_LENGTH),
+    description: z.string().max(PROJECT_MILESTONE_DESCRIPTION_MAX_LENGTH),
+    dueDate: z.number().int()
+});
+export type ProjectMilestoneDraft = z.infer<typeof projectMilestoneDraftSchema>;
+
+/**
+ * Une dépendance : `cardId` est bloquée par `blockedByCardId`.
+ *
+ * Le sens est fixé une fois pour toutes — « bloquée par » et non « bloque » —
+ * pour qu'il n'y ait jamais à se demander dans quel sens lire une arête.
+ */
+export const projectCardDepSchema = z.object({
+    cardId: z.number().int().positive(),
+    blockedByCardId: z.number().int().positive()
+});
+export type ProjectCardDep = z.infer<typeof projectCardDepSchema>;
+
+/** Ligne SQL (serveur uniquement). */
+export interface ProjectMilestoneRow {
+    id: number;
+    project_id: number;
+    workspace_id: number;
+    due_date: number;
+    reached_at: number | null;
+    sort_order: number;
+    content: string;
+    created: number;
+}
+
+/** Ligne SQL (serveur uniquement). */
+export interface ProjectCardDepRow {
+    card_id: number;
+    blocked_by_card_id: number;
+    project_id: number;
+    created: number;
+}