Éditer le registre unique du personnel

Le bouton menait au registre de paramétrage juridique — un autre document, qui ne répond à aucune demande d'inspection. Le registre unique du personnel n'existait pas. Il se tient par établissement : celui-ci est demandé avant l'édition plutôt que déduit, car en tirer un au hasard pour une entreprise qui compte trente sites ne répondrait à rien. Une ligne par contrat et non par personne : un salarié réembauché a deux entrées et deux sorties, et les fondre effacerait l'interruption. Les partis y figurent aussi — c'est l'historique que l'inspection vient chercher. Les mentions manquantes sont annoncées avant le téléchargement, et comptées par salarié parce que la contravention l'est aussi. Découvrir un registre incomplet en l'ouvrant, c'est le découvrir devant l'inspection. L'édition est journalisée : le document rassemble l'identité, la nationalité et le parcours de tout le personnel d'un site. Une réserve, portée par le code et par le document : PlanFlow ne collecte pas le sexe, mention pourtant exigée. La colonne reste vide et alimente le décompte des dossiers incomplets, en attendant le champ. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-10 16:46:15 +02:00
1 parent 8808fcdb95
commit 3bf2cbabff
@@ -34,6 +34,7 @@
    "@prisma/client": "7.9.1",
    "next": "16.3.0",
    "nodemailer": "^9.0.5",
+    "pdf-lib": "^1.17.1",
    "pg": "8.22.0",
    "qrcode": "^1.5.4",
    "react": "19.2.8",
@@ -23,6 +23,9 @@ importers:
      nodemailer:
        specifier: ^9.0.5
        version: 9.0.5
+      pdf-lib:
+        specifier: ^1.17.1
+        version: 1.17.1
      pg:
        specifier: 8.22.0
        version: 8.22.0
@@ -769,6 +772,12 @@ packages:
  '@oxc-project/types@0.143.0':
    resolution: {integrity: sha512-u6JZdLBTLotrNC9Vd6vPssINdzcCzleKAH6EJKImQb7GtYvX5keN2dxkoK44stCc4tffE6QQRtZTXVSzsLUlWA==}

+  '@pdf-lib/standard-fonts@1.0.0':
+    resolution: {integrity: sha512-hU30BK9IUN/su0Mn9VdlVKsWBS6GyhVfqjwl1FjZN4TxP6cCw0jP2w7V3Hf5uX7M0AZJ16vey9yE0ny7Sa59ZA==}
+
+  '@pdf-lib/upng@1.0.1':
+    resolution: {integrity: sha512-dQK2FUMQtowVP00mtIksrlZhdFXQZPC+taih1q4CvPZ5vqdxR/LKBaFg0oAfzd1GlHZXXSPdQfzQnt+ViGvEIQ==}
+
  '@playwright/test@1.62.1':
    resolution: {integrity: sha512-DTcUc8qii+cpHvtOwggMtBRMjKZHXYWdw8syRYu2vtzuq4Wxphqq4NfCs5Zt44L6mA8rfDfj+PHnxFc/FeK6mQ==}
    engines: {node: '>=20'}
@@ -2689,6 +2698,9 @@ packages:
    resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
    engines: {node: '>=6'}

+  pako@1.0.11:
+    resolution: {integrity: sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==}
+
  parent-module@1.0.1:
    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
    engines: {node: '>=6'}
@@ -2707,6 +2719,9 @@ packages:
  pathe@2.0.3:
    resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}

+  pdf-lib@1.17.1:
+    resolution: {integrity: sha512-V/mpyJAoTsN4cnP31vc0wfNA1+p20evqqnap0KLoRUN0Yk/p3wN52DOEsL4oBFcLdb76hlpKPtzJIgo67j/XLw==}
+
  perfect-debounce@2.1.0:
    resolution: {integrity: sha512-LjgdTytVFXeUgtHZr9WYViYSM/g8MkcTPYDlPa3cDqMirHjKiSZPYd6DoL7pK8AJQr+uWkQvCjHNdiMqsrJs+g==}

@@ -3137,6 +3152,9 @@ packages:
  tsconfig-paths@3.15.0:
    resolution: {integrity: sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==}

+  tslib@1.14.1:
+    resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==}
+
  tslib@2.8.1:
    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}

@@ -3900,6 +3918,14 @@ snapshots:

  '@oxc-project/types@0.143.0': {}

+  '@pdf-lib/standard-fonts@1.0.0':
+    dependencies:
+      pako: 1.0.11
+
+  '@pdf-lib/upng@1.0.1':
+    dependencies:
+      pako: 1.0.11
+
  '@playwright/test@1.62.1':
    dependencies:
      playwright: 1.62.1
@@ -5943,6 +5969,8 @@ snapshots:

  p-try@2.2.0: {}

+  pako@1.0.11: {}
+
  parent-module@1.0.1:
    dependencies:
      callsites: 3.1.0
@@ -5955,6 +5983,13 @@ snapshots:

  pathe@2.0.3: {}

+  pdf-lib@1.17.1:
+    dependencies:
+      '@pdf-lib/standard-fonts': 1.0.0
+      '@pdf-lib/upng': 1.0.1
+      pako: 1.0.11
+      tslib: 1.14.1
+
  perfect-debounce@2.1.0: {}

  pg-cloudflare@1.4.0:
@@ -6432,6 +6467,8 @@ snapshots:
      minimist: 1.2.8
      strip-bom: 3.0.0

+  tslib@1.14.1: {}
+
  tslib@2.8.1: {}

  tsx@4.20.6:
@@ -0,0 +1,141 @@
+'use client';
+
+import { useEffect, useRef, useState } from 'react';
+
+import { Button } from '@/components/ui/Button';
+
+/**
+ * Édition du registre unique du personnel.
+ *
+ * L'établissement est demandé avant le téléchargement, et non déduit : le
+ * registre se tient **par établissement**, et en tirer un au hasard pour une
+ * entreprise qui en compte trente ne répondrait à aucune demande d'inspection.
+ *
+ * L'avertissement sur les mentions manquantes arrive avant le fichier, pas
+ * dedans : découvrir un registre incomplet en l'ouvrant, c'est le découvrir
+ * devant l'inspection.
+ */
+
+export interface RegisterLocation {
+  id: string;
+  name: string;
+  incomplete: number;
+  total: number;
+}
+
+export function RegisterDialog({
+  locations,
+}: {
+  locations: RegisterLocation[];
+}) {
+  const dialog = useRef<HTMLDialogElement>(null);
+  const [open, setOpen] = useState(false);
+  const [locationId, setLocationId] = useState('');
+
+  useEffect(() => {
+    const element = dialog.current;
+    if (!element) return;
+    if (open && !element.open) element.showModal();
+    if (!open && element.open) element.close();
+  }, [open]);
+
+  const chosen = locations.find((location) => location.id === locationId);
+
+  return (
+    <>
+      <Button onClick={() => setOpen(true)}>
+        Registre unique du personnel
+      </Button>
+
+      <dialog
+        ref={dialog}
+        aria-labelledby="titre-rup"
+        onClose={() => setOpen(false)}
+        className="m-auto w-[min(38rem,calc(100vw-2rem))] rounded-3 border border-line-1 bg-surface p-0 text-ink-1 backdrop:bg-[rgb(0_0_0/0.4)]"
+      >
+        <header className="flex items-center gap-3 px-5 pt-5">
+          <h2 id="titre-rup" className="text-lg font-semibold">
+            Téléchargez votre registre unique du personnel
+          </h2>
+          <span className="flex-1" />
+          <Button variant="ghost" onClick={() => setOpen(false)}>
+            Fermer
+          </Button>
+        </header>
+
+        <div className="flex flex-col gap-4 p-5">
+          <p className="rounded-3 border border-line-1 bg-surface-2 p-4 text-sm leading-[var(--lh-prose)] text-ink-2">
+            Tout employeur doit tenir un registre unique du personnel par
+            établissement. Aucune forme n’est imposée : en cas de contrôle par
+            l’inspection du travail, le format numérique peut être présenté.
+          </p>
+
+          <label className="flex flex-col gap-1.5">
+            <span className="text-sm font-medium">
+              Établissement pour lequel éditer le registre
+            </span>
+            <select
+              value={locationId}
+              onChange={(event) => setLocationId(event.target.value)}
+              className="h-10 rounded-2 border border-line-2 bg-surface px-3 text-sm text-ink-1 outline-none focus-visible:border-focus"
+            >
+              <option value="">Choisissez un établissement…</option>
+              {locations.map((location) => (
+                <option key={location.id} value={location.id}>
+                  {location.name}
+                </option>
+              ))}
+            </select>
+          </label>
+
+          {chosen && chosen.incomplete > 0 ? (
+            <div
+              role="alert"
+              className="rounded-3 border border-warn bg-warn-soft p-4 text-sm text-warn-soft-ink"
+            >
+              <p className="font-semibold">
+                Des mentions manquent pour {chosen.incomplete} salarié
+                {chosen.incomplete > 1 ? 's' : ''} de cet établissement
+              </p>
+              <p className="mt-1 leading-[var(--lh-prose)]">
+                Le registre reste éditable, et les manques y figurent en clair.
+                Un registre incomplet expose à une contravention par salarié
+                concerné : complétez les dossiers avant de le présenter.
+              </p>
+            </div>
+          ) : null}
+
+          {chosen && chosen.total === 0 ? (
+            <p className="text-sm text-ink-3">
+              Aucun contrat n’est rattaché à cet établissement : le registre
+              sera vide.
+            </p>
+          ) : null}
+        </div>
+
+        <footer className="flex items-center justify-end gap-3 border-t border-line-1 px-5 py-4">
+          <Button onClick={() => setOpen(false)}>Annuler</Button>
+          {/* Un lien, pas un bouton : le navigateur télécharge sans quitter la
+              page, et l'adresse reste rejouable. */}
+          <a
+            href={
+              locationId ? `/equipe/registre?etablissement=${locationId}` : '#'
+            }
+            aria-disabled={!locationId}
+            onClick={(event) => {
+              if (!locationId) event.preventDefault();
+              else setOpen(false);
+            }}
+            className={
+              locationId
+                ? 'inline-flex h-8 items-center rounded-2 border border-accent bg-accent px-3.5 text-sm font-medium text-accent-ink hover:bg-accent-hover'
+                : 'pointer-events-none inline-flex h-8 items-center rounded-2 border border-line-2 bg-surface-3 px-3.5 text-sm font-medium text-ink-3'
+            }
+          >
+            Télécharger
+          </a>
+        </footer>
+      </dialog>
+    </>
+  );
+}
@@ -3,6 +3,8 @@ import { Suspense } from 'react';

 import { AddEmployeeDialog } from '@/app/(app)/equipe/AddEmployeeDialog';
 import { DirectoryFilters } from '@/app/(app)/equipe/DirectoryFilters';
+import { RegisterDialog } from '@/app/(app)/equipe/RegisterDialog';
+import { listRegisterLocations } from '@/server/employees/rup';
 import { PageBody, PageHeader } from '@/components/shell/PageHeader';
 import { Badge, type Tone } from '@/components/ui/Badge';
 import { EmptyState } from '@/components/ui/Card';
@@ -51,6 +53,9 @@ export default async function EquipePage({
  // formulaire s'en tient à l'identité.
  const hiringLocations = await listContractLocations().catch(() => []);

+  // Sans `members.register.export`, le bouton du registre ne paraît pas.
+  const registerLocations = await listRegisterLocations().catch(() => []);
+
  const filtered = directory.rows.length !== directory.total;

  return (
@@ -64,12 +69,9 @@ export default async function EquipePage({
          : {})}
        actions={
          <>
-            <Link
-              href="/reglages/registre"
-              className="inline-flex h-8 items-center rounded-2 border border-line-3 bg-surface px-3.5 text-sm font-medium text-ink-1 hover:bg-surface-2"
-            >
-              Registre unique du personnel
-            </Link>
+            {registerLocations.length > 0 ? (
+              <RegisterDialog locations={registerLocations} />
+            ) : null}
            <AddEmployeeDialog locations={hiringLocations} />
          </>
        }
@@ -0,0 +1,60 @@
+import { NextResponse, type NextRequest } from 'next/server';
+
+import { asciiFileName, sanitiseFileName } from '@/domain/documents/rules';
+import { recordAudit } from '@/server/audit';
+import { query } from '@/server/context';
+import { getRegisterData } from '@/server/employees/rup';
+import { renderRegisterPdf } from '@/server/employees/rup-pdf';
+
+/**
+ * Téléchargement du registre unique du personnel.
+ *
+ * Une route et non une action : le document est un fichier, pas un écran, et
+ * son édition doit pouvoir être rejouée par une simple adresse — c'est aussi
+ * ce qui permet de la présenter depuis un poste d'inspection.
+ *
+ * L'édition est journalisée. Le registre rassemble l'identité, la nationalité
+ * et le parcours de tout le personnel d'un établissement : savoir qui l'a
+ * extrait, et quand, fait partie de ce qu'on doit pouvoir répondre.
+ */
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const locationId = request.nextUrl.searchParams.get('etablissement');
+  if (!locationId) {
+    return NextResponse.json(
+      { error: 'Choisissez un établissement.' },
+      { status: 400 },
+    );
+  }
+
+  const data = await getRegisterData(locationId);
+  if (!data) {
+    return NextResponse.json(
+      { error: 'Établissement introuvable.' },
+      { status: 404 },
+    );
+  }
+
+  await query('members.register.export', async (db, actor) =>
+    recordAudit(db, {
+      actorMembershipId: actor.membershipId,
+      action: 'members.register.export',
+      entityType: 'Location',
+      entityId: data.locationId,
+      after: { lines: data.people.length, incomplete: data.incomplete },
+    }),
+  );
+
+  const pdf = await renderRegisterPdf(data);
+  const stamp = new Date().toISOString().slice(0, 10).split('-').reverse().join('_');
+  const name = sanitiseFileName(`RUP - ${data.locationName} - ${stamp}.pdf`);
+
+  return new NextResponse(pdf as BodyInit, {
+    headers: {
+      'Content-Type': 'application/pdf',
+      'Content-Disposition': `attachment; filename="${asciiFileName(name)}"; filename*=UTF-8''${encodeURIComponent(name)}`,
+      // Un registre se lit à l'instant où il est demandé : le mettre en cache
+      // ferait présenter un effectif périmé au contrôle suivant.
+      'Cache-Control': 'no-store',
+    },
+  });
+}
@@ -0,0 +1,73 @@
+/**
+ * Registre unique du personnel — articles L1221-13 et D1221-23 du code du
+ * travail.
+ *
+ * Tenu par établissement et non par entreprise : c'est l'inspection d'un
+ * établissement donné qui le réclame, et un registre global ne répondrait pas
+ * à la demande.
+ *
+ * Les mentions sont fixées par le texte. Elles sont énumérées ici plutôt que
+ * dispersées dans le rendu, pour qu'une relecture juridique porte sur un seul
+ * endroit.
+ */
+
+export interface RupPerson {
+  lastName: string;
+  firstName: string;
+  /** Mention exigée. Non collectée par PlanFlow à ce jour. */
+  sex: string | null;
+  nationality: string | null;
+  birthDate: Date | null;
+  /** Emploi tenu, tel que porté par le contrat. */
+  jobTitle: string | null;
+  qualification: string | null;
+  contractLabel: string | null;
+  entryDate: Date | null;
+  exitDate: Date | null;
+}
+
+export interface RupColumn {
+  key: keyof RupPerson;
+  label: string;
+  /** Part de la largeur utile. La somme vaut 1. */
+  width: number;
+}
+
+/**
+ * L'ordre suit celui du texte réglementaire : identité, puis situation, puis
+ * dates. Un registre réordonné se relit mal en regard de l'article.
+ */
+export const RUP_COLUMNS: RupColumn[] = [
+  { key: 'lastName', label: 'Nom', width: 0.13 },
+  { key: 'firstName', label: 'Prénom', width: 0.11 },
+  { key: 'sex', label: 'Sexe', width: 0.05 },
+  { key: 'nationality', label: 'Nationalité', width: 0.1 },
+  { key: 'birthDate', label: 'Date de naissance', width: 0.1 },
+  { key: 'jobTitle', label: 'Emploi', width: 0.14 },
+  { key: 'qualification', label: 'Qualification', width: 0.11 },
+  { key: 'contractLabel', label: 'Contrat', width: 0.08 },
+  { key: 'entryDate', label: 'Entrée', width: 0.09 },
+  { key: 'exitDate', label: 'Sortie', width: 0.09 },
+];
+
+/**
+ * Mentions obligatoires manquantes pour une personne.
+ *
+ * La date de sortie est exclue : son absence signifie que le salarié est
+ * toujours présent, ce qui est une information et non un oubli.
+ */
+export function missingMentions(person: RupPerson): string[] {
+  return RUP_COLUMNS.filter((column) => {
+    if (column.key === 'exitDate') return false;
+    const value = person[column.key];
+    return value === null || value === '';
+  }).map((column) => column.label);
+}
+
+/**
+ * Une contravention par salarié concerné, et non une par registre : c'est ce
+ * qui justifie de compter les personnes plutôt que les champs.
+ */
+export function peopleWithGaps(people: RupPerson[]): number {
+  return people.filter((person) => missingMentions(person).length > 0).length;
+}
@@ -0,0 +1,164 @@
+import 'server-only';
+
+import { PDFDocument, StandardFonts, rgb, type PDFFont } from 'pdf-lib';
+
+import { RUP_COLUMNS, type RupPerson } from '@/domain/legal/rup';
+import type { RupData } from '@/server/employees/rup';
+
+/**
+ * Rendu du registre unique du personnel.
+ *
+ * Aucune forme n'est imposée par la loi : ce qui compte est que les mentions y
+ * soient, lisibles, et que le document puisse être présenté tel quel en cas de
+ * contrôle. D'où un tableau paysage sobre plutôt qu'une mise en page.
+ *
+ * Helvetica et l'encodage WinAnsi : les accents français y sont, et une police
+ * embarquée alourdirait le fichier sans rien apporter à un tableau.
+ */
+
+const A4_LANDSCAPE: [number, number] = [841.89, 595.28];
+const MARGIN = 32;
+const ROW_HEIGHT = 18;
+const FONT_SIZE = 8;
+
+const dateFormat = new Intl.DateTimeFormat('fr-FR', { dateStyle: 'short' });
+
+function cell(person: RupPerson, key: keyof RupPerson): string {
+  const value = person[key];
+  if (value === null || value === '') return '—';
+  if (value instanceof Date) return dateFormat.format(value);
+  return String(value);
+}
+
+/** Coupe au lieu de déborder : une colonne qui empiète sur la suivante rend
+ *  les deux illisibles. */
+function fit(text: string, font: PDFFont, size: number, width: number): string {
+  if (font.widthOfTextAtSize(text, size) <= width) return text;
+  let cut = text;
+  while (cut.length > 1 && font.widthOfTextAtSize(`${cut}…`, size) > width) {
+    cut = cut.slice(0, -1);
+  }
+  return `${cut}…`;
+}
+
+export async function renderRegisterPdf(data: RupData): Promise<Uint8Array> {
+  const pdf = await PDFDocument.create();
+  pdf.setTitle(`Registre unique du personnel — ${data.locationName}`);
+  pdf.setCreator('PlanFlow');
+
+  const regular = await pdf.embedFont(StandardFonts.Helvetica);
+  const bold = await pdf.embedFont(StandardFonts.HelveticaBold);
+
+  const usable = A4_LANDSCAPE[0] - MARGIN * 2;
+  const widths = RUP_COLUMNS.map((column) => column.width * usable);
+  const ink = rgb(0.11, 0.11, 0.11);
+  const faint = rgb(0.62, 0.62, 0.62);
+  const rule = rgb(0.85, 0.85, 0.85);
+
+  const printedOn = dateFormat.format(new Date());
+  let page = pdf.addPage(A4_LANDSCAPE);
+  let y = A4_LANDSCAPE[1] - MARGIN;
+
+  const header = () => {
+    page.drawText('Registre unique du personnel', {
+      x: MARGIN,
+      y: y - 12,
+      size: 14,
+      font: bold,
+      color: ink,
+    });
+    page.drawText(
+      [
+        data.locationName,
+        data.siret ? `SIRET ${data.siret}` : null,
+        `édité le ${printedOn}`,
+      ]
+        .filter(Boolean)
+        .join(' · '),
+      { x: MARGIN, y: y - 28, size: 9, font: regular, color: faint },
+    );
+    y -= 48;
+
+    let x = MARGIN;
+    RUP_COLUMNS.forEach((column, index) => {
+      page.drawText(column.label, {
+        x,
+        y: y - 10,
+        size: FONT_SIZE,
+        font: bold,
+        color: ink,
+      });
+      x += widths[index] as number;
+    });
+    y -= 16;
+    page.drawLine({
+      start: { x: MARGIN, y },
+      end: { x: MARGIN + usable, y },
+      thickness: 0.7,
+      color: rule,
+    });
+    y -= 4;
+  };
+
+  header();
+
+  for (const person of data.people) {
+    // Nouvelle page avant d'écrire, pas après : une ligne à moitié sous la
+    // marge est pire qu'une page de plus.
+    if (y - ROW_HEIGHT < MARGIN + 24) {
+      page = pdf.addPage(A4_LANDSCAPE);
+      y = A4_LANDSCAPE[1] - MARGIN;
+      header();
+    }
+
+    let x = MARGIN;
+    RUP_COLUMNS.forEach((column, index) => {
+      const width = widths[index] as number;
+      const value = cell(person, column.key);
+      page.drawText(fit(value, regular, FONT_SIZE, width - 6), {
+        x,
+        y: y - 12,
+        size: FONT_SIZE,
+        font: regular,
+        color: value === '—' ? faint : ink,
+      });
+      x += width;
+    });
+
+    y -= ROW_HEIGHT;
+    page.drawLine({
+      start: { x: MARGIN, y: y + 4 },
+      end: { x: MARGIN + usable, y: y + 4 },
+      thickness: 0.4,
+      color: rule,
+    });
+  }
+
+  if (data.people.length === 0) {
+    page.drawText('Aucun salarié rattaché à cet établissement.', {
+      x: MARGIN,
+      y: y - 12,
+      size: 9,
+      font: regular,
+      color: faint,
+    });
+  }
+
+  // Mention de pied : un registre incomplet reste un registre, mais celui qui
+  // le présente doit savoir ce qui lui manque avant l'inspection.
+  const pages = pdf.getPages();
+  pages.forEach((current, index) => {
+    current.drawText(
+      [
+        `Page ${index + 1} sur ${pages.length}`,
+        `${data.people.length} ligne${data.people.length > 1 ? 's' : ''}`,
+        data.incomplete > 0
+          ? `${data.incomplete} dossier${data.incomplete > 1 ? 's' : ''} incomplet${data.incomplete > 1 ? 's' : ''}`
+          : 'Mentions complètes',
+      ].join(' · '),
+      { x: MARGIN, y: MARGIN - 12, size: 7, font: regular, color: faint },
+    );
+  });
+
+  return pdf.save();
+}
@@ -0,0 +1,163 @@
+import 'server-only';
+
+import { cache } from 'react';
+
+import type { RupPerson } from '@/domain/legal/rup';
+import { peopleWithGaps } from '@/domain/legal/rup';
+import { query } from '@/server/context';
+import { contractLabel } from '@/server/employees/queries';
+
+/**
+ * Registre unique du personnel — lecture.
+ *
+ * Le registre porte **tous** ceux qui ont été employés dans l'établissement,
+ * y compris les partis : c'est précisément l'historique que l'inspection vient
+ * chercher. Filtrer sur les présents en ferait un trombinoscope.
+ */
+
+export interface RupData {
+  locationId: string;
+  locationName: string;
+  siret: string | null;
+  people: RupPerson[];
+  /** Nombre de salariés à qui il manque au moins une mention obligatoire. */
+  incomplete: number;
+}
+
+export const getRegisterData = cache(async function getRegisterData(
+  locationId: string,
+): Promise<RupData | null> {
+  return query('members.register.export', async (db) => {
+    const location = await db.location.findUnique({
+      where: { id: locationId },
+      select: { id: true, name: true, siret: true },
+    });
+    if (!location) return null;
+
+    const contracts = await db.userContract.findMany({
+      where: { locationId },
+      orderBy: { startDate: 'asc' },
+      include: {
+        membership: {
+          select: {
+            profile: {
+              select: {
+                firstName: true,
+                lastName: true,
+                nationality: true,
+                birthDate: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const jobTitleIds = [
+      ...new Set(
+        contracts
+          .map((contract) => contract.jobTitleId)
+          .filter((id): id is string => Boolean(id)),
+      ),
+    ];
+    const jobTitles = await db.jobTitle.findMany({
+      where: { id: { in: jobTitleIds } },
+      select: { id: true, name: true },
+    });
+    const jobTitleNames = new Map(
+      jobTitles.map((entry) => [entry.id, entry.name]),
+    );
+
+    // Une ligne par contrat, pas par personne : un salarié réembauché a deux
+    // entrées et deux sorties, et les fondre effacerait l'interruption.
+    const people: RupPerson[] = contracts.map((contract) => ({
+      lastName: contract.membership.profile?.lastName ?? '',
+      firstName: contract.membership.profile?.firstName ?? '',
+      // PlanFlow ne collecte pas le sexe : la mention est exigée, la colonne
+      // reste donc vide et le décompte des dossiers incomplets le signale.
+      sex: null,
+      nationality: contract.membership.profile?.nationality ?? null,
+      birthDate: contract.membership.profile?.birthDate ?? null,
+      jobTitle: contract.jobTitleId
+        ? (jobTitleNames.get(contract.jobTitleId) ?? null)
+        : null,
+      qualification: contract.classification,
+      contractLabel: contractLabel(contract.contractType),
+      entryDate: contract.startDate,
+      exitDate: contract.endDate,
+    }));
+
+    return {
+      locationId: location.id,
+      locationName: location.name,
+      siret: location.siret,
+      people,
+      incomplete: peopleWithGaps(people),
+    };
+  });
+});
+
+/** Établissements pour lesquels un registre peut être tiré. */
+export const listRegisterLocations = cache(
+  async function listRegisterLocations(): Promise<
+    Array<{ id: string; name: string; incomplete: number; total: number }>
+  > {
+    return query('members.register.export', async (db) => {
+      const locations = await db.location.findMany({
+        where: { archivedAt: null },
+        select: { id: true, name: true },
+        orderBy: { name: 'asc' },
+      });
+
+      // Le décompte des manques est calculé ici pour que l'écran puisse
+      // avertir **avant** le téléchargement : découvrir un registre incomplet
+      // en l'ouvrant, c'est le découvrir devant l'inspection.
+      return Promise.all(
+        locations.map(async (location) => {
+          const contracts = await db.userContract.findMany({
+            where: { locationId: location.id },
+            select: {
+              classification: true,
+              jobTitleId: true,
+              contractType: true,
+              startDate: true,
+              endDate: true,
+              membership: {
+                select: {
+                  profile: {
+                    select: {
+                      firstName: true,
+                      lastName: true,
+                      nationality: true,
+                      birthDate: true,
+                    },
+                  },
+                },
+              },
+            },
+          });
+
+          const people: RupPerson[] = contracts.map((contract) => ({
+            lastName: contract.membership.profile?.lastName ?? '',
+            firstName: contract.membership.profile?.firstName ?? '',
+            sex: null,
+            nationality: contract.membership.profile?.nationality ?? null,
+            birthDate: contract.membership.profile?.birthDate ?? null,
+            jobTitle: contract.jobTitleId ? 'x' : null,
+            qualification: contract.classification,
+            contractLabel: contractLabel(contract.contractType),
+            entryDate: contract.startDate,
+            exitDate: contract.endDate,
+          }));
+
+          return {
+            id: location.id,
+            name: location.name,
+            incomplete: peopleWithGaps(people),
+            total: people.length,
+          };
+        }),
+      );
+    });
+  },
+);
@@ -0,0 +1,46 @@
+import { expect, test } from '@playwright/test';
+
+/**
+ * Registre unique du personnel — édition.
+ *
+ * Ce qui est éprouvé n'est pas la mise en page, mais qu'un fichier sorte et
+ * qu'il porte le bon établissement : un registre édité pour le mauvais site ne
+ * répond à aucune demande d'inspection.
+ */
+
+test('le registre s’édite par établissement', async ({ page }) => {
+  await page.goto('/equipe');
+
+  await page.getByRole('button', { name: 'Registre unique du personnel' }).click();
+  await expect(
+    page.getByRole('heading', {
+      name: 'Téléchargez votre registre unique du personnel',
+    }),
+  ).toBeVisible();
+
+  // Sans établissement, rien à télécharger : le registre se tient par site.
+  const download = page.getByRole('link', { name: 'Télécharger' });
+  await expect(download).toHaveAttribute('aria-disabled', 'true');
+
+  const select = page.getByLabel('Établissement pour lequel éditer le registre');
+  const value = await select.locator('option').nth(1).getAttribute('value');
+  await select.selectOption(value!);
+
+  const started = page.waitForEvent('download');
+  await download.click();
+  const file = await started;
+
+  expect(file.suggestedFilename()).toMatch(/^RUP - .+\.pdf$/);
+
+  // Le contenu est bien un PDF, pas une page d'erreur renvoyée en 200.
+  const path = await file.path();
+  const { readFileSync } = await import('node:fs');
+  expect(readFileSync(path).subarray(0, 5).toString()).toBe('%PDF-');
+});
+
+test('l’adresse du registre refuse un établissement absent', async ({
+  page,
+}) => {
+  const response = await page.goto('/equipe/registre');
+  expect(response?.status()).toBe(400);
+});
@@ -0,0 +1,10 @@
+/**
+ * Doublure de `server-only`.
+ *
+ * Le paquet est fourni par Next au moment du bundling : il n'existe pas dans
+ * `node_modules`, et son seul rôle est de faire échouer la compilation d'un
+ * module serveur importé depuis un composant client. Hors de Next, il n'a rien
+ * à garantir — mais son absence empêcherait de tester les modules qui le
+ * déclarent.
+ */
+export {};
@@ -0,0 +1,119 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  RUP_COLUMNS,
+  missingMentions,
+  peopleWithGaps,
+  type RupPerson,
+} from '@/domain/legal/rup';
+
+/**
+ * Registre unique du personnel — mentions obligatoires.
+ *
+ * La sanction se compte **par salarié concerné**, pas par registre : c'est ce
+ * que le décompte doit refléter, et c'est ce qui décide de l'avertissement
+ * affiché avant l'édition.
+ */
+
+const complete: RupPerson = {
+  lastName: 'Ferrand',
+  firstName: 'Camille',
+  sex: 'F',
+  nationality: 'France',
+  birthDate: new Date('1990-04-12T00:00:00Z'),
+  jobTitle: 'Hôte de caisse',
+  qualification: 'Niveau 3',
+  contractLabel: 'CDI',
+  entryDate: new Date('2024-09-01T00:00:00Z'),
+  exitDate: null,
+};
+
+describe('registre unique du personnel', () => {
+  it('énumère les mentions fixées par le texte', () => {
+    expect(RUP_COLUMNS.map((column) => column.key)).toEqual([
+      'lastName',
+      'firstName',
+      'sex',
+      'nationality',
+      'birthDate',
+      'jobTitle',
+      'qualification',
+      'contractLabel',
+      'entryDate',
+      'exitDate',
+    ]);
+  });
+
+  it('répartit la largeur sur la totalité de la page', () => {
+    const total = RUP_COLUMNS.reduce((sum, column) => sum + column.width, 0);
+    expect(total).toBeCloseTo(1, 5);
+  });
+
+  it('ne réclame rien quand toutes les mentions sont là', () => {
+    expect(missingMentions(complete)).toEqual([]);
+  });
+
+  it('tient une date de sortie absente pour une présence, pas pour un oubli', () => {
+    // Un salarié en poste n'a pas de date de sortie : la réclamer ferait
+    // apparaître tout l'effectif courant comme incomplet.
+    expect(missingMentions({ ...complete, exitDate: null })).toEqual([]);
+  });
+
+  it('nomme les mentions manquantes', () => {
+    expect(
+      missingMentions({ ...complete, nationality: null, qualification: '' }),
+    ).toEqual(['Nationalité', 'Qualification']);
+  });
+
+  it('compte les personnes concernées, pas les champs vides', () => {
+    const bancal: RupPerson = {
+      ...complete,
+      sex: null,
+      nationality: null,
+      birthDate: null,
+    };
+    // Trois manques sur une seule personne : une contravention, pas trois.
+    expect(peopleWithGaps([complete, bancal])).toBe(1);
+  });
+});
+
+describe('rendu du registre', () => {
+  it('produit un PDF paginé qui porte les manques en pied', async () => {
+    const { renderRegisterPdf } = await import('@/server/employees/rup-pdf');
+
+    // Assez de lignes pour dépasser une page : c'est la rupture que le rendu
+    // rate le plus volontiers.
+    const people: RupPerson[] = Array.from({ length: 60 }, (_, index) => ({
+      ...complete,
+      lastName: `Nom manifestement trop long pour la colonne ${index}`,
+      sex: index % 2 === 0 ? null : 'F',
+    }));
+
+    const pdf = await renderRegisterPdf({
+      locationId: 'loc',
+      locationName: 'La Foir’Fouille',
+      siret: '12345678901234',
+      people,
+      incomplete: 30,
+    });
+
+    expect(Buffer.from(pdf).subarray(0, 5).toString()).toBe('%PDF-');
+    expect(pdf.length).toBeGreaterThan(1000);
+  });
+
+  it('édite un registre vide plutôt que de refuser', async () => {
+    const { renderRegisterPdf } = await import('@/server/employees/rup-pdf');
+
+    // Un établissement qui vient d'ouvrir n'a personne : le registre existe
+    // quand même, et son absence serait plus embarrassante que sa vacuité.
+    const pdf = await renderRegisterPdf({
+      locationId: 'loc',
+      locationName: 'Nouvel établissement',
+      siret: null,
+      people: [],
+      incomplete: 0,
+    });
+
+    expect(Buffer.from(pdf).subarray(0, 5).toString()).toBe('%PDF-');
+  });
+});
@@ -8,6 +8,11 @@ export default defineConfig({
  resolve: {
    alias: {
      '@': fileURLToPath(new URL('./src', import.meta.url)),
+      // Fourni par Next au bundling, absent de `node_modules` : sans doublure,
+      // aucun module serveur qui le déclare ne serait testable.
+      'server-only': fileURLToPath(
+        new URL('./tests/support/server-only.ts', import.meta.url),
+      ),
    },
  },
  test: {