@nomosui/react 0.4.0

package/dist/index.js

@@ -0,0 +1,4591 @@
+import { Check, ChevronDown, ChevronLeft, ChevronRight, ChevronUp, Circle, CircleAlert, CircleCheck, CircleX, Info, LoaderCircle, Search, Star, TriangleAlert, X } from "lucide-react";
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { Slot } from "@radix-ui/react-slot";
+import * as React from "react";
+import { Fragment as Fragment$1, createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import * as SelectPrimitive from "@radix-ui/react-select";
+import { columnFilteringFeature, columnVisibilityFeature, createFilteredRowModel, createPaginatedRowModel, createSortedRowModel, flexRender, globalFilteringFeature, rowPaginationFeature, rowSortingFeature, sortFn_alphanumeric, sortFn_basic, sortFn_datetime, sortFn_text, tableFeatures, useTable } from "@tanstack/react-table";
+import * as SheetPrimitive from "@radix-ui/react-dialog";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+import * as SwitchPrimitive from "@radix-ui/react-switch";
+import * as RadioGroupPrimitive from "@radix-ui/react-radio-group";
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+import { z } from "zod";
+//#region src/lib/cn.ts
+/**
+* Le `cn` du cœur. Il vit ici et pas dans l'app : un composant du design system ne
+* peut pas dépendre d'un utilitaire qui appartient au dashboard.
+*/
+var cn = (...inputs) => twMerge(clsx(inputs));
+//#endregion
+//#region src/lib/tone.ts
+/**
+* Le vocabulaire de tons du cœur : sept **intentions**, pas sept couleurs. Un badge de
+* statut choisit l'intention (« danger », « succès »), et c'est le cœur qui sait la
+* rendre — l'app ne manipule plus un nom de couleur.
+*
+* Chaque ton lit deux emplacements sémantiques (`status-<ton>` pour la surface, lue à
+* faible opacité, et `status-<ton>-ink` pour l'encre) : c'est le token qui porte le
+* mode, pas la classe, donc le cœur ne connaît jamais le mode (ADR 0004, garde des tokens).
+*/
+var TONES = [
+	"neutral",
+	"info",
+	"progress",
+	"attention",
+	"warning",
+	"danger",
+	"success"
+];
+var toneClasses = {
+	neutral: "border-transparent bg-muted text-muted-foreground",
+	info: "border-status-info/30 bg-status-info/15 text-status-info-ink",
+	progress: "border-status-progress/30 bg-status-progress/15 text-status-progress-ink",
+	attention: "border-status-attention/30 bg-status-attention/15 text-status-attention-ink",
+	warning: "border-status-warning/30 bg-status-warning/15 text-status-warning-ink",
+	danger: "border-status-danger/30 bg-status-danger/15 text-status-danger-ink",
+	success: "border-status-success/30 bg-status-success/15 text-status-success-ink"
+};
+//#endregion
+//#region src/components/alert/alert.tsx
+/** L'icône par défaut d'un ton ; `neutral` reste sans icône. L'appelant peut la remplacer. */
+var defaultIcon$1 = {
+	info: /* @__PURE__ */ jsx(Info, { className: "size-4" }),
+	progress: /* @__PURE__ */ jsx(LoaderCircle, { className: "size-4" }),
+	attention: /* @__PURE__ */ jsx(CircleAlert, { className: "size-4" }),
+	warning: /* @__PURE__ */ jsx(TriangleAlert, { className: "size-4" }),
+	danger: /* @__PURE__ */ jsx(CircleX, { className: "size-4" }),
+	success: /* @__PURE__ */ jsx(CircleCheck, { className: "size-4" })
+};
+function Alert({ tone = "info", title, children, action, icon, onClose, closeLabel, className }) {
+	return /* @__PURE__ */ jsxs("div", {
+		role: tone === "danger" ? "alert" : "status",
+		className: cn("flex items-start gap-3 rounded-md border p-4 text-sm", toneClasses[tone], className),
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				"aria-hidden": true,
+				className: "mt-0.5 shrink-0",
+				children: icon ?? defaultIcon$1[tone] ?? null
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "min-w-0 flex-1",
+				children: [/* @__PURE__ */ jsx("p", {
+					className: "font-medium",
+					children: title
+				}), children ? /* @__PURE__ */ jsx("div", {
+					className: "mt-0.5 opacity-90",
+					children
+				}) : null]
+			}),
+			action ? /* @__PURE__ */ jsx("div", {
+				className: "shrink-0",
+				children: action
+			}) : null,
+			onClose ? /* @__PURE__ */ jsx("button", {
+				type: "button",
+				"aria-label": closeLabel,
+				onClick: onClose,
+				className: "-m-1 shrink-0 rounded p-1 opacity-70 transition-opacity hover:opacity-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+				children: /* @__PURE__ */ jsx(CircleX, {
+					className: "size-4",
+					"aria-hidden": true
+				})
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/components/alert/manifest.ts
+/** Le manifeste du bandeau (ADR 0005, ADR 0015). Le ton réutilise le vocabulaire `toneClasses`. */
+var alertManifest = {
+	name: "alert",
+	title: "Alert",
+	summary: "Un bandeau inline qui dit une information, un avertissement, un succès ou une erreur. Le ton vient du cœur (une intention, pas une couleur) ; tout texte est fourni par l'app.",
+	level: "primitive",
+	example: {
+		tone: "info",
+		title: "information",
+		children: "un détail à lire."
+	},
+	variants: [{
+		name: "tone",
+		values: [...TONES],
+		default: "info",
+		description: "L'intention du bandeau — c'est ce que l'appelant choisit selon l'usage, pas son goût."
+	}],
+	props: [
+		{
+			name: "title",
+			type: "string",
+			required: true,
+			check: "rendered",
+			description: "Le titre du bandeau : court, jamais une phrase."
+		},
+		{
+			name: "children",
+			type: "ReactNode",
+			required: false,
+			check: "content",
+			description: "Le contenu détaillé, sous le titre."
+		},
+		{
+			name: "action",
+			type: "ReactNode",
+			required: false,
+			check: "accepted",
+			description: "Ce qu’on peut faire : un bouton, un lien."
+		},
+		{
+			name: "icon",
+			type: "ReactNode",
+			required: false,
+			check: "accepted",
+			description: "Remplace l'icône par défaut du ton."
+		},
+		{
+			name: "onClose",
+			type: "() => void",
+			required: false,
+			check: "accepted",
+			description: "Affiche un bouton de fermeture et le rappelle au clic."
+		},
+		{
+			name: "closeLabel",
+			type: "string",
+			required: false,
+			check: "accepted",
+			description: "Le libellé accessible du bouton de fermeture (requis avec `onClose`)."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		}
+	],
+	usages: [{
+		when: "signaler un état qui demande l’attention sans bloquer la vue",
+		use: "<Alert tone=\"warning\" title={…}>…</Alert>",
+		avoid: "un `Alert` pour une information décorative : le bandeau doit dire quelque chose"
+	}, {
+		when: "un bandeau qu’on peut refermer",
+		use: "onClose + closeLabel (les deux ensemble)",
+		avoid: "onClose sans closeLabel : le bouton devient muet pour un lecteur d’écran"
+	}]
+};
+//#endregion
+//#region src/components/badge/badge.tsx
+/**
+* La config des variantes est exportée à côté de `badgeVariants` : le catalogue la lit
+* pour vérifier que le manifeste ne dérive pas des props réelles (ADR 0005). cva ne
+* porte pas la config sur la fonction qu'il rend, donc on l'écrit ici, une fois.
+*/
+var badgeVariantsConfig = {
+	variants: { variant: {
+		default: "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
+		secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+		destructive: "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
+		outline: "text-foreground"
+	} },
+	defaultVariants: { variant: "default" }
+};
+var badgeVariants = cva("inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2", badgeVariantsConfig);
+var Badge = ({ className, variant, ...props }) => /* @__PURE__ */ jsx("div", {
+	className: cn(badgeVariants({ variant }), className),
+	...props
+});
+//#endregion
+//#region src/components/badge/manifest.ts
+/**
+* Le manifeste du Badge (ADR 0005). Il est écrit à la main : le type se génère,
+* l'usage s'écrit. Le test de cohérence du catalogue le confronte aux props réelles —
+* une variante ajoutée au composant sans passer ici fait rougir le test.
+*/
+var badgeManifest = {
+	name: "badge",
+	title: "Badge",
+	summary: "Une étiquette courte et non interactive, posée à côté d'un contenu pour le qualifier. Tout attribut HTML est transmis tel quel à l'élément.",
+	level: "primitive",
+	variants: [{
+		name: "variant",
+		values: [
+			"default",
+			"secondary",
+			"destructive",
+			"outline"
+		],
+		default: "default",
+		description: "Le ton de l'étiquette — c'est ce que l'appelant choisit selon l'usage, pas selon son goût."
+	}],
+	props: [
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles de la variante."
+		},
+		{
+			name: "title",
+			type: "string",
+			required: false,
+			check: "attribute",
+			description: "L'attribut HTML transmis tel quel, ici le libellé au survol."
+		},
+		{
+			name: "children",
+			type: "ReactNode",
+			required: true,
+			check: "content",
+			description: "Le texte porté par l'étiquette : court, jamais une phrase."
+		}
+	],
+	usages: [
+		{
+			when: "un statut de production qu'on doit voir au premier coup d'œil",
+			use: "variant=\"destructive\"",
+			avoid: "variant=\"outline\", qui ne se distingue pas dans une ligne déjà dense"
+		},
+		{
+			when: "une étiquette neutre posée à côté du contenu",
+			use: "variant=\"secondary\"",
+			avoid: "variant=\"default\", réservé au ton principal de la vue"
+		},
+		{
+			when: "une information à qualifier sans crier (compte, catégorie)",
+			use: "variant=\"outline\"",
+			avoid: "variant=\"destructive\" pour qualifier sans urgence : le ton doit dire la gravité réelle"
+		}
+	]
+};
+//#endregion
+//#region src/components/button/button.tsx
+/**
+* Le bouton du cœur. La config des variantes est exportée à côté de `buttonVariants`,
+* comme celle du Badge : le catalogue la lit pour vérifier que le manifeste ne dérive
+* pas des props réelles (ADR 0005).
+*/
+var buttonVariantsConfig = {
+	variants: {
+		variant: {
+			default: "bg-primary text-primary-foreground hover:bg-primary/90",
+			destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+			outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
+			secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+			ghost: "hover:bg-accent hover:text-accent-foreground",
+			link: "text-primary underline-offset-4 hover:underline"
+		},
+		size: {
+			default: "h-10 px-4 py-2",
+			sm: "h-9 rounded-md px-3",
+			lg: "h-11 rounded-md px-8",
+			icon: "h-10 w-10"
+		}
+	},
+	defaultVariants: {
+		variant: "default",
+		size: "default"
+	}
+};
+var buttonVariants = cva("inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0", buttonVariantsConfig);
+function Button({ className, variant, size, asChild = false, ...props }) {
+	return /* @__PURE__ */ jsx(asChild ? Slot : "button", {
+		className: cn(buttonVariants({
+			variant,
+			size,
+			className
+		})),
+		...props
+	});
+}
+//#endregion
+//#region src/components/button/manifest.ts
+/**
+* Le manifeste du Bouton (ADR 0005). Il déclare les deux groupes de variantes —
+* `variant` (le ton) et `size` (la taille) — que le test de cohérence confronte à la
+* config réelle.
+*/
+var buttonManifest = {
+	name: "button",
+	title: "Button",
+	summary: "Un déclencheur d'action. Le ton (`variant`) dit l'importance, la taille (`size`) dit la densité. Tout attribut HTML de bouton est transmis tel quel.",
+	level: "primitive",
+	example: { children: "Bouton" },
+	variants: [{
+		name: "variant",
+		values: [
+			"default",
+			"destructive",
+			"outline",
+			"secondary",
+			"ghost",
+			"link"
+		],
+		default: "default",
+		description: "Le ton de l'action : principale, dangereuse, secondaire, discrète ou lien."
+	}, {
+		name: "size",
+		values: [
+			"default",
+			"sm",
+			"lg",
+			"icon"
+		],
+		default: "default",
+		description: "La taille du contrôle, du plus discret au plus large, ou icon-only."
+	}],
+	props: [
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles de la variante."
+		},
+		{
+			name: "children",
+			type: "ReactNode",
+			required: true,
+			check: "content",
+			description: "Le libellé de l'action, ou une icône seule (avec `aria-label`)."
+		},
+		{
+			name: "onClick",
+			type: "(event: MouseEvent) => void",
+			required: false,
+			check: "accepted",
+			description: "L'action déclenchée au clic ; le cœur ne la connaît pas."
+		}
+	],
+	usages: [
+		{
+			when: "l'action principale d'une vue",
+			use: "variant=\"default\"",
+			avoid: "plusieurs `default` côte à côte : le ton principal doit rester unique"
+		},
+		{
+			when: "une action secondaire à côté de la principale",
+			use: "variant=\"outline\"",
+			avoid: "`ghost` pour une action qu’on doit voir sans survol"
+		},
+		{
+			when: "une icône seule (fermer, paginer)",
+			use: "size=\"icon\" + aria-label",
+			avoid: "un `icon` sans `aria-label` : le bouton devient muet pour un lecteur d’écran"
+		},
+		{
+			when: "poser le style du bouton sur un lien ou un autre élément",
+			use: "asChild avec un seul enfant",
+			avoid: "asChild avec plusieurs enfants : Radix Slot n’en accepte qu’un"
+		}
+	]
+};
+//#endregion
+//#region src/components/card/card.tsx
+/**
+* La carte : une surface qui regroupe un contenu apparenté — un en-tête (titre +
+* description), un corps, un pied. En parts importables séparément ; aucune part ne
+* nomme un produit, les textes viennent de l'appelant.
+*/
+function Card({ className, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("rounded-lg border bg-card text-card-foreground shadow-sm", className),
+		...props
+	});
+}
+function CardHeader({ className, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("flex flex-col space-y-1.5 p-6", className),
+		...props
+	});
+}
+function CardTitle({ className, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("text-2xl font-semibold leading-none tracking-tight", className),
+		...props
+	});
+}
+function CardDescription({ className, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("text-sm text-muted-foreground", className),
+		...props
+	});
+}
+function CardContent({ className, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("p-6 pt-0", className),
+		...props
+	});
+}
+function CardFooter({ className, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("flex items-center p-6 pt-0", className),
+		...props
+	});
+}
+//#endregion
+//#region src/components/card/manifest.ts
+/** Le manifeste de la carte (ADR 0005). Le catalogue enregistre la coquille `Card`. */
+var cardManifest = {
+	name: "card",
+	title: "Card",
+	summary: "Une surface qui regroupe un contenu apparenté : un en-tête (titre, description), un corps et un pied. Livrée en parts importables séparément, sans libellé propre au cœur.",
+	level: "primitive",
+	example: {
+		className: "max-w-sm",
+		children: createElement(Fragment$1, null, createElement(CardHeader, null, createElement(CardTitle, null, "Titre"), createElement(CardDescription, null, "Une description courte.")), createElement(CardContent, null, "Le contenu de la carte."))
+	},
+	variants: [],
+	props: [{
+		name: "className",
+		type: "string",
+		required: false,
+		check: "class",
+		description: "Les classes de l'appelant, fusionnées après celles du cœur."
+	}, {
+		name: "children",
+		type: "ReactNode",
+		required: true,
+		check: "content",
+		description: "Les parts de la carte : un en-tête, un corps, un pied."
+	}],
+	usages: [{
+		when: "regrouper un titre, un corps et un pied dans une surface",
+		use: "<Card><CardHeader><CardTitle>…</CardTitle></CardHeader><CardContent>…</CardContent></Card>",
+		avoid: "un `<div>` stylé au coup par coup : on perd les tokens de bordure et de fond"
+	}, {
+		when: "des cartes de résumé côte à côte dans une grille",
+		use: "plusieurs `Card` de même niveau",
+		avoid: "imbriquer des `Card` profondément : une carte n’est pas un layout"
+	}]
+};
+//#endregion
+//#region src/components/empty-state/empty-state.tsx
+function EmptyState({ icon, title, description, detail, action, wrap = true, className }) {
+	return /* @__PURE__ */ jsxs(Card, {
+		className: cn("mx-auto max-w-xl", className),
+		children: [
+			/* @__PURE__ */ jsxs(CardHeader, { children: [
+				icon ? /* @__PURE__ */ jsx("div", {
+					className: "mb-2",
+					children: icon
+				}) : null,
+				/* @__PURE__ */ jsx(CardTitle, { children: title }),
+				description ? /* @__PURE__ */ jsx(CardDescription, { children: description }) : null
+			] }),
+			detail ? /* @__PURE__ */ jsx(CardContent, { children: /* @__PURE__ */ jsx("pre", {
+				className: cn("overflow-x-auto rounded-md bg-muted p-3 text-xs text-muted-foreground", wrap && "whitespace-pre-wrap"),
+				children: detail
+			}) }) : null,
+			action ? /* @__PURE__ */ jsx(CardFooter, {
+				className: "gap-2",
+				children: action
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/components/empty-state/manifest.ts
+/** Le manifeste de l'état vide (ADR 0005, ADR 0015). Présentation seule, sans moteur. */
+var emptyStateManifest = {
+	name: "empty-state",
+	title: "EmptyState",
+	summary: "L'état vide d'une vue : une carte centrée (icône, titre, description, détail brut, action). Aucun texte propre au cœur — l’app fournit tout, y compris le pourquoi de l’absence.",
+	level: "bloc",
+	example: {
+		title: "aucune donnée",
+		description: "le lot est vide.",
+		detail: "flux introuvable : 404 (script de sync non lancé)",
+		wrap: true
+	},
+	variants: [],
+	props: [
+		{
+			name: "title",
+			type: "string",
+			required: true,
+			check: "rendered",
+			description: "Le titre de l'état : court, jamais une phrase."
+		},
+		{
+			name: "description",
+			type: "string",
+			required: false,
+			check: "rendered",
+			description: "Une description d’une phrase, sous le titre."
+		},
+		{
+			name: "detail",
+			type: "string",
+			required: false,
+			check: "rendered",
+			description: "Le détail brut (message d’erreur, cause), affiché tel quel."
+		},
+		{
+			name: "wrap",
+			type: "boolean",
+			required: false,
+			default: "true",
+			check: "rendered",
+			description: "Passe le détail sur plusieurs lignes au lieu de le laisser défiler."
+		},
+		{
+			name: "icon",
+			type: "ReactNode",
+			required: false,
+			check: "accepted",
+			description: "L'illustration ou l'icône, fournie par l'appelant."
+		},
+		{
+			name: "action",
+			type: "ReactNode",
+			required: false,
+			check: "accepted",
+			description: "Ce qu’on peut faire devant cet état : un bouton, un lien."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		}
+	],
+	usages: [{
+		when: "une vue n’a pas de donnée à montrer",
+		use: "<EmptyState title={t('empty')} description={…} action={<Button…/>} />",
+		avoid: "un `<div>` stylé au coup par coup : on perd les tokens de la carte"
+	}, {
+		when: "un lot est illisible (pas vide, mais en panne)",
+		use: "le `detail` brut, pour nommer la vraie panne plutôt que la masquer",
+		avoid: "un zéro ou un vide silencieux là où le signal est illisible"
+	}]
+};
+//#endregion
+//#region src/components/chip/chip.tsx
+/** La hauteur d'une puce selon sa taille. */
+var chipSizeClasses = {
+	default: "h-6",
+	sm: "h-5 text-[11px]"
+};
+/**
+* La puce : une étiquette compacte, éventuellement retirable. Présentation seule — l'app
+* fournit le libellé, l'icône et l'action de retrait (ADR 0015).
+*/
+function Chip({ tone = "neutral", size = "default", icon, children, onRemove, removeLabel, disabled = false, className }) {
+	return /* @__PURE__ */ jsxs("span", {
+		className: cn("inline-flex max-w-full items-center gap-1 rounded-full border px-2.5 text-xs font-medium", chipSizeClasses[size], toneClasses[tone], className),
+		children: [
+			icon ? /* @__PURE__ */ jsx("span", {
+				"aria-hidden": true,
+				className: "shrink-0",
+				children: icon
+			}) : null,
+			/* @__PURE__ */ jsx("span", {
+				className: "truncate",
+				children
+			}),
+			onRemove ? /* @__PURE__ */ jsx("button", {
+				type: "button",
+				"aria-label": removeLabel,
+				disabled,
+				onClick: onRemove,
+				className: "-mr-1 shrink-0 rounded-full p-0.5 opacity-70 transition-opacity hover:opacity-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-40",
+				children: /* @__PURE__ */ jsx(X, {
+					className: "size-3",
+					"aria-hidden": true
+				})
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/components/chip/manifest.ts
+/** Le manifeste de la puce (ADR 0005, ADR 0015). Le ton réutilise `toneClasses`. */
+var chipManifest = {
+	name: "chip",
+	title: "Chip",
+	summary: "Une étiquette compacte, éventuellement retirable. Le ton vient du cœur (une intention) ; l'app fournit le libellé, l'icône et l'action de retrait.",
+	level: "primitive",
+	example: {
+		tone: "neutral",
+		size: "default",
+		children: "filtre"
+	},
+	variants: [{
+		name: "tone",
+		values: [...TONES],
+		default: "neutral",
+		description: "L'intention de la puce — ce que l'appelant choisit selon l'usage."
+	}, {
+		name: "size",
+		values: ["default", "sm"],
+		default: "default",
+		description: "La taille de la puce, du plus lisible au plus discret."
+	}],
+	props: [
+		{
+			name: "children",
+			type: "ReactNode",
+			required: true,
+			check: "content",
+			description: "Le libellé de la puce : court, jamais une phrase."
+		},
+		{
+			name: "icon",
+			type: "ReactNode",
+			required: false,
+			check: "accepted",
+			description: "Une icône de tête, fournie par l'appelant."
+		},
+		{
+			name: "onRemove",
+			type: "() => void",
+			required: false,
+			check: "accepted",
+			description: "Affiche un bouton de retrait et le rappelle au clic."
+		},
+		{
+			name: "removeLabel",
+			type: "string",
+			required: false,
+			check: "accepted",
+			description: "Le libellé accessible du bouton de retrait (requis avec `onRemove`)."
+		},
+		{
+			name: "disabled",
+			type: "boolean",
+			required: false,
+			check: "accepted",
+			description: "Désactive le bouton de retrait."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		}
+	],
+	usages: [{
+		when: "montrer un filtre actif qu’on peut retirer",
+		use: "<Chip onRemove={…} removeLabel={…}>domaine : ui</Chip>",
+		avoid: "un `Badge` pour quelque chose de retirable : le `Badge` n’est pas interactif"
+	}, {
+		when: "qualifier un élément sans action",
+		use: "un `Chip` sans `onRemove`",
+		avoid: "un `Chip` pour un statut de production : un `Badge` dit l’état sans inviter au clic"
+	}]
+};
+//#endregion
+//#region src/components/freshness/freshness.tsx
+function Freshness({ label, title, stale = false, className, ...props }) {
+	return /* @__PURE__ */ jsxs("span", {
+		className: cn("inline-flex items-center gap-1.5 whitespace-nowrap text-xs", stale ? "text-destructive" : "text-muted-foreground", className),
+		title: title ?? void 0,
+		...props,
+		children: [/* @__PURE__ */ jsx("span", {
+			"aria-hidden": true,
+			className: cn("size-1.5 shrink-0 rounded-full", stale ? "bg-destructive" : "bg-muted-foreground/50")
+		}), label]
+	});
+}
+//#endregion
+//#region src/components/freshness/manifest.ts
+/**
+* Le manifeste de l'indicateur de fraîcheur (ADR 0005). L'âge est injecté par
+* l'appelant : c'est lui qui formate (« il y a 2 heures ») et qui décide du seuil de
+* péremption ; le cœur ne fait que le rendre.
+*/
+var freshnessManifest = {
+	name: "freshness",
+	title: "Freshness",
+	summary: "L'âge d'une donnée depuis sa dernière mise à jour, avec une pastille qui passe au rouge quand elle est périmée. Se rend seule, hors d'une table : une cellule comme un bandeau de provenance l’utilisent.",
+	level: "primitive",
+	example: {
+		label: "il y a 2 heures",
+		stale: false
+	},
+	variants: [],
+	props: [
+		{
+			name: "label",
+			type: "string",
+			required: true,
+			check: "rendered",
+			description: "L'âge déjà formaté par l'appelant : le cœur n'a pas d'i18n."
+		},
+		{
+			name: "stale",
+			type: "boolean",
+			required: false,
+			check: "rendered",
+			description: "Vrai quand la donnée dépasse le seuil de péremption décidé par l'appelant."
+		},
+		{
+			name: "title",
+			type: "string | null",
+			required: false,
+			check: "attribute",
+			description: "L'horodatage absolu, transmis comme infobulle HTML."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		}
+	],
+	usages: [{
+		when: "une cellule dit depuis quand une donnée n'a pas bougé",
+		use: "<Freshness label={relativeTime(row.updated_at)} />",
+		avoid: "un `<span>` nu : la pastille est le repère visuel de fraîcheur"
+	}, {
+		when: "un bandeau dit la fraîcheur d'un instantané",
+		use: "<Freshness label={age} title={absolute} stale={olderThanADay} />",
+		avoid: "un seuil de péremption dans le cœur : il dépend du domaine, pas du rendu"
+	}]
+};
+//#endregion
+//#region src/components/input/input.tsx
+/**
+* Le champ de saisie du cœur : un `<input>` stylé par les tokens. Il n'impose aucune
+* validation ni aucun état d'app — l'appelant passe ses props HTML et ses classes.
+*/
+function Input({ className, type, ...props }) {
+	return /* @__PURE__ */ jsx("input", {
+		type,
+		className: cn("flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-base ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 md:text-sm", className),
+		...props
+	});
+}
+//#endregion
+//#region src/components/input/manifest.ts
+/**
+* Le manifeste du champ de saisie (ADR 0005). Le cœur ne pose ni validation ni état :
+* l'appelant passe ses props HTML, la valeur et le rappel restent chez lui.
+*/
+var inputManifest = {
+	name: "input",
+	title: "Input",
+	summary: "Un champ de saisie d'une ligne. Il porte le style des tokens et transmet tout attribut HTML d'`<input>` ; la valeur et le changement restent à l'appelant.",
+	level: "primitive",
+	example: { placeholder: "rechercher" },
+	variants: [],
+	props: [
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		},
+		{
+			name: "type",
+			type: "string",
+			required: false,
+			check: "attribute",
+			description: "Le type HTML du champ (`text`, `search`, `password`…)."
+		},
+		{
+			name: "placeholder",
+			type: "string",
+			required: false,
+			check: "attribute",
+			description: "Le texte d'invite, affiché tant que le champ est vide."
+		}
+	],
+	usages: [{
+		when: "un champ de recherche dans une barre d’outils",
+		use: "<Input type=\"search\" placeholder={…} />",
+		avoid: "un placeholder à la place d’un libellé durable, pour un champ de formulaire"
+	}, {
+		when: "un champ contrôlé",
+		use: "<Input value={v} onChange={…} /> (l’état reste dans l’app)",
+		avoid: "attendre un état interne du cœur : il n’en a pas"
+	}]
+};
+//#endregion
+//#region src/components/number-field/number-field.tsx
+/**
+* Le champ numérique du cœur : un `<input>` en `type="number"`, donc le pas (`step`) et
+* les bornes (`min`/`max`) viennent du natif. Aucune validation ni i18n : la valeur et le
+* rappel restent chez l'appelant, comme `Input` (ADR 0015).
+*/
+function NumberField({ type = "number", ...props }) {
+	return /* @__PURE__ */ jsx(Input, {
+		type,
+		...props
+	});
+}
+//#endregion
+//#region src/components/number-field/manifest.ts
+/** Le manifeste du champ numérique (ADR 0005, ADR 0015). Le natif porte pas et bornes. */
+var numberFieldManifest = {
+	name: "number-field",
+	title: "NumberField",
+	summary: "Un champ numérique (`<input type=\"number\">`) : le pas et les bornes viennent du natif (`step`, `min`, `max`). La valeur et le rappel restent à l'appelant.",
+	level: "primitive",
+	example: {
+		placeholder: "0",
+		step: 1,
+		min: 0,
+		max: 10
+	},
+	variants: [],
+	props: [
+		{
+			name: "step",
+			type: "number",
+			required: false,
+			check: "attribute",
+			description: "Le pas du compteur natif."
+		},
+		{
+			name: "min",
+			type: "number",
+			required: false,
+			check: "attribute",
+			description: "La borne basse."
+		},
+		{
+			name: "max",
+			type: "number",
+			required: false,
+			check: "attribute",
+			description: "La borne haute."
+		},
+		{
+			name: "placeholder",
+			type: "string",
+			required: false,
+			check: "attribute",
+			description: "Le texte d'invite, affiché tant que le champ est vide."
+		},
+		{
+			name: "value",
+			type: "string",
+			required: false,
+			check: "accepted",
+			description: "La valeur courante, contrôlée par l’appelant."
+		},
+		{
+			name: "onChange",
+			type: "ChangeEventHandler<HTMLInputElement>",
+			required: false,
+			check: "accepted",
+			description: "Le rappel de saisie."
+		},
+		{
+			name: "disabled",
+			type: "boolean",
+			required: false,
+			check: "accepted",
+			description: "Désactive le champ."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		}
+	],
+	usages: [{
+		when: "poser un nombre borné avec un pas",
+		use: "<NumberField min={0} max={100} step={5} value={v} onChange={…} />",
+		avoid: "attendre une validation ou un formatage du cœur : ils appartiennent à l’app"
+	}, {
+		when: "un champ contrôlé",
+		use: "<NumberField value={v} onChange={…} /> (l’état reste dans l’app)",
+		avoid: "un état interne : le cœur n’en a pas"
+	}]
+};
+//#endregion
+//#region src/components/search-field/search-field.tsx
+function SearchField({ value, onChange, clearLabel, placeholder, className }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("relative", className),
+		children: [
+			/* @__PURE__ */ jsx(Search, { className: "pointer-events-none absolute left-3 top-1/2 size-4 -translate-y-1/2 text-muted-foreground" }),
+			/* @__PURE__ */ jsx(Input, {
+				type: "search",
+				value,
+				onChange: (event) => onChange(event.target.value),
+				placeholder,
+				className: "pl-9 pr-9"
+			}),
+			value ? /* @__PURE__ */ jsx("button", {
+				type: "button",
+				"aria-label": clearLabel,
+				onClick: () => onChange(""),
+				className: "absolute right-2 top-1/2 grid size-6 -translate-y-1/2 place-items-center rounded text-muted-foreground hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+				children: /* @__PURE__ */ jsx(X, { className: "size-4" })
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/components/search-field/manifest.ts
+/** Le manifeste du champ de recherche (ADR 0005, ADR 0015). Le cœur ne connaît pas l'i18n. */
+var searchFieldManifest = {
+	name: "search-field",
+	title: "SearchField",
+	summary: "Un champ de recherche avec icône et bouton d'effacement, contrôlé par props (`value` + `onChange`). Le libellé « effacer » est injecté : le cœur n'a pas d'i18n.",
+	level: "primitive",
+	example: {
+		value: "",
+		onChange: () => {},
+		clearLabel: "Effacer",
+		placeholder: "rechercher"
+	},
+	variants: [],
+	props: [
+		{
+			name: "value",
+			type: "string",
+			required: true,
+			check: "accepted",
+			description: "Le terme courant, contrôlé par l’appelant."
+		},
+		{
+			name: "onChange",
+			type: "(value: string) => void",
+			required: true,
+			check: "accepted",
+			description: "Le rappel de saisie **et** d’effacement (le bouton renvoie la chaîne vide)."
+		},
+		{
+			name: "clearLabel",
+			type: "string",
+			required: true,
+			check: "accepted",
+			description: "Le libellé accessible du bouton d'effacement."
+		},
+		{
+			name: "placeholder",
+			type: "string",
+			required: false,
+			check: "attribute",
+			description: "Le texte d'invite, affiché tant que le champ est vide."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		}
+	],
+	usages: [{
+		when: "chercher dans une liste ou une barre d’outils",
+		use: "<SearchField value={v} onChange={set} clearLabel={t('clear')} />",
+		avoid: "un `Input type=\"search\"` nu quand il faut l’icône et l’effacement"
+	}, {
+		when: "effacer la recherche",
+		use: "le bouton intégré, qui rappelle `onChange(\"\")`",
+		avoid: "gérer l’effacement dans l’app quand le champ est déjà rempli"
+	}]
+};
+//#endregion
+//#region src/components/label/label.tsx
+/** Le libellé d'un champ : associé au contrôle par `htmlFor`. Tout texte vient de l'app. */
+function Label({ className, ...props }) {
+	return /* @__PURE__ */ jsx("label", {
+		className: cn("text-sm font-medium leading-none", className),
+		...props
+	});
+}
+//#endregion
+//#region src/components/label/manifest.ts
+/** Le manifeste du libellé (ADR 0005, ADR 0015). */
+var labelManifest = {
+	name: "label",
+	title: "Label",
+	summary: "Le libellé d'un champ, associé au contrôle par `htmlFor`. Le texte vient de l'appelant (le cœur n'a pas d'i18n) ; la typographie vient des tokens.",
+	level: "primitive",
+	example: { children: "Libellé" },
+	variants: [],
+	props: [
+		{
+			name: "htmlFor",
+			type: "string",
+			required: false,
+			check: "accepted",
+			description: "L'`id` du contrôle associé : clique le libellé et le champ prend le focus (rendu en attribut `for`)."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		},
+		{
+			name: "children",
+			type: "ReactNode",
+			required: true,
+			check: "content",
+			description: "Le texte du libellé, injecté par l'app."
+		}
+	],
+	usages: [{
+		when: "nommer un champ et l’associer à son contrôle",
+		use: "<Label htmlFor=\"email\">Adresse</Label>",
+		avoid: "un libellé sans `htmlFor` : le clic ne donne pas le focus au champ"
+	}, {
+		when: "poser un libellé hors d’un `Field`",
+		use: "le même atome, avec ton propre espacement",
+		avoid: "coder un `<label>` stylé à la main : on perd la typographie des tokens"
+	}]
+};
+//#endregion
+//#region src/components/fieldset/fieldset.tsx
+/** Un regroupement de champs apparentés ; l'app fournit le titre (`legend`). */
+function Fieldset({ className, ...props }) {
+	return /* @__PURE__ */ jsx("fieldset", {
+		className: cn("flex flex-col gap-4", className),
+		...props
+	});
+}
+//#endregion
+//#region src/components/fieldset/manifest.ts
+/** Le manifeste du regroupement de champs (ADR 0005, ADR 0015). */
+var fieldsetManifest = {
+	name: "fieldset",
+	title: "Fieldset",
+	summary: "Un regroupement de champs apparentés. Sémantique (`fieldset`) et espacement des tokens ; le titre du groupe (`legend`) vient de l'app.",
+	level: "primitive",
+	example: { children: "groupe de champs" },
+	variants: [],
+	props: [{
+		name: "className",
+		type: "string",
+		required: false,
+		check: "class",
+		description: "Les classes de l'appelant, fusionnées après celles du cœur."
+	}, {
+		name: "children",
+		type: "ReactNode",
+		required: true,
+		check: "content",
+		description: "Les champs regroupés (et leur `legend`)."
+	}],
+	usages: [{
+		when: "regrouper des champs apparentés d’un formulaire",
+		use: "<Fieldset><legend>…</legend> …champs… </Fieldset>",
+		avoid: "un `<div>` : on perd la sémantique de groupe de formulaire"
+	}]
+};
+//#endregion
+//#region src/components/field/field.tsx
+function Field({ label, hint, error, htmlFor, className, children }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("flex flex-col gap-1.5", className),
+		children: [
+			label ? /* @__PURE__ */ jsx(Label, {
+				htmlFor,
+				children: label
+			}) : null,
+			children,
+			error ? /* @__PURE__ */ jsx("p", {
+				className: "text-xs text-destructive",
+				children: error
+			}) : hint ? /* @__PURE__ */ jsx("p", {
+				className: "text-xs text-muted-foreground",
+				children: hint
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/components/field/manifest.ts
+/** Le manifeste de l'emplacement de champ (ADR 0005, ADR 0015). */
+var fieldManifest = {
+	name: "field",
+	title: "Field",
+	summary: "L'emplacement d'un champ : libellé, contrôle (fourni par l'app), puis aide ou message d'erreur. Aucun moteur : l'app possède l'état, la validation et les textes.",
+	level: "primitive",
+	example: {
+		label: "Libellé",
+		hint: "Aide",
+		children: "champ"
+	},
+	variants: [],
+	props: [
+		{
+			name: "label",
+			type: "ReactNode",
+			required: false,
+			check: "rendered",
+			description: "Le libellé du champ ; absent, aucun libellé n'est rendu."
+		},
+		{
+			name: "hint",
+			type: "ReactNode",
+			required: false,
+			check: "rendered",
+			description: "L'aide sous le champ, affichée quand il n'y a pas d'erreur."
+		},
+		{
+			name: "error",
+			type: "string | null",
+			required: false,
+			check: "rendered",
+			description: "Le message d'erreur, **déjà formaté** par l'app : il remplace l'aide."
+		},
+		{
+			name: "htmlFor",
+			type: "string",
+			required: false,
+			check: "accepted",
+			description: "L'`id` du contrôle, transmis au libellé en attribut `for`."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		},
+		{
+			name: "children",
+			type: "ReactNode",
+			required: true,
+			check: "content",
+			description: "Le contrôle (Input, Select, …), fourni par l’appelant."
+		}
+	],
+	usages: [{
+		when: "poser un libellé, un contrôle et une aide",
+		use: "<Field label=\"Adresse\" hint=\"…\"><Input … /></Field>",
+		avoid: "attendre une validation du cœur : le message d’erreur est injecté, pas calculé"
+	}, {
+		when: "montrer une erreur de validation",
+		use: "<Field label=\"Adresse\" error={message}>…</Field>",
+		avoid: "passer la règle ou le champ fautif : le cœur ne connaît que le texte final"
+	}]
+};
+//#endregion
+//#region src/components/form/form.tsx
+function Form({ columns = 1, actions, children, className, ...props }) {
+	return /* @__PURE__ */ jsxs("form", {
+		className: cn("flex flex-col gap-6", className),
+		...props,
+		children: [/* @__PURE__ */ jsx("div", {
+			className: cn("grid gap-4", columns === 2 && "md:grid-cols-2"),
+			children
+		}), actions ? /* @__PURE__ */ jsx("div", {
+			className: "flex items-center justify-end gap-2",
+			children: actions
+		}) : null]
+	});
+}
+//#endregion
+//#region src/components/form/manifest.ts
+/** Le manifeste du bloc de formulaire (ADR 0005, ADR 0015). Mise en page seule, sans moteur. */
+var formManifest = {
+	name: "form",
+	title: "Form",
+	summary: "La mise en page d'un formulaire : une grille de champs et une zone d'actions, dans un `<form>`. Aucune validation, aucun état, aucun texte — l'app fournit champs et actions.",
+	level: "bloc",
+	example: {
+		children: "un champ",
+		columns: 1,
+		actions: "actions"
+	},
+	variants: [],
+	props: [
+		{
+			name: "columns",
+			type: "1 | 2",
+			required: false,
+			default: "1",
+			check: "accepted",
+			description: "Le nombre de colonnes de la grille de champs à partir du palier `md`."
+		},
+		{
+			name: "actions",
+			type: "ReactNode",
+			required: false,
+			check: "accepted",
+			description: "La zone d'actions sous les champs (boutons fournis par l'app)."
+		},
+		{
+			name: "onSubmit",
+			type: "FormEventHandler<HTMLFormElement>",
+			required: false,
+			check: "accepted",
+			description: "La soumission, gérée par l’appelant (le cœur ne soumet rien)."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		}
+	],
+	usages: [{
+		when: "mettre en page un formulaire contrôlé",
+		use: "<Form actions={<Button type=\"submit\">…</Button>}><Fieldset>…</Fieldset></Form>",
+		avoid: "attendre du cœur qu’il valide, soumette ou affiche une erreur : il ne le fait pas"
+	}, {
+		when: "ranger des champs sur deux colonnes",
+		use: "<Form columns={2}> (deux colonnes à partir du palier `md`)",
+		avoid: "une grille maison dans l’app quand le bloc la fournit déjà"
+	}]
+};
+//#endregion
+//#region src/internal/dropdown-menu.tsx
+var DropdownMenu = DropdownMenuPrimitive.Root;
+var DropdownMenuTrigger = DropdownMenuPrimitive.Trigger;
+var DropdownMenuSubTrigger = React.forwardRef(({ className, inset, children, ...props }, ref) => /* @__PURE__ */ jsxs(DropdownMenuPrimitive.SubTrigger, {
+	ref,
+	className: cn("flex cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent data-[state=open]:bg-accent [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0", inset && "pl-8", className),
+	...props,
+	children: [children, /* @__PURE__ */ jsx(ChevronRight, { className: "ml-auto" })]
+}));
+DropdownMenuSubTrigger.displayName = DropdownMenuPrimitive.SubTrigger.displayName;
+var DropdownMenuSubContent = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(DropdownMenuPrimitive.SubContent, {
+	ref,
+	className: cn("z-50 min-w-32 overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-dropdown-menu-content-transform-origin]", className),
+	...props
+}));
+DropdownMenuSubContent.displayName = DropdownMenuPrimitive.SubContent.displayName;
+var DropdownMenuContent = React.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx(DropdownMenuPrimitive.Portal, { children: /* @__PURE__ */ jsx(DropdownMenuPrimitive.Content, {
+	ref,
+	sideOffset,
+	className: cn("z-50 max-h-[var(--radix-dropdown-menu-content-available-height)] min-w-32 overflow-y-auto overflow-x-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-dropdown-menu-content-transform-origin]", className),
+	...props
+}) }));
+DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName;
+var DropdownMenuItem = React.forwardRef(({ className, inset, ...props }, ref) => /* @__PURE__ */ jsx(DropdownMenuPrimitive.Item, {
+	ref,
+	className: cn("relative flex cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0", inset && "pl-8", className),
+	...props
+}));
+DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName;
+var DropdownMenuCheckboxItem = React.forwardRef(({ className, children, checked, ...props }, ref) => /* @__PURE__ */ jsxs(DropdownMenuPrimitive.CheckboxItem, {
+	ref,
+	className: cn("relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className),
+	checked,
+	...props,
+	children: [/* @__PURE__ */ jsx("span", {
+		className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center",
+		children: /* @__PURE__ */ jsx(DropdownMenuPrimitive.ItemIndicator, { children: /* @__PURE__ */ jsx(Check, { className: "h-4 w-4" }) })
+	}), children]
+}));
+DropdownMenuCheckboxItem.displayName = DropdownMenuPrimitive.CheckboxItem.displayName;
+var DropdownMenuRadioItem = React.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(DropdownMenuPrimitive.RadioItem, {
+	ref,
+	className: cn("relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className),
+	...props,
+	children: [/* @__PURE__ */ jsx("span", {
+		className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center",
+		children: /* @__PURE__ */ jsx(DropdownMenuPrimitive.ItemIndicator, { children: /* @__PURE__ */ jsx(Circle, { className: "h-2 w-2 fill-current" }) })
+	}), children]
+}));
+DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName;
+var DropdownMenuLabel = React.forwardRef(({ className, inset, ...props }, ref) => /* @__PURE__ */ jsx(DropdownMenuPrimitive.Label, {
+	ref,
+	className: cn("px-2 py-1.5 text-sm font-semibold", inset && "pl-8", className),
+	...props
+}));
+DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName;
+var DropdownMenuSeparator = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(DropdownMenuPrimitive.Separator, {
+	ref,
+	className: cn("-mx-1 my-1 h-px bg-muted", className),
+	...props
+}));
+DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName;
+var DropdownMenuShortcut = ({ className, ...props }) => {
+	return /* @__PURE__ */ jsx("span", {
+		className: cn("ml-auto text-xs tracking-widest opacity-60", className),
+		...props
+	});
+};
+DropdownMenuShortcut.displayName = "DropdownMenuShortcut";
+//#endregion
+//#region src/components/facet-filter/facet-filter.tsx
+function FacetFilter({ label, options, selected, onChange, clearLabel, className }) {
+	const toggle = (value) => {
+		onChange(selected.includes(value) ? selected.filter((item) => item !== value) : [...selected, value]);
+	};
+	return /* @__PURE__ */ jsxs(DropdownMenu, { children: [/* @__PURE__ */ jsx(DropdownMenuTrigger, {
+		asChild: true,
+		children: /* @__PURE__ */ jsxs(Button, {
+			variant: "outline",
+			size: "sm",
+			className: cn("h-8 gap-1 border-dashed", className),
+			children: [
+				label,
+				selected.length > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", { className: "mx-1 h-4 w-px bg-border" }), /* @__PURE__ */ jsx(Badge, {
+					variant: "secondary",
+					className: "rounded px-1 text-[10px]",
+					children: selected.length
+				})] }) : null,
+				/* @__PURE__ */ jsx(ChevronDown, { className: "size-3.5 opacity-60" })
+			]
+		})
+	}), /* @__PURE__ */ jsxs(DropdownMenuContent, {
+		align: "start",
+		className: "max-h-72 w-56 overflow-y-auto",
+		children: [options.map((option) => {
+			const isSelected = selected.includes(option.value);
+			return /* @__PURE__ */ jsxs(DropdownMenuItem, {
+				onSelect: (event) => {
+					event.preventDefault();
+					toggle(option.value);
+				},
+				className: "gap-2",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: cn("grid size-4 shrink-0 place-items-center rounded border", isSelected ? "border-primary bg-primary text-primary-foreground" : "opacity-60"),
+						children: isSelected ? /* @__PURE__ */ jsx(Check, { className: "size-3" }) : null
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "flex-1 truncate",
+						children: option.label
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "text-xs tabular-nums text-muted-foreground",
+						children: option.count
+					})
+				]
+			}, option.value);
+		}), selected.length > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(DropdownMenuSeparator, {}), /* @__PURE__ */ jsx(DropdownMenuItem, {
+			onSelect: () => onChange([]),
+			className: "justify-center text-xs text-muted-foreground",
+			children: clearLabel
+		})] }) : null]
+	})] });
+}
+//#endregion
+//#region src/components/facet-filter/manifest.ts
+/**
+* Le manifeste du filtre à facettes (ADR 0005). Les options, la sélection et les
+* libellés sont injectés : c'est ce qui l'importe hors d'une table.
+*/
+var facetFilterManifest = {
+	name: "facet-filter",
+	title: "FacetFilter",
+	summary: "Un menu à choix multiples sur une facette : chaque option porte son compte, et la sélection se cumule. Rien ne vient de l’app — options, sélection et libellé « effacer » sont injectés.",
+	level: "primitive",
+	example: {
+		label: "dépôt",
+		options: [{
+			value: "workout-app",
+			label: "workout-app",
+			count: 3
+		}, {
+			value: "mijote",
+			label: "mijote",
+			count: 1
+		}],
+		selected: ["workout-app"],
+		onChange: () => {},
+		clearLabel: "Effacer"
+	},
+	variants: [],
+	props: [
+		{
+			name: "label",
+			type: "string",
+			required: true,
+			check: "rendered",
+			description: "Le nom de la facette, porté par le déclencheur."
+		},
+		{
+			name: "options",
+			type: "FacetOption[]",
+			required: true,
+			check: "accepted",
+			description: "Les valeurs filtrables, chacune avec son libellé et son compte."
+		},
+		{
+			name: "selected",
+			type: "string[]",
+			required: true,
+			check: "accepted",
+			description: "Les valeurs déjà retenues ; le compte s’affiche sur le déclencheur."
+		},
+		{
+			name: "onChange",
+			type: "(next: string[]) => void",
+			required: true,
+			check: "accepted",
+			description: "Le rappel de sélection : la liste complète des valeurs retenues."
+		},
+		{
+			name: "clearLabel",
+			type: "string",
+			required: true,
+			check: "accepted",
+			description: "Le libellé de l'entrée qui efface la sélection (le cœur n'a pas d'i18n)."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées sur le déclencheur."
+		}
+	],
+	usages: [{
+		when: "filtrer une liste par une de ses dimensions",
+		use: "<FacetFilter label=\"dépôt\" options={…} selected={…} onChange={…} clearLabel={…} />",
+		avoid: "coder une facette produit dans le cœur : les options sont des données d’app"
+	}, {
+		when: "filtrer autre chose qu’une table (une carte, une liste)",
+		use: "le même atome, avec les options de la source",
+		avoid: "le coupler à un query-param : l’état de sélection appartient à l’appelant"
+	}]
+};
+//#endregion
+//#region src/components/data-table-toolbar/data-table-toolbar.tsx
+function DataTableToolbar({ globalFilter, onGlobalFilterChange, placeholder, facets, shownLabel, canReset, resetLabel, clearFacetLabel, onReset, columns, actions }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col gap-3 lg:flex-row lg:items-center lg:justify-between",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "relative w-full lg:max-w-xs",
+			children: [/* @__PURE__ */ jsx(Search, { className: "absolute left-3 top-1/2 size-4 -translate-y-1/2 text-muted-foreground" }), /* @__PURE__ */ jsx(Input, {
+				value: globalFilter,
+				onChange: (event) => onGlobalFilterChange(event.target.value),
+				placeholder,
+				className: "h-8 pl-9"
+			})]
+		}), /* @__PURE__ */ jsxs("div", {
+			className: "flex flex-wrap items-center gap-2",
+			children: [
+				facets.map((facet) => /* @__PURE__ */ jsx(FacetFilter, {
+					label: facet.label,
+					options: facet.options,
+					selected: facet.selected,
+					onChange: facet.onChange,
+					clearLabel: clearFacetLabel
+				}, facet.id)),
+				columns ? /* @__PURE__ */ jsxs(DropdownMenu, { children: [/* @__PURE__ */ jsx(DropdownMenuTrigger, {
+					asChild: true,
+					children: /* @__PURE__ */ jsxs(Button, {
+						variant: "outline",
+						size: "sm",
+						className: "h-8 gap-1 border-dashed",
+						children: [columns.label, /* @__PURE__ */ jsx(ChevronDown, { className: "size-3.5 opacity-60" })]
+					})
+				}), /* @__PURE__ */ jsxs(DropdownMenuContent, {
+					align: "start",
+					className: "w-56",
+					children: [
+						columns.options.map((option) => /* @__PURE__ */ jsxs(DropdownMenuItem, {
+							onSelect: (event) => {
+								event.preventDefault();
+								columns.onToggle(option.id, !option.visible);
+							},
+							className: "gap-2",
+							children: [
+								/* @__PURE__ */ jsx("span", {
+									className: cn("grid size-4 shrink-0 place-items-center rounded border", option.visible ? "border-primary bg-primary text-primary-foreground" : "opacity-60"),
+									children: option.visible ? /* @__PURE__ */ jsx(Check, { className: "size-3" }) : null
+								}),
+								/* @__PURE__ */ jsx("span", {
+									className: "flex-1 truncate",
+									children: option.label
+								}),
+								columns.onMove ? /* @__PURE__ */ jsxs("span", {
+									className: "flex items-center gap-0.5",
+									children: [/* @__PURE__ */ jsx("button", {
+										type: "button",
+										"aria-label": columns.moveUpLabel?.(option.label) ?? option.label,
+										className: "rounded p-0.5 text-muted-foreground hover:text-foreground",
+										onClick: (event) => {
+											event.stopPropagation();
+											event.preventDefault();
+											columns.onMove?.(option.id, -1);
+										},
+										children: /* @__PURE__ */ jsx(ChevronUp, { className: "size-3.5" })
+									}), /* @__PURE__ */ jsx("button", {
+										type: "button",
+										"aria-label": columns.moveDownLabel?.(option.label) ?? option.label,
+										className: "rounded p-0.5 text-muted-foreground hover:text-foreground",
+										onClick: (event) => {
+											event.stopPropagation();
+											event.preventDefault();
+											columns.onMove?.(option.id, 1);
+										},
+										children: /* @__PURE__ */ jsx(ChevronDown, { className: "size-3.5" })
+									})]
+								}) : null
+							]
+						}, option.id)),
+						/* @__PURE__ */ jsx(DropdownMenuSeparator, {}),
+						/* @__PURE__ */ jsx(DropdownMenuItem, {
+							onSelect: () => columns.options.forEach((option) => columns.onToggle(option.id, true)),
+							className: "justify-center text-xs text-muted-foreground",
+							children: columns.clearLabel
+						})
+					]
+				})] }) : null,
+				canReset ? /* @__PURE__ */ jsxs(Button, {
+					variant: "ghost",
+					size: "sm",
+					className: "h-8",
+					onClick: onReset,
+					children: [resetLabel, /* @__PURE__ */ jsx(X, { className: "ml-1 size-3.5" })]
+				}) : null,
+				/* @__PURE__ */ jsx("span", {
+					className: "ml-1 hidden text-xs text-muted-foreground sm:inline",
+					children: shownLabel
+				}),
+				actions
+			]
+		})]
+	});
+}
+//#endregion
+//#region src/components/data-table-toolbar/manifest.ts
+/** Le manifeste de la barre d'outils de table (ADR 0005). Aucun libellé propre au cœur. */
+var dataTableToolbarManifest = {
+	name: "data-table-toolbar",
+	title: "DataTableToolbar",
+	summary: "La recherche, les facettes, la gestion des colonnes et le compte affiché d’une table. Elle ne connaît ni l'i18n de l'app ni ses query-params : état et libellés sont injectés.",
+	level: "bloc",
+	example: {
+		globalFilter: "",
+		onGlobalFilterChange: () => {},
+		placeholder: "rechercher",
+		facets: [],
+		shownLabel: "0 / 0",
+		canReset: true,
+		resetLabel: "Réinitialiser",
+		clearFacetLabel: "Effacer",
+		onReset: () => {},
+		columns: {
+			label: "Colonnes",
+			clearLabel: "Tout afficher",
+			options: [{
+				id: "name",
+				label: "nom",
+				visible: true
+			}],
+			onToggle: () => {}
+		}
+	},
+	variants: [],
+	props: [
+		{
+			name: "placeholder",
+			type: "string",
+			required: true,
+			check: "attribute",
+			description: "Le texte d'invite du champ de recherche."
+		},
+		{
+			name: "shownLabel",
+			type: "string",
+			required: true,
+			check: "rendered",
+			description: "Le compte affiché, déjà formaté par l’appelant."
+		},
+		{
+			name: "resetLabel",
+			type: "string",
+			required: true,
+			check: "rendered",
+			description: "Le libellé du bouton qui efface filtres et recherche."
+		},
+		{
+			name: "canReset",
+			type: "boolean",
+			required: true,
+			check: "rendered",
+			description: "Vrai quand il y a un filtre à effacer : le bouton apparaît alors."
+		},
+		{
+			name: "facets",
+			type: "Facet[]",
+			required: true,
+			check: "accepted",
+			description: "Les facettes liées (valeur, options, sélection, rappel)."
+		},
+		{
+			name: "globalFilter",
+			type: "string",
+			required: true,
+			check: "accepted",
+			description: "Le terme de recherche courant, contrôlé par l’appelant."
+		},
+		{
+			name: "onGlobalFilterChange",
+			type: "(value: string) => void",
+			required: true,
+			check: "accepted",
+			description: "Le rappel de saisie du champ de recherche."
+		},
+		{
+			name: "clearFacetLabel",
+			type: "string",
+			required: true,
+			check: "accepted",
+			description: "Le libellé d'effacement transmis à chaque filtre à facettes."
+		},
+		{
+			name: "onReset",
+			type: "() => void",
+			required: true,
+			check: "accepted",
+			description: "Le rappel du bouton de réinitialisation."
+		},
+		{
+			name: "columns",
+			type: "{ label: string; clearLabel: string; options: DataTableColumnOption[]; onToggle(id: string, visible: boolean): void; onMove?(id: string, direction: number): void; moveUpLabel?(label: string): string; moveDownLabel?(label: string): string }",
+			required: false,
+			check: "accepted",
+			description: "La gestion des colonnes : libellé du menu, colonnes masquables, bascule d'affichage et (fourni) déplacement haut/bas. Absente, aucun menu."
+		},
+		{
+			name: "actions",
+			type: "ReactNode",
+			required: false,
+			check: "accepted",
+			description: "Des actions complémentaires posées à droite de la barre."
+		}
+	],
+	usages: [{
+		when: "poser la recherche et les facettes d’une table",
+		use: "<DataTableToolbar … labels injectés />",
+		avoid: "lire un query-param dans le cœur : l’état appartient à l’appelant"
+	}, {
+		when: "laisser masquer/réafficher des colonnes",
+		use: "la prop `columns` (liste + rappel) ; absente, pas de menu",
+		avoid: "décider dans le cœur quelles colonnes sont masquables : la liste vient de l’app"
+	}]
+};
+//#endregion
+//#region src/internal/select.tsx
+var Select = SelectPrimitive.Root;
+var SelectGroup = SelectPrimitive.Group;
+var SelectValue = SelectPrimitive.Value;
+var SelectTrigger = React.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(SelectPrimitive.Trigger, {
+	ref,
+	className: cn("flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background data-[placeholder]:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1", className),
+	...props,
+	children: [children, /* @__PURE__ */ jsx(SelectPrimitive.Icon, {
+		asChild: true,
+		children: /* @__PURE__ */ jsx(ChevronDown, { className: "h-4 w-4 opacity-50" })
+	})]
+}));
+SelectTrigger.displayName = SelectPrimitive.Trigger.displayName;
+var SelectScrollUpButton = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(SelectPrimitive.ScrollUpButton, {
+	ref,
+	className: cn("flex cursor-default items-center justify-center py-1", className),
+	...props,
+	children: /* @__PURE__ */ jsx(ChevronUp, { className: "h-4 w-4" })
+}));
+SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName;
+var SelectScrollDownButton = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(SelectPrimitive.ScrollDownButton, {
+	ref,
+	className: cn("flex cursor-default items-center justify-center py-1", className),
+	...props,
+	children: /* @__PURE__ */ jsx(ChevronDown, { className: "h-4 w-4" })
+}));
+SelectScrollDownButton.displayName = SelectPrimitive.ScrollDownButton.displayName;
+var SelectContent = React.forwardRef(({ className, children, position = "popper", ...props }, ref) => /* @__PURE__ */ jsx(SelectPrimitive.Portal, { children: /* @__PURE__ */ jsxs(SelectPrimitive.Content, {
+	ref,
+	className: cn("relative z-50 max-h-[--radix-select-content-available-height] min-w-32 overflow-y-auto overflow-x-hidden rounded-md border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-select-content-transform-origin]", position === "popper" && "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1", className),
+	position,
+	...props,
+	children: [
+		/* @__PURE__ */ jsx(SelectScrollUpButton, {}),
+		/* @__PURE__ */ jsx(SelectPrimitive.Viewport, {
+			className: cn("p-1", position === "popper" && "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"),
+			children
+		}),
+		/* @__PURE__ */ jsx(SelectScrollDownButton, {})
+	]
+}) }));
+SelectContent.displayName = SelectPrimitive.Content.displayName;
+var SelectLabel = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(SelectPrimitive.Label, {
+	ref,
+	className: cn("py-1.5 pl-8 pr-2 text-sm font-semibold", className),
+	...props
+}));
+SelectLabel.displayName = SelectPrimitive.Label.displayName;
+var SelectItem = React.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(SelectPrimitive.Item, {
+	ref,
+	className: cn("relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className),
+	...props,
+	children: [/* @__PURE__ */ jsx("span", {
+		className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center",
+		children: /* @__PURE__ */ jsx(SelectPrimitive.ItemIndicator, { children: /* @__PURE__ */ jsx(Check, { className: "h-4 w-4" }) })
+	}), /* @__PURE__ */ jsx(SelectPrimitive.ItemText, { children })]
+}));
+SelectItem.displayName = SelectPrimitive.Item.displayName;
+var SelectSeparator = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(SelectPrimitive.Separator, {
+	ref,
+	className: cn("-mx-1 my-1 h-px bg-muted", className),
+	...props
+}));
+SelectSeparator.displayName = SelectPrimitive.Separator.displayName;
+//#endregion
+//#region src/components/data-table-pagination/data-table-pagination.tsx
+function DataTablePagination({ page, pageCount, pageSize, onPageSizeChange, onPrevious, onNext, canPrevious, canNext, rowsLabel, pageOf, previousLabel, nextLabel }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex items-center justify-between gap-3",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "flex items-center gap-2 text-xs text-muted-foreground",
+			children: [/* @__PURE__ */ jsx("span", { children: rowsLabel }), /* @__PURE__ */ jsxs(Select, {
+				value: String(pageSize),
+				onValueChange: (value) => onPageSizeChange(Number(value)),
+				children: [/* @__PURE__ */ jsx(SelectTrigger, {
+					className: "h-8 w-18",
+					children: /* @__PURE__ */ jsx(SelectValue, {})
+				}), /* @__PURE__ */ jsx(SelectContent, { children: [
+					10,
+					25,
+					50,
+					100
+				].map((size) => /* @__PURE__ */ jsx(SelectItem, {
+					value: String(size),
+					children: size
+				}, size)) })]
+			})]
+		}), /* @__PURE__ */ jsxs("div", {
+			className: "flex items-center gap-2",
+			children: [
+				/* @__PURE__ */ jsx("span", {
+					className: "text-xs text-muted-foreground",
+					children: pageOf(page, pageCount)
+				}),
+				/* @__PURE__ */ jsx(Button, {
+					variant: "outline",
+					size: "icon",
+					className: "size-8",
+					onClick: onPrevious,
+					disabled: !canPrevious,
+					"aria-label": previousLabel,
+					children: /* @__PURE__ */ jsx(ChevronLeft, { className: "size-4" })
+				}),
+				/* @__PURE__ */ jsx(Button, {
+					variant: "outline",
+					size: "icon",
+					className: "size-8",
+					onClick: onNext,
+					disabled: !canNext,
+					"aria-label": nextLabel,
+					children: /* @__PURE__ */ jsx(ChevronRight, { className: "size-4" })
+				})
+			]
+		})]
+	});
+}
+//#endregion
+//#region src/components/data-table-pagination/manifest.ts
+/** Le manifeste de la pagination (ADR 0005). Elle ne connaît pas TanStack, seulement des nombres. */
+var dataTablePaginationManifest = {
+	name: "data-table-pagination",
+	title: "DataTablePagination",
+	summary: "Le choix de la taille de page et les bornes de navigation. Elle ne dépend pas de la table : page, bornes et rappels suffisent, donc elle se rend hors d'une table.",
+	level: "bloc",
+	example: {
+		page: 1,
+		pageCount: 3,
+		pageSize: 25,
+		onPageSizeChange: () => {},
+		onPrevious: () => {},
+		onNext: () => {},
+		canPrevious: false,
+		canNext: true,
+		rowsLabel: "Lignes",
+		pageOf: (page, total) => `${page} / ${total}`,
+		previousLabel: "Page précédente",
+		nextLabel: "Page suivante"
+	},
+	variants: [],
+	props: [
+		{
+			name: "rowsLabel",
+			type: "string",
+			required: true,
+			check: "rendered",
+			description: "Le libellé devant le sélecteur de taille de page."
+		},
+		{
+			name: "pageOf",
+			type: "(page: number, total: number) => string",
+			required: true,
+			check: "rendered",
+			description: "Le formateur « page sur total », injecté par l’appelant."
+		},
+		{
+			name: "previousLabel",
+			type: "string",
+			required: true,
+			check: "rendered",
+			description: "Le libellé d’accessibilité du bouton précédent."
+		},
+		{
+			name: "nextLabel",
+			type: "string",
+			required: true,
+			check: "rendered",
+			description: "Le libellé d’accessibilité du bouton suivant."
+		},
+		{
+			name: "page",
+			type: "number",
+			required: true,
+			check: "rendered",
+			description: "La page courante, à partir de 1."
+		},
+		{
+			name: "pageCount",
+			type: "number",
+			required: true,
+			check: "rendered",
+			description: "Le nombre total de pages."
+		},
+		{
+			name: "pageSize",
+			type: "number",
+			required: true,
+			check: "rendered",
+			description: "Le nombre de lignes par page."
+		},
+		{
+			name: "canPrevious",
+			type: "boolean",
+			required: true,
+			check: "rendered",
+			description: "Vrai si une page précédente existe."
+		},
+		{
+			name: "canNext",
+			type: "boolean",
+			required: true,
+			check: "rendered",
+			description: "Vrai si une page suivante existe."
+		},
+		{
+			name: "onPageSizeChange",
+			type: "(size: number) => void",
+			required: true,
+			check: "accepted",
+			description: "Le rappel de changement de taille de page."
+		},
+		{
+			name: "onPrevious",
+			type: "() => void",
+			required: true,
+			check: "accepted",
+			description: "Le rappel de navigation vers la page précédente."
+		},
+		{
+			name: "onNext",
+			type: "() => void",
+			required: true,
+			check: "accepted",
+			description: "Le rappel de navigation vers la page suivante."
+		}
+	],
+	usages: [{
+		when: "naviguer dans une liste paginée",
+		use: "<DataTablePagination page={…} pageCount={…} onNext={…} … />",
+		avoid: "lui passer une table : elle n’a besoin que des nombres et des rappels"
+	}]
+};
+//#endregion
+//#region src/components/table/table.tsx
+/**
+* La table dense : une grille de lignes, en parts importables séparément. Aucune part
+* ne nomme un produit ni ne lit l'i18n de l'app — les libellés viennent de l'appelant,
+* les cellules de ce qu'il rend (ADR 0010).
+*
+* Les classes de l'appelant se fusionnent après celles du cœur, jamais avant.
+*/
+function Table({ className, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "relative w-full overflow-auto",
+		children: /* @__PURE__ */ jsx("table", {
+			className: cn("w-full caption-bottom text-sm", className),
+			...props
+		})
+	});
+}
+function TableHeader({ className, ...props }) {
+	return /* @__PURE__ */ jsx("thead", {
+		className: cn("[&_tr]:border-b", className),
+		...props
+	});
+}
+function TableBody({ className, ...props }) {
+	return /* @__PURE__ */ jsx("tbody", {
+		className: cn("[&_tr:last-child]:border-0", className),
+		...props
+	});
+}
+function TableRow({ className, ...props }) {
+	return /* @__PURE__ */ jsx("tr", {
+		className: cn("border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted", className),
+		...props
+	});
+}
+function TableHead({ className, ...props }) {
+	return /* @__PURE__ */ jsx("th", {
+		className: cn("h-12 px-4 text-left align-middle font-medium text-muted-foreground [&:has([role=checkbox])]:pr-0", className),
+		...props
+	});
+}
+function TableCell({ className, ...props }) {
+	return /* @__PURE__ */ jsx("td", {
+		className: cn("p-4 align-middle [&:has([role=checkbox])]:pr-0", className),
+		...props
+	});
+}
+//#endregion
+//#region src/features/data-table-features.ts
+/**
+* Le seul jeu de fonctionnalités que partagent les tables d'objets routés : filtrage
+* par facettes des colonnes, recherche globale, tri et pagination.
+*/
+var dataTableFeatures = tableFeatures({
+	columnFilteringFeature,
+	columnVisibilityFeature,
+	globalFilteringFeature,
+	rowSortingFeature,
+	rowPaginationFeature,
+	filteredRowModel: createFilteredRowModel(),
+	sortedRowModel: createSortedRowModel(),
+	paginatedRowModel: createPaginatedRowModel(),
+	columnMeta: {},
+	sortFns: {
+		alphanumeric: sortFn_alphanumeric,
+		basic: sortFn_basic,
+		datetime: sortFn_datetime,
+		text: sortFn_text
+	}
+});
+//#endregion
+//#region src/internal/sheet.tsx
+var Sheet = SheetPrimitive.Root;
+var SheetPortal = SheetPrimitive.Portal;
+var SheetOverlay = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(SheetPrimitive.Overlay, {
+	className: cn("fixed inset-0 z-50 bg-black/80  data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0", className),
+	...props,
+	ref
+}));
+SheetOverlay.displayName = SheetPrimitive.Overlay.displayName;
+var sheetVariants = cva("fixed z-50 gap-4 bg-background p-6 shadow-lg transition ease-in-out data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:duration-300 data-[state=open]:duration-500", {
+	variants: { side: {
+		top: "inset-x-0 top-0 border-b data-[state=closed]:slide-out-to-top data-[state=open]:slide-in-from-top",
+		bottom: "inset-x-0 bottom-0 border-t data-[state=closed]:slide-out-to-bottom data-[state=open]:slide-in-from-bottom",
+		left: "inset-y-0 left-0 h-full w-3/4 border-r data-[state=closed]:slide-out-to-left data-[state=open]:slide-in-from-left sm:max-w-sm",
+		right: "inset-y-0 right-0 h-full w-3/4  border-l data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right sm:max-w-sm"
+	} },
+	defaultVariants: { side: "right" }
+});
+var SheetContent = React.forwardRef(({ side = "right", className, children, ...props }, ref) => /* @__PURE__ */ jsxs(SheetPortal, { children: [/* @__PURE__ */ jsx(SheetOverlay, {}), /* @__PURE__ */ jsxs(SheetPrimitive.Content, {
+	ref,
+	className: cn(sheetVariants({ side }), className),
+	...props,
+	children: [children, /* @__PURE__ */ jsxs(SheetPrimitive.Close, {
+		className: "absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-secondary",
+		children: [/* @__PURE__ */ jsx(X, { className: "h-4 w-4" }), /* @__PURE__ */ jsx("span", {
+			className: "sr-only",
+			children: "Close"
+		})]
+	})]
+})] }));
+SheetContent.displayName = SheetPrimitive.Content.displayName;
+var SheetHeader = ({ className, ...props }) => /* @__PURE__ */ jsx("div", {
+	className: cn("flex flex-col space-y-2 text-center sm:text-left", className),
+	...props
+});
+SheetHeader.displayName = "SheetHeader";
+var SheetFooter = ({ className, ...props }) => /* @__PURE__ */ jsx("div", {
+	className: cn("flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2", className),
+	...props
+});
+SheetFooter.displayName = "SheetFooter";
+var SheetTitle = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(SheetPrimitive.Title, {
+	ref,
+	className: cn("text-lg font-semibold text-foreground", className),
+	...props
+}));
+SheetTitle.displayName = SheetPrimitive.Title.displayName;
+var SheetDescription = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(SheetPrimitive.Description, {
+	ref,
+	className: cn("text-sm text-muted-foreground", className),
+	...props
+}));
+SheetDescription.displayName = SheetPrimitive.Description.displayName;
+//#endregion
+//#region src/features/faceted-data-table.tsx
+function resolve$1(updater, previous) {
+	return typeof updater === "function" ? updater(previous) : updater;
+}
+function SelectionCheckbox({ checked, indeterminate = false, label, onChange }) {
+	return /* @__PURE__ */ jsx("input", {
+		type: "checkbox",
+		"aria-label": label,
+		checked,
+		ref: (node) => {
+			if (node) node.indeterminate = indeterminate;
+		},
+		onClick: (event) => event.stopPropagation(),
+		onChange: (event) => onChange(event.target.checked)
+	});
+}
+function FacetedDataTable({ data, renderColumns, facets, globalFilterFn, labels, detail, selection, columnManager, rowKey, state, onStateChange, actions }) {
+	const placement = detail?.placement ?? "overlay";
+	const controlled = state !== void 0;
+	const keyOf = useCallback((row) => rowKey ? rowKey(row) : String(data.indexOf(row)), [rowKey, data]);
+	const [internal, setInternal] = useState(() => ({
+		sorting: [],
+		globalFilter: "",
+		columnFilters: [],
+		pagination: {
+			pageIndex: 0,
+			pageSize: 25
+		},
+		openedKey: null,
+		selection: [],
+		columnVisibility: {},
+		columnOrder: []
+	}));
+	const current = state ?? internal;
+	const [draggingId, setDraggingId] = useState(null);
+	const update = useCallback((patch) => {
+		const next = {
+			...current,
+			...patch
+		};
+		if (controlled) onStateChange?.(next);
+		else setInternal(next);
+	}, [
+		controlled,
+		current,
+		onStateChange
+	]);
+	const resetPerPage = (patch) => update({
+		...patch,
+		pagination: {
+			...current.pagination,
+			pageIndex: 0
+		}
+	});
+	const openDetail = useCallback((row) => {
+		const key = keyOf(row);
+		if (placement === "inline") update({ openedKey: current.openedKey === key ? null : key });
+		else update({ openedKey: key });
+	}, [
+		current.openedKey,
+		keyOf,
+		placement,
+		update
+	]);
+	const baseColumns = useMemo(() => renderColumns(openDetail), [renderColumns, openDetail]);
+	const toggleRow = (key) => update({ selection: current.selection.includes(key) ? current.selection.filter((selected) => selected !== key) : [...current.selection, key] });
+	const selectedRows = data.filter((row) => current.selection.includes(keyOf(row)));
+	const selectionColumn = useMemo(() => ({
+		id: "__select__",
+		enableSorting: false,
+		enableGlobalFilter: false,
+		header: () => null,
+		cell: ({ row }) => /* @__PURE__ */ jsx(SelectionCheckbox, {
+			checked: current.selection.includes(keyOf(row.original)),
+			label: selection?.selectRowLabel(row.original) ?? "",
+			onChange: () => toggleRow(keyOf(row.original))
+		})
+	}), [
+		selection,
+		current.selection,
+		keyOf
+	]);
+	const orderedBase = useMemo(() => {
+		const order = current.columnOrder;
+		return [...baseColumns].sort((a, b) => {
+			const ai = order.indexOf(String(a.id));
+			const bi = order.indexOf(String(b.id));
+			return (ai === -1 ? Number.POSITIVE_INFINITY : ai) - (bi === -1 ? Number.POSITIVE_INFINITY : bi);
+		});
+	}, [baseColumns, current.columnOrder]);
+	const orderedIds = orderedBase.map((column) => String(column.id));
+	const moveColumn = (id, direction) => {
+		const from = orderedIds.indexOf(id);
+		const to = from + direction;
+		if (from === -1 || to < 0 || to >= orderedIds.length) return;
+		const next = [...orderedIds];
+		const [moved] = next.splice(from, 1);
+		next.splice(to, 0, moved);
+		update({ columnOrder: next });
+	};
+	const moveColumnBefore = (draggedId, targetId) => {
+		const from = orderedIds.indexOf(draggedId);
+		const to = orderedIds.indexOf(targetId);
+		if (from === -1 || to === -1 || from === to) return;
+		const next = [...orderedIds];
+		const [moved] = next.splice(from, 1);
+		next.splice(to, 0, moved);
+		update({ columnOrder: next });
+	};
+	const columns = useMemo(() => selection ? [selectionColumn, ...orderedBase] : orderedBase, [
+		selection,
+		selectionColumn,
+		orderedBase
+	]);
+	const defaultSorting = useMemo(() => columns.flatMap((column) => column.id && column.meta?.defaultSort ? [{
+		id: column.id,
+		desc: column.meta.defaultSort === "desc"
+	}] : []), [columns]);
+	const sorting = current.sorting.length ? current.sorting : defaultSorting;
+	const table = useTable({
+		features: dataTableFeatures,
+		data,
+		columns,
+		state: {
+			sorting,
+			globalFilter: current.globalFilter,
+			columnFilters: current.columnFilters,
+			pagination: current.pagination,
+			columnVisibility: current.columnVisibility
+		},
+		onSortingChange: (updater) => resetPerPage({ sorting: resolve$1(updater, current.sorting) }),
+		onGlobalFilterChange: (updater) => resetPerPage({ globalFilter: resolve$1(updater, current.globalFilter) }),
+		onColumnFiltersChange: (updater) => resetPerPage({ columnFilters: resolve$1(updater, current.columnFilters) }),
+		onPaginationChange: (updater) => update({ pagination: resolve$1(updater, current.pagination) }),
+		onColumnVisibilityChange: (updater) => update({ columnVisibility: resolve$1(updater, current.columnVisibility) }),
+		globalFilterFn
+	});
+	const selectedFor = (id) => current.columnFilters.find((filter) => filter.id === id)?.value ?? [];
+	const setFacet = (id, values) => resetPerPage({ columnFilters: [...current.columnFilters.filter((filter) => filter.id !== id), ...values.length ? [{
+		id,
+		value: values
+	}] : []] });
+	const boundFacets = facets.map(({ id, label, options }) => ({
+		id,
+		label,
+		options,
+		selected: selectedFor(id),
+		onChange: (next) => setFacet(id, next)
+	}));
+	const rows = table.getRowModel().rows;
+	const filteredCount = table.getFilteredRowModel().rows.length;
+	const columnCount = columns.length;
+	const canReset = current.globalFilter.length > 0 || current.columnFilters.length > 0;
+	const rowClick = detail ? (row) => openDetail(row) : void 0;
+	const openedRow = current.openedKey == null ? null : data.find((row) => keyOf(row) === current.openedKey) ?? null;
+	const filteredKeys = table.getFilteredRowModel().rows.map((row) => keyOf(row.original));
+	const allSelected = filteredKeys.length > 0 && filteredKeys.every((key) => current.selection.includes(key));
+	const someSelected = filteredKeys.some((key) => current.selection.includes(key));
+	const toggleAll = () => update({ selection: allSelected ? current.selection.filter((key) => !filteredKeys.includes(key)) : [.../* @__PURE__ */ new Set([...current.selection, ...filteredKeys])] });
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col gap-4",
+		children: [
+			/* @__PURE__ */ jsx(DataTableToolbar, {
+				globalFilter: current.globalFilter,
+				onGlobalFilterChange: (value) => resetPerPage({ globalFilter: value }),
+				placeholder: labels.search,
+				facets: boundFacets,
+				shownLabel: labels.shown(filteredCount, data.length, labels.unit),
+				canReset,
+				resetLabel: labels.reset,
+				clearFacetLabel: labels.clear,
+				onReset: () => resetPerPage({
+					globalFilter: "",
+					columnFilters: []
+				}),
+				columns: columnManager ? {
+					label: columnManager.label,
+					clearLabel: columnManager.clearLabel,
+					options: [...columnManager.columns].sort((a, b) => orderedIds.indexOf(a.id) - orderedIds.indexOf(b.id)).map((column) => ({
+						...column,
+						visible: current.columnVisibility[column.id] !== false
+					})),
+					onToggle: (id, visible) => update({ columnVisibility: {
+						...current.columnVisibility,
+						[id]: visible
+					} }),
+					onMove: moveColumn,
+					moveUpLabel: columnManager.moveUpLabel,
+					moveDownLabel: columnManager.moveDownLabel
+				} : void 0,
+				actions
+			}),
+			selection && selectedRows.length ? /* @__PURE__ */ jsxs("div", {
+				className: "flex flex-wrap items-center gap-3 rounded-md border bg-muted/30 px-3 py-2 text-xs",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "font-medium",
+						children: selection.selectedLabel(selectedRows.length)
+					}),
+					/* @__PURE__ */ jsx("div", {
+						className: "flex flex-wrap items-center gap-2",
+						children: selection.bulkActions?.(selectedRows)
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						variant: "ghost",
+						size: "sm",
+						className: "ml-auto h-8",
+						onClick: () => update({ selection: [] }),
+						children: selection.clearLabel
+					})
+				]
+			}) : null,
+			/* @__PURE__ */ jsx("div", {
+				className: "rounded-md border",
+				children: /* @__PURE__ */ jsxs(Table, { children: [/* @__PURE__ */ jsx(TableHeader, { children: table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ jsx(TableRow, { children: headerGroup.headers.map((header) => /* @__PURE__ */ jsx(TableHead, {
+					className: "whitespace-nowrap",
+					draggable: Boolean(columnManager) && header.column.id !== "__select__",
+					onDragStart: columnManager ? () => setDraggingId(String(header.column.id)) : void 0,
+					onDragOver: columnManager ? (event) => event.preventDefault() : void 0,
+					onDrop: columnManager ? () => {
+						if (draggingId) moveColumnBefore(draggingId, String(header.column.id));
+						setDraggingId(null);
+					} : void 0,
+					children: header.column.id === "__select__" ? /* @__PURE__ */ jsx(SelectionCheckbox, {
+						checked: allSelected,
+						indeterminate: someSelected && !allSelected,
+						label: selection?.selectAllLabel ?? "",
+						onChange: toggleAll
+					}) : header.isPlaceholder ? null : flexRender(header.column.columnDef.header, header.getContext())
+				}, header.id)) }, headerGroup.id)) }), /* @__PURE__ */ jsx(TableBody, { children: rows.length ? rows.map((row) => /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(TableRow, {
+					onClick: rowClick ? () => rowClick(row.original) : void 0,
+					className: rowClick ? "cursor-pointer" : void 0,
+					"data-selected": current.selection.includes(keyOf(row.original)) || void 0,
+					children: row.getAllCells().map((cell) => /* @__PURE__ */ jsx(TableCell, {
+						className: "py-2",
+						children: flexRender(cell.column.columnDef.cell, cell.getContext())
+					}, cell.id))
+				}), placement === "inline" && current.openedKey === keyOf(row.original) && detail ? /* @__PURE__ */ jsx(TableRow, { children: /* @__PURE__ */ jsx(TableCell, {
+					colSpan: columnCount,
+					className: "bg-muted/30",
+					children: detail.render(row.original)
+				}) }) : null] }, row.id)) : /* @__PURE__ */ jsx(TableRow, { children: /* @__PURE__ */ jsx(TableCell, {
+					colSpan: columnCount,
+					className: "h-24 text-center text-sm text-muted-foreground",
+					children: labels.empty
+				}) }) })] })
+			}),
+			/* @__PURE__ */ jsx(DataTablePagination, {
+				page: table.getPageCount() === 0 ? 0 : current.pagination.pageIndex + 1,
+				pageCount: table.getPageCount(),
+				pageSize: current.pagination.pageSize,
+				onPageSizeChange: (size) => update({ pagination: {
+					pageIndex: 0,
+					pageSize: size
+				} }),
+				onPrevious: () => update({ pagination: {
+					...current.pagination,
+					pageIndex: Math.max(0, current.pagination.pageIndex - 1)
+				} }),
+				onNext: () => update({ pagination: {
+					...current.pagination,
+					pageIndex: Math.min(table.getPageCount() - 1, current.pagination.pageIndex + 1)
+				} }),
+				canPrevious: table.getCanPreviousPage(),
+				canNext: table.getCanNextPage(),
+				rowsLabel: labels.rows,
+				pageOf: labels.pageOf,
+				previousLabel: labels.previous,
+				nextLabel: labels.next
+			}),
+			placement === "overlay" && detail ? /* @__PURE__ */ jsx(Sheet, {
+				open: current.openedKey != null,
+				onOpenChange: (open) => update({ openedKey: open ? current.openedKey : null }),
+				children: /* @__PURE__ */ jsx(SheetContent, {
+					side: "right",
+					className: "w-full overflow-y-auto sm:max-w-2xl",
+					children: openedRow ? detail.render(openedRow) : null
+				})
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/internal/tooltip.tsx
+var TooltipProvider = TooltipPrimitive.Provider;
+var TooltipContent = React.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx(TooltipPrimitive.Content, {
+	ref,
+	sideOffset,
+	className: cn("z-50 overflow-hidden rounded-md border bg-popover px-3 py-1.5 text-sm text-popover-foreground shadow-md animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-tooltip-content-transform-origin]", className),
+	...props
+}));
+TooltipContent.displayName = TooltipPrimitive.Content.displayName;
+//#endregion
+//#region src/components/meter/meter.tsx
+/**
+* Le Meter : une barre qui montre où en est une valeur sur une échelle, avec la marque
+* du seuil quand il y en a un. Il sert une cellule de table **et** une carte de santé —
+* c'est ce qui en fait un atome et pas un détail interne à la table (ADR 0010).
+*
+* Aucun libellé ne vient de l'app : l'appelant passe le texte du seuil. Le cœur ne
+* connaît ni l'i18n de l'app ni un mot produit.
+*/
+function clamp01$1(value) {
+	return Math.max(0, Math.min(1, value));
+}
+/** Une valeur non numérique est une donnée cassée : on la ramène à 0 plutôt que de
+*  produire un `width: NaN%`, que le navigateur refuse — et jsdom avec lui. */
+function finite$1(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function Meter({ label, value, max, threshold, decimals = 2, confidence, thresholdLabel, className, ...props }) {
+	const shown = finite$1(value);
+	const peak = finite$1(max);
+	const ratio = peak > 0 ? clamp01$1(shown / peak) : 0;
+	const mark = threshold != null && peak > 0 ? clamp01$1(finite$1(threshold) / peak) : null;
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("flex items-center gap-3", className),
+		...props,
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: "w-40 shrink-0 truncate font-mono text-xs text-muted-foreground",
+				title: label,
+				children: label
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "relative h-2 flex-1 rounded-full bg-muted",
+				children: [/* @__PURE__ */ jsx("div", {
+					className: "h-full rounded-full bg-primary",
+					style: { width: `${ratio * 100}%` }
+				}), mark != null ? /* @__PURE__ */ jsx("div", {
+					className: "absolute top-1/2 h-3.5 w-0.5 -translate-y-1/2 rounded-full bg-foreground/60",
+					style: { left: `calc(${mark * 100}% - 1px)` },
+					title: thresholdLabel ? thresholdLabel(threshold) : void 0
+				}) : null]
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "w-10 shrink-0 text-right font-mono text-xs tabular-nums",
+				children: shown.toFixed(decimals)
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "w-11 shrink-0 text-right font-mono text-[11px] tabular-nums text-muted-foreground",
+				children: typeof confidence === "number" && Number.isFinite(confidence) ? `c${confidence.toFixed(2)}` : ""
+			})
+		]
+	});
+}
+/** La même barre, en plus court : une cellule de table dense. */
+function CompactMeter({ label, value, max, threshold, className, ...props }) {
+	const shown = finite$1(value);
+	const peak = finite$1(max);
+	const ratio = peak > 0 ? clamp01$1(shown / peak) : 0;
+	const mark = threshold != null && peak > 0 ? clamp01$1(finite$1(threshold) / peak) : null;
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("flex items-center gap-2", className),
+		...props,
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: "w-9 shrink-0 font-mono text-[10px] text-muted-foreground",
+				children: label
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "relative h-1.5 w-24 rounded-full bg-muted",
+				children: [/* @__PURE__ */ jsx("div", {
+					className: "h-full rounded-full bg-primary",
+					style: { width: `${ratio * 100}%` }
+				}), mark != null ? /* @__PURE__ */ jsx("div", {
+					className: "absolute top-1/2 h-2.5 w-px -translate-y-1/2 bg-foreground/60",
+					style: { left: `${mark * 100}%` }
+				}) : null]
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "w-8 shrink-0 text-right font-mono text-[10px] tabular-nums",
+				children: shown.toFixed(2)
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/meter/manifest.ts
+/**
+* Le manifeste du Meter (ADR 0005). Il documente les deux tailles du même atome :
+* la barre large, qui a besoin du libellé du seuil, et la barre compacte d'une cellule.
+*/
+var meterManifest = {
+	name: "meter",
+	title: "Meter",
+	summary: "Une barre qui situe une valeur sur une échelle, avec la marque du seuil. Se rend seule, hors de toute table : une carte de santé l'utilise au même titre qu'une cellule.",
+	level: "primitive",
+	example: {
+		label: "spec",
+		value: 2,
+		max: 3,
+		threshold: 2
+	},
+	variants: [],
+	props: [
+		{
+			name: "value",
+			type: "number",
+			required: true,
+			check: "rendered",
+			description: "La valeur mesurée, bornée à l'échelle : c'est elle qui remplit la barre."
+		},
+		{
+			name: "max",
+			type: "number",
+			required: true,
+			check: "rendered",
+			description: "Le haut de l'échelle : 3 pour un score, 1 pour un Noul."
+		},
+		{
+			name: "label",
+			type: "string",
+			required: true,
+			check: "rendered",
+			description: "Le nom de ce qui est mesuré, à gauche de la barre."
+		},
+		{
+			name: "threshold",
+			type: "number | null",
+			required: false,
+			check: "rendered",
+			description: "Le seuil comparé, marqué sur la barre ; absent, la barre n'a pas de marque."
+		},
+		{
+			name: "confidence",
+			type: "number | null",
+			required: false,
+			check: "rendered",
+			description: "La confiance attachée à la valeur, affichée en `c0.00` à droite."
+		},
+		{
+			name: "thresholdLabel",
+			type: "(threshold: number) => string",
+			required: false,
+			check: "rendered",
+			description: "Le texte du seuil, injecté par l'appelant : le cœur n'a pas d'i18n (ADR 0010)."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du composant."
+		}
+	],
+	usages: [
+		{
+			when: "une carte de santé montre l'avancement d'une mesure",
+			use: "<Meter label=\"sessions\" value={12} max={20} />",
+			avoid: "la barre compacte, illisible hors d’une cellule dense"
+		},
+		{
+			when: "une cellule de table dense porte deux mesures côte à côte",
+			use: "<CompactMeter label=\"spec\" value={2} max={3} threshold={2} />",
+			avoid: "la barre large : elle ne tient pas dans une colonne"
+		},
+		{
+			when: "un seuil est marqué sur la barre",
+			use: "thresholdLabel={t.meter.threshold} (le texte vient de l’app)",
+			avoid: "un libellé en dur dans le cœur : il serait monolingue et lié à un produit"
+		}
+	]
+};
+//#endregion
+//#region src/components/separator/separator.tsx
+/**
+* Un séparateur : un trait de bordure qui sépare deux contenus, horizontal ou vertical.
+* Décoratif par défaut (Radix), donc invisible aux lecteurs d'écran sauf demande.
+*/
+function Separator({ className, orientation = "horizontal", decorative = true, ...props }) {
+	return /* @__PURE__ */ jsx(SeparatorPrimitive.Root, {
+		decorative,
+		orientation,
+		className: cn("shrink-0 bg-border", orientation === "horizontal" ? "h-px w-full" : "h-full w-px", className),
+		...props
+	});
+}
+//#endregion
+//#region src/components/separator/manifest.ts
+/** Le manifeste du séparateur (ADR 0005). */
+var separatorManifest = {
+	name: "separator",
+	title: "Separator",
+	summary: "Un trait de bordure qui sépare deux contenus, horizontal ou vertical. Décoratif par défaut : il ne porte aucun sens pour un lecteur d’écran sauf demande explicite.",
+	level: "primitive",
+	example: { orientation: "horizontal" },
+	variants: [],
+	props: [
+		{
+			name: "orientation",
+			type: "'horizontal' | 'vertical'",
+			required: false,
+			check: "rendered",
+			description: "Le sens du trait ; horizontal par défaut."
+		},
+		{
+			name: "decorative",
+			type: "boolean",
+			required: false,
+			check: "accepted",
+			description: "Décoratif (vrai par défaut) : masqué aux technologies d’assistance."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		}
+	],
+	usages: [{
+		when: "séparer deux blocs dans une carte ou une barre",
+		use: "<Separator />",
+		avoid: "une bordure manuelle : le séparateur porte la couleur de bordure des tokens"
+	}, {
+		when: "un trait vertical entre deux contrôles alignés",
+		use: "<Separator orientation=\"vertical\" className=\"h-5\" />",
+		avoid: "oublier la hauteur : un séparateur vertical n’a pas de taille propre"
+	}]
+};
+//#endregion
+//#region src/components/skeleton/skeleton.tsx
+/** Un bloc de chargement : une surface pulsante qui tient la place d'un contenu. */
+function Skeleton({ className, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("animate-pulse rounded-md bg-muted", className),
+		...props
+	});
+}
+//#endregion
+//#region src/components/skeleton/manifest.ts
+/** Le manifeste du squelette de chargement (ADR 0005). */
+var skeletonManifest = {
+	name: "skeleton",
+	title: "Skeleton",
+	summary: "Un bloc qui pulse pour tenir la place d'un contenu en cours de chargement. Sa largeur et sa hauteur viennent des classes de l’appelant.",
+	level: "primitive",
+	example: { className: "h-8 w-72" },
+	variants: [],
+	props: [{
+		name: "className",
+		type: "string",
+		required: false,
+		check: "class",
+		description: "Les classes de l'appelant (dimensions) : le cœur ne connaît que le style de pulsation."
+	}, {
+		name: "children",
+		type: "ReactNode",
+		required: false,
+		check: "content",
+		description: "Rarement utilisé : un squelette est une surface vide."
+	}],
+	usages: [{
+		when: "tenir la place d’un texte ou d’un bloc pendant le chargement",
+		use: "<Skeleton className=\"h-8 w-72\" />",
+		avoid: "un `Skeleton` aux dimensions par défaut : il n’a pas de taille propre"
+	}, {
+		when: "plusieurs lignes de chargement",
+		use: "plusieurs `Skeleton` empilés",
+		avoid: "un spinner : le squelette montre la forme du contenu qui arrive"
+	}]
+};
+//#endregion
+//#region src/components/table/manifest.ts
+/**
+* Le manifeste de la table (ADR 0005). La table est un atome composé : le catalogue
+* enregistre la coquille `Table`, et le manifeste documente le jeu de parts — c'est
+* l'ensemble qui se pose, pas la coquille seule.
+*/
+var tableManifest = {
+	name: "table",
+	title: "Table",
+	summary: "Une grille dense de lignes, livrée en parts importables séparément (Table, TableHeader, TableBody, TableRow, TableHead, TableCell). Aucune part ne nomme un produit : les libellés et les cellules viennent de l'appelant.",
+	level: "primitive",
+	example: { children: createElement(Fragment$1, null, createElement(TableHeader, null, createElement(TableRow, null, createElement(TableHead, null, "nom"), createElement(TableHead, null, "valeur"))), createElement(TableBody, null, createElement(TableRow, null, createElement(TableCell, null, "spec"), createElement(TableCell, null, "2 / 3")))) },
+	variants: [],
+	props: [{
+		name: "className",
+		type: "string",
+		required: false,
+		check: "class",
+		description: "Les classes de l'appelant, fusionnées après celles du cœur."
+	}, {
+		name: "children",
+		type: "ReactNode",
+		required: true,
+		check: "content",
+		description: "Les parts de la table : un en-tête et un corps, ou une fiche dense."
+	}],
+	usages: [{
+		when: "une grille dense de lignes dans un pupitre",
+		use: "<Table><TableHeader>…</TableHeader><TableBody>…</TableBody></Table>",
+		avoid: "un `<table>` brut : il perd les tokens de bordure, de survol et de densité"
+	}, {
+		when: "une fiche dense hors de toute table",
+		use: "importer Table / TableRow / TableCell séparément",
+		avoid: "réimplémenter une grille en `<div>` : la sémantique de table est perdue"
+	}]
+};
+//#endregion
+//#region src/components/textarea/textarea.tsx
+/** Un champ de saisie multiligne, stylé par les tokens. Rien d'autre que les props HTML. */
+function Textarea({ className, ...props }) {
+	return /* @__PURE__ */ jsx("textarea", {
+		className: cn("flex min-h-16 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50", className),
+		...props
+	});
+}
+//#endregion
+//#region src/components/textarea/manifest.ts
+/** Le manifeste du champ multiligne (ADR 0005, ADR 0015). */
+var textareaManifest = {
+	name: "textarea",
+	title: "Textarea",
+	summary: "Un champ de saisie multiligne. Il porte le style des tokens et transmet tout attribut HTML de `<textarea>` ; la valeur et le changement restent à l'appelant.",
+	level: "primitive",
+	example: { placeholder: "votre message" },
+	variants: [],
+	props: [{
+		name: "placeholder",
+		type: "string",
+		required: false,
+		check: "attribute",
+		description: "Le texte d'invite, affiché tant que le champ est vide."
+	}, {
+		name: "className",
+		type: "string",
+		required: false,
+		check: "class",
+		description: "Les classes de l'appelant, fusionnées après celles du cœur."
+	}],
+	usages: [{
+		when: "saisir un texte de plusieurs lignes",
+		use: "<Textarea rows={4} placeholder={…} />",
+		avoid: "un `<Input>` pour un texte long : le clavier et la hauteur ne s’y prêtent pas"
+	}, {
+		when: "un champ contrôlé dans un `Field`",
+		use: "<Field label={…}><Textarea value={v} onChange={…} /></Field>",
+		avoid: "attendre un état interne du cœur : il n’en a pas"
+	}]
+};
+//#endregion
+//#region src/components/checkbox/checkbox.tsx
+/** Une case à cocher contrôlée. Le cœur fournit l'apparence et l'a11y (Radix), pas l'état. */
+function Checkbox({ className, ...props }) {
+	return /* @__PURE__ */ jsx(CheckboxPrimitive.Root, {
+		className: cn("size-4 shrink-0 rounded border border-input ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:border-primary data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground", className),
+		...props,
+		children: /* @__PURE__ */ jsx(CheckboxPrimitive.Indicator, {
+			className: "grid place-items-center text-current",
+			children: /* @__PURE__ */ jsx(Check, { className: "size-3.5" })
+		})
+	});
+}
+//#endregion
+//#region src/components/checkbox/manifest.ts
+/** Le manifeste de la case à cocher (ADR 0005, ADR 0015). */
+var checkboxManifest = {
+	name: "checkbox",
+	title: "Checkbox",
+	summary: "Une case à cocher, contrôlée par props (`checked` + `onCheckedChange`). Le cœur ne possède ni l'état ni la validation ; l'a11y vient de Radix.",
+	level: "primitive",
+	example: {
+		checked: true,
+		onCheckedChange: () => {}
+	},
+	variants: [],
+	props: [
+		{
+			name: "checked",
+			type: "boolean",
+			required: false,
+			check: "rendered",
+			description: "Cochée ou non ; la valeur est chez l’appelant."
+		},
+		{
+			name: "onCheckedChange",
+			type: "(checked: boolean) => void",
+			required: false,
+			check: "accepted",
+			description: "Le rappel de bascule."
+		},
+		{
+			name: "disabled",
+			type: "boolean",
+			required: false,
+			check: "accepted",
+			description: "Désactive la case."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		}
+	],
+	usages: [{
+		when: "cocher une option indépendante",
+		use: "<Checkbox checked={v} onCheckedChange={set} />",
+		avoid: "attendre un état interne : la valeur reste dans l’app"
+	}, {
+		when: "nommer la case",
+		use: "un `Label htmlFor` ou un `aria-label`",
+		avoid: "une case sans libellé : elle devient muette pour un lecteur d’écran"
+	}]
+};
+//#endregion
+//#region src/components/switch/switch.tsx
+/** Un interrupteur contrôlé : le cœur fournit l'apparence et l'a11y (Radix), pas l'état. */
+function Switch({ className, ...props }) {
+	return /* @__PURE__ */ jsx(SwitchPrimitive.Root, {
+		className: cn("peer inline-flex h-5 w-9 shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=unchecked]:bg-input", className),
+		...props,
+		children: /* @__PURE__ */ jsx(SwitchPrimitive.Thumb, { className: "pointer-events-none block size-4 rounded-full bg-background shadow-lg ring-0 transition-transform data-[state=checked]:translate-x-4 data-[state=unchecked]:translate-x-0" })
+	});
+}
+//#endregion
+//#region src/components/switch/manifest.ts
+/** Le manifeste de l'interrupteur (ADR 0005, ADR 0015). */
+var switchManifest = {
+	name: "switch",
+	title: "Switch",
+	summary: "Un interrupteur qui bascule un état tout de suite, contrôlé par props (`checked` + `onCheckedChange`). Le cœur ne possède ni l'état ni l'action.",
+	level: "primitive",
+	example: {
+		checked: true,
+		onCheckedChange: () => {}
+	},
+	variants: [],
+	props: [
+		{
+			name: "checked",
+			type: "boolean",
+			required: false,
+			check: "rendered",
+			description: "Activé ou non ; la valeur est chez l’appelant."
+		},
+		{
+			name: "onCheckedChange",
+			type: "(checked: boolean) => void",
+			required: false,
+			check: "accepted",
+			description: "Le rappel de bascule."
+		},
+		{
+			name: "disabled",
+			type: "boolean",
+			required: false,
+			check: "accepted",
+			description: "Désactive l’interrupteur."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		}
+	],
+	usages: [{
+		when: "activer/désactiver une option qui prend effet immédiatement",
+		use: "<Switch checked={v} onCheckedChange={set} aria-label={…} />",
+		avoid: "un `Switch` pour un choix qui exige un bouton « Enregistrer » : préférer une `Checkbox`"
+	}]
+};
+//#endregion
+//#region src/components/radio/radio.tsx
+/** Un groupe de boutons radio ; l'app possède la valeur et le rappel. */
+function RadioGroup({ className, ...props }) {
+	return /* @__PURE__ */ jsx(RadioGroupPrimitive.Root, {
+		className: cn("grid gap-2", className),
+		...props
+	});
+}
+function RadioGroupItem({ className, ...props }) {
+	return /* @__PURE__ */ jsx(RadioGroupPrimitive.Item, {
+		className: cn("size-4 shrink-0 rounded-full border border-input text-primary ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:border-primary", className),
+		...props,
+		children: /* @__PURE__ */ jsx(RadioGroupPrimitive.Indicator, {
+			className: "grid place-items-center",
+			children: /* @__PURE__ */ jsx(Circle, { className: "size-2 fill-current" })
+		})
+	});
+}
+//#endregion
+//#region src/components/radio/manifest.ts
+/** Le manifeste du groupe radio (ADR 0005, ADR 0015). */
+var radioManifest = {
+	name: "radio",
+	title: "RadioGroup",
+	summary: "Un groupe de boutons radio où une seule option est retenue. Le cœur possède le groupe et ses items ; la valeur et le rappel restent à l’appelant.",
+	level: "primitive",
+	example: {
+		value: "a",
+		onValueChange: () => {},
+		children: createElement(Fragment$1, null, createElement("label", { className: "flex items-center gap-2" }, createElement(RadioGroupItem, { value: "a" }), "Option A"), createElement("label", { className: "flex items-center gap-2" }, createElement(RadioGroupItem, { value: "b" }), "Option B"))
+	},
+	variants: [],
+	props: [
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		},
+		{
+			name: "children",
+			type: "ReactNode",
+			required: true,
+			check: "content",
+			description: "Les `RadioGroupItem`, chacun avec sa valeur."
+		},
+		{
+			name: "value",
+			type: "string",
+			required: false,
+			check: "accepted",
+			description: "La valeur retenue ; la valeur est chez l’appelant."
+		},
+		{
+			name: "onValueChange",
+			type: "(value: string) => void",
+			required: false,
+			check: "accepted",
+			description: "Le rappel de choix."
+		}
+	],
+	usages: [{
+		when: "choisir une seule option parmi quelques-unes",
+		use: "<RadioGroup value={v} onValueChange={set}><RadioGroupItem value=\"a\" /></RadioGroup>",
+		avoid: "des `Checkbox` pour un choix exclusif : elles autorisent plusieurs valeurs"
+	}]
+};
+//#endregion
+//#region src/components/toggle/toggle.tsx
+/**
+* Le bouton à deux états : pressé ou non. Un `Switch` dit un réglage qui persiste ; un
+* `Toggle` est une bascule ponctuelle (mode d'affichage, filtre). Contrôlé par props —
+* `pressed` + `onPressedChange` — ou laissé libre via `defaultPressed` (ADR 0015).
+*/
+var toggleVariantsConfig = {
+	variants: {
+		variant: {
+			default: "bg-transparent",
+			outline: "border border-input bg-transparent hover:bg-accent hover:text-accent-foreground"
+		},
+		size: {
+			default: "h-10 px-3 min-w-10",
+			sm: "h-9 px-2.5 min-w-9",
+			lg: "h-11 px-5 min-w-11"
+		}
+	},
+	defaultVariants: {
+		variant: "default",
+		size: "default"
+	}
+};
+var toggleVariants = cva("inline-flex items-center justify-center gap-2 rounded-md text-sm font-medium ring-offset-background transition-colors hover:bg-muted hover:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=on]:bg-accent data-[state=on]:text-accent-foreground [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0", toggleVariantsConfig);
+function Toggle({ className, variant, size, ...props }) {
+	return /* @__PURE__ */ jsx(TogglePrimitive.Root, {
+		className: cn(toggleVariants({
+			variant,
+			size
+		}), className),
+		...props
+	});
+}
+//#endregion
+//#region src/components/toggle/manifest.ts
+/** Le manifeste de la bascule (ADR 0005, ADR 0015). Deux états, contrôlés par props. */
+var toggleManifest = {
+	name: "toggle",
+	title: "Toggle",
+	summary: "Un bouton à deux états : pressé ou non. Une bascule ponctuelle (mode, filtre), pas un réglage qui persiste comme `Switch`. Contrôlé par props, a11y par Radix.",
+	level: "primitive",
+	example: {
+		children: "compact",
+		defaultPressed: true
+	},
+	variants: [{
+		name: "variant",
+		values: ["default", "outline"],
+		default: "default",
+		description: "Le ton du bouton — plein discret, ou bordé pour une barre d’outils."
+	}, {
+		name: "size",
+		values: [
+			"default",
+			"sm",
+			"lg"
+		],
+		default: "default",
+		description: "La taille du contrôle, du plus discret au plus large."
+	}],
+	props: [
+		{
+			name: "children",
+			type: "ReactNode",
+			required: true,
+			check: "content",
+			description: "Le libellé ou l’icône de la bascule."
+		},
+		{
+			name: "pressed",
+			type: "boolean",
+			required: false,
+			check: "accepted",
+			description: "L’état pressé, contrôlé par l’appelant."
+		},
+		{
+			name: "onPressedChange",
+			type: "(pressed: boolean) => void",
+			required: false,
+			check: "accepted",
+			description: "Le rappel de bascule."
+		},
+		{
+			name: "disabled",
+			type: "boolean",
+			required: false,
+			check: "accepted",
+			description: "Désactive la bascule."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		}
+	],
+	usages: [{
+		when: "un mode ou un filtre qu’on active ponctuellement",
+		use: "<Toggle pressed={v} onPressedChange={set}>compact</Toggle>",
+		avoid: "un `Toggle` pour un réglage qui persiste : c’est un `Switch`"
+	}, {
+		when: "laisser la bascule libre de son état",
+		use: "defaultPressed (non contrôlé)",
+		avoid: "mélanger `pressed` et `defaultPressed` : l’un annule l’autre"
+	}]
+};
+//#endregion
+//#region src/components/toggle-group/toggle-group.tsx
+/**
+* Le groupe de bascules : un choix segmenté (`type="single"`) ou multiple. Le variant et
+* la taille se posent sur le groupe et se propagent aux items ; l'état appartient à
+* l'app (ADR 0015). Les items sont des parts importables séparément.
+*/
+var ToggleGroupContext = createContext({
+	variant: "default",
+	size: "default"
+});
+function ToggleGroup({ className, variant, size, children, ...props }) {
+	return /* @__PURE__ */ jsx(ToggleGroupPrimitive.Root, {
+		className: cn("flex items-center gap-1", className),
+		...props,
+		children: /* @__PURE__ */ jsx(ToggleGroupContext.Provider, {
+			value: {
+				variant,
+				size
+			},
+			children
+		})
+	});
+}
+function ToggleGroupItem({ className, variant, size, ...props }) {
+	const context = useContext(ToggleGroupContext);
+	return /* @__PURE__ */ jsx(ToggleGroupPrimitive.Item, {
+		className: cn(toggleVariants({
+			variant: context.variant ?? variant,
+			size: context.size ?? size
+		}), className),
+		...props
+	});
+}
+//#endregion
+//#region src/components/toggle-group/manifest.ts
+/**
+* Le manifeste du groupe de bascules (ADR 0005, ADR 0015). Le catalogue enregistre le
+* groupe ; les items sont des parts importables.
+*/
+var toggleGroupManifest = {
+	name: "toggle-group",
+	title: "ToggleGroup",
+	summary: "Un choix segmenté (`type=\"single\"`) ou multiple de bascules. Variant et taille se posent sur le groupe et se propagent aux items ; l'état appartient à l'appelant.",
+	level: "primitive",
+	example: {
+		type: "single",
+		variant: "outline",
+		size: "sm",
+		children: createElement(Fragment$1, null, createElement(ToggleGroupItem, { value: "un" }, "un"), createElement(ToggleGroupItem, { value: "deux" }, "deux"))
+	},
+	variants: [{
+		name: "variant",
+		values: ["default", "outline"],
+		default: "default",
+		description: "Le ton des bascules du groupe."
+	}, {
+		name: "size",
+		values: [
+			"default",
+			"sm",
+			"lg"
+		],
+		default: "default",
+		description: "La taille des bascules du groupe."
+	}],
+	props: [
+		{
+			name: "children",
+			type: "ReactNode",
+			required: true,
+			check: "content",
+			description: "Les items du groupe (`ToggleGroupItem`)."
+		},
+		{
+			name: "value",
+			type: "string",
+			required: false,
+			check: "accepted",
+			description: "La valeur sélectionnée, contrôlée par l’appelant."
+		},
+		{
+			name: "onValueChange",
+			type: "(value: string) => void",
+			required: false,
+			check: "accepted",
+			description: "Le rappel de sélection."
+		},
+		{
+			name: "disabled",
+			type: "boolean",
+			required: false,
+			check: "accepted",
+			description: "Désactive tout le groupe."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		}
+	],
+	usages: [{
+		when: "choisir une seule vue parmi quelques-unes (un segment)",
+		use: "<ToggleGroup type=\"single\" value={v} onValueChange={set}>…</ToggleGroup>",
+		avoid: "un `Select` pour deux ou trois choix courts : un segment se lit d’un coup"
+	}, {
+		when: "choisir plusieurs options indépendantes",
+		use: "type=\"multiple\" (Radix), l’état reste dans l’app",
+		avoid: "attendre un état interne : le cœur n’en a pas"
+	}]
+};
+//#endregion
+//#region src/components/toast/toast.tsx
+/** L'icône par défaut d'un ton ; `neutral` et `progress` restent sans icône. */
+var defaultIcon = {
+	info: /* @__PURE__ */ jsx(Info, { className: "size-4" }),
+	attention: /* @__PURE__ */ jsx(CircleAlert, { className: "size-4" }),
+	warning: /* @__PURE__ */ jsx(TriangleAlert, { className: "size-4" }),
+	danger: /* @__PURE__ */ jsx(CircleX, { className: "size-4" }),
+	success: /* @__PURE__ */ jsx(CircleCheck, { className: "size-4" })
+};
+/**
+* La notification : une carte flottante qui dit ce qu'une action a produit. Présentation
+* seule — la **file** et les minuteurs vivent dans `ToastProvider` (ADR 0020). L'app
+* fournit le message, l'action et le libellé de fermeture.
+*/
+function Toast({ tone = "info", message, description, action, icon, onClose, closeLabel, className }) {
+	return /* @__PURE__ */ jsxs("div", {
+		role: "status",
+		className: cn("pointer-events-auto flex w-full items-start gap-3 rounded-md border p-3 text-sm shadow-lg", toneClasses[tone], className),
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				"aria-hidden": true,
+				className: "mt-0.5 shrink-0",
+				children: icon ?? defaultIcon[tone] ?? null
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "min-w-0 flex-1",
+				children: [/* @__PURE__ */ jsx("p", {
+					className: "font-medium",
+					children: message
+				}), description ? /* @__PURE__ */ jsx("p", {
+					className: "mt-0.5 text-xs opacity-90",
+					children: description
+				}) : null]
+			}),
+			action ? /* @__PURE__ */ jsx("div", {
+				className: "shrink-0",
+				children: action
+			}) : null,
+			onClose ? /* @__PURE__ */ jsx("button", {
+				type: "button",
+				"aria-label": closeLabel,
+				onClick: onClose,
+				className: "-m-1 shrink-0 rounded p-1 opacity-70 transition-opacity hover:opacity-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+				children: /* @__PURE__ */ jsx(CircleX, {
+					className: "size-4",
+					"aria-hidden": true
+				})
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/components/toast/manifest.ts
+/** Le manifeste de la notification (ADR 0005, ADR 0020). Le ton réutilise `toneClasses`. */
+var toastManifest = {
+	name: "toast",
+	title: "Toast",
+	summary: "Une notification flottante : un message, un détail, une action, une fermeture. Le ton vient du cœur ; la file et les minuteurs vivent dans `ToastProvider`.",
+	level: "primitive",
+	example: {
+		tone: "success",
+		message: "réindexé",
+		description: "12 éléments"
+	},
+	variants: [{
+		name: "tone",
+		values: [...TONES],
+		default: "info",
+		description: "L'intention de la notification — ce que l'appelant choisit selon l'usage."
+	}],
+	props: [
+		{
+			name: "message",
+			type: "ReactNode",
+			required: true,
+			check: "rendered",
+			description: "Le message principal : une ligne, jamais une phrase."
+		},
+		{
+			name: "description",
+			type: "ReactNode",
+			required: false,
+			check: "rendered",
+			description: "Un détail sous le message, plus discret."
+		},
+		{
+			name: "action",
+			type: "ReactNode",
+			required: false,
+			check: "accepted",
+			description: "Une action : un bouton, un lien."
+		},
+		{
+			name: "icon",
+			type: "ReactNode",
+			required: false,
+			check: "accepted",
+			description: "Remplace l'icône par défaut du ton."
+		},
+		{
+			name: "onClose",
+			type: "() => void",
+			required: false,
+			check: "accepted",
+			description: "Affiche un bouton de fermeture et le rappelle au clic."
+		},
+		{
+			name: "closeLabel",
+			type: "string",
+			required: false,
+			check: "accepted",
+			description: "Le libellé accessible du bouton de fermeture (requis avec `onClose`)."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du cœur."
+		}
+	],
+	usages: [{
+		when: "dire ce qu’une action a produit, sans bloquer la vue",
+		use: "via `useToast().show({ message })` (le `ToastProvider` gère la file)",
+		avoid: "un `Toast` monté à la main : la file et l’auto-dismiss vivent dans le provider"
+	}, {
+		when: "signaler un échec qu’on doit voir",
+		use: "tone \"danger\" et un `description` qui nomme la cause",
+		avoid: "un toast pour une erreur de chargement de page : c’est un `EmptyState`"
+	}]
+};
+//#endregion
+//#region src/features/toast.tsx
+var ToastContext = createContext(null);
+function useToast() {
+	const api = useContext(ToastContext);
+	if (!api) throw new Error("useToast doit être utilisé sous <ToastProvider>.");
+	return api;
+}
+var DEFAULT_DURATION = 4e3;
+function ToastProvider({ children, closeLabel, duration = DEFAULT_DURATION }) {
+	const [items, setItems] = useState([]);
+	const idRef = useRef(0);
+	const timers = useRef(/* @__PURE__ */ new Map());
+	const clearTimer = useCallback((id) => {
+		const timer = timers.current.get(id);
+		if (timer) {
+			clearTimeout(timer);
+			timers.current.delete(id);
+		}
+	}, []);
+	const dismiss = useCallback((id) => {
+		clearTimer(id);
+		setItems((previous) => previous.filter((item) => item.id !== id));
+	}, [clearTimer]);
+	const show = useCallback((options) => {
+		const id = `toast-${++idRef.current}`;
+		setItems((previous) => [...previous, {
+			...options,
+			id
+		}]);
+		return id;
+	}, []);
+	const update = useCallback((id, options) => {
+		setItems((previous) => previous.map((item) => item.id === id ? {
+			...item,
+			...options
+		} : item));
+	}, []);
+	useEffect(() => {
+		for (const item of items) {
+			if (item.persistent) {
+				clearTimer(item.id);
+				continue;
+			}
+			if (!timers.current.has(item.id)) timers.current.set(item.id, setTimeout(() => dismiss(item.id), item.duration ?? duration));
+		}
+		for (const [id, timer] of timers.current) if (!items.some((item) => item.id === id)) {
+			clearTimeout(timer);
+			timers.current.delete(id);
+		}
+	}, [
+		items,
+		duration,
+		dismiss,
+		clearTimer
+	]);
+	useEffect(() => {
+		const armed = timers.current;
+		return () => {
+			for (const timer of armed.values()) clearTimeout(timer);
+			armed.clear();
+		};
+	}, []);
+	const api = useMemo(() => ({
+		show,
+		update,
+		dismiss
+	}), [
+		show,
+		update,
+		dismiss
+	]);
+	return /* @__PURE__ */ jsxs(ToastContext.Provider, {
+		value: api,
+		children: [children, /* @__PURE__ */ jsx("div", {
+			"aria-live": "polite",
+			className: "pointer-events-none fixed inset-x-0 bottom-0 z-50 flex flex-col items-center gap-2 p-4 sm:items-end",
+			children: items.map((item) => {
+				const common = {
+					tone: item.tone,
+					message: item.message,
+					description: item.description,
+					action: item.action
+				};
+				return /* @__PURE__ */ jsx("div", {
+					className: "pointer-events-auto w-full max-w-sm",
+					onMouseEnter: () => clearTimer(item.id),
+					onMouseLeave: () => {
+						if (!item.persistent && !timers.current.has(item.id)) timers.current.set(item.id, setTimeout(() => dismiss(item.id), item.duration ?? duration));
+					},
+					children: closeLabel ? /* @__PURE__ */ jsx(Toast, {
+						...common,
+						onClose: () => dismiss(item.id),
+						closeLabel
+					}) : /* @__PURE__ */ jsx(Toast, { ...common })
+				}, item.id);
+			})
+		})]
+	});
+}
+//#endregion
+//#region src/components/tree/tree.tsx
+/** Aplati les nœuds **visibles** (les enfants d'un nœud fermé n'y sont pas) pour piloter
+*  le focus et les flèches comme une seule liste. */
+function flatten$1(nodes, expanded, level = 1, parentId = null) {
+	const out = [];
+	nodes.forEach((node, index) => {
+		const hasChildren = Boolean(node.children && node.children.length);
+		out.push({
+			node,
+			level,
+			parentId,
+			hasChildren,
+			posinset: index + 1,
+			setsize: nodes.length
+		});
+		if (hasChildren && expanded.has(node.id)) out.push(...flatten$1(node.children ?? [], expanded, level + 1, node.id));
+	});
+	return out;
+}
+function TreeBase({ nodes, expandedIds = [], onToggle, selectedIds = [], onSelect, multi = false, ariaLabel, className }) {
+	const expanded = useMemo(() => new Set(expandedIds), [expandedIds]);
+	const selected = useMemo(() => new Set(selectedIds), [selectedIds]);
+	const visible = useMemo(() => flatten$1(nodes, expanded), [nodes, expanded]);
+	const [focusedId, setFocusedId] = useState(visible[0]?.node.id ?? null);
+	const items = useRef(/* @__PURE__ */ new Map());
+	const interacted = useRef(false);
+	const activeId = visible.some((entry) => entry.node.id === focusedId) ? focusedId : visible[0]?.node.id ?? null;
+	useEffect(() => {
+		if (interacted.current && activeId) items.current.get(activeId)?.focus();
+	}, [activeId]);
+	const focusAt = useCallback((index) => {
+		const target = visible[index];
+		if (!target) return;
+		interacted.current = true;
+		setFocusedId(target.node.id);
+		items.current.get(target.node.id)?.focus();
+	}, [visible]);
+	function onKeyDown(event) {
+		const index = visible.findIndex((entry) => entry.node.id === activeId);
+		if (index < 0) return;
+		const current = visible[index];
+		const parentIndex = () => visible.findIndex((entry) => entry.node.id === current.parentId);
+		switch (event.key) {
+			case "ArrowDown":
+				event.preventDefault();
+				focusAt(Math.min(index + 1, visible.length - 1));
+				break;
+			case "ArrowUp":
+				event.preventDefault();
+				focusAt(Math.max(index - 1, 0));
+				break;
+			case "Home":
+				event.preventDefault();
+				focusAt(0);
+				break;
+			case "End":
+				event.preventDefault();
+				focusAt(visible.length - 1);
+				break;
+			case "ArrowRight":
+				event.preventDefault();
+				if (current.hasChildren && !expanded.has(current.node.id)) onToggle?.(current.node.id);
+				else if (current.hasChildren) focusAt(index + 1);
+				break;
+			case "ArrowLeft":
+				event.preventDefault();
+				if (current.hasChildren && expanded.has(current.node.id)) onToggle?.(current.node.id);
+				else if (parentIndex() >= 0) focusAt(parentIndex());
+				break;
+			case "Enter":
+			case " ":
+				event.preventDefault();
+				onSelect?.(current.node.id);
+		}
+	}
+	return /* @__PURE__ */ jsx("div", {
+		role: "tree",
+		"aria-label": ariaLabel,
+		"aria-multiselectable": multi || void 0,
+		onKeyDown,
+		className: cn("flex flex-col", className),
+		children: visible.map((entry) => {
+			const { node, level, hasChildren, posinset, setsize } = entry;
+			const isExpanded = hasChildren && expanded.has(node.id);
+			return /* @__PURE__ */ jsxs("div", {
+				ref: (element) => {
+					if (element) items.current.set(node.id, element);
+					else items.current.delete(node.id);
+				},
+				role: "treeitem",
+				"aria-level": level,
+				"aria-posinset": posinset,
+				"aria-setsize": setsize,
+				"aria-selected": selected.has(node.id),
+				"aria-expanded": hasChildren ? isExpanded : void 0,
+				tabIndex: node.id === activeId ? 0 : -1,
+				onClick: () => {
+					interacted.current = true;
+					setFocusedId(node.id);
+					items.current.get(node.id)?.focus();
+					onSelect?.(node.id);
+				},
+				style: { paddingLeft: `${(level - 1) * 16}px` },
+				className: cn("flex cursor-default items-center gap-1 rounded px-1.5 py-1 text-sm outline-none", "focus-visible:ring-2 focus-visible:ring-ring", selected.has(node.id) && "bg-accent text-accent-foreground"),
+				children: [hasChildren ? /* @__PURE__ */ jsx("span", {
+					"aria-hidden": true,
+					onClick: (event) => {
+						event.stopPropagation();
+						onToggle?.(node.id);
+					},
+					className: "flex size-4 shrink-0 items-center justify-center text-muted-foreground",
+					children: /* @__PURE__ */ jsx(ChevronRight, { className: cn("size-4 transition-transform", isExpanded && "rotate-90") })
+				}) : /* @__PURE__ */ jsx("span", {
+					"aria-hidden": true,
+					className: "size-4 shrink-0"
+				}), /* @__PURE__ */ jsx("span", {
+					className: "truncate",
+					children: node.label
+				})]
+			}, node.id);
+		})
+	});
+}
+function Tree({ selectedId, ...props }) {
+	return /* @__PURE__ */ jsx(TreeBase, {
+		...props,
+		selectedIds: selectedId ? [selectedId] : []
+	});
+}
+function SelectionTree(props) {
+	return /* @__PURE__ */ jsx(TreeBase, {
+		...props,
+		multi: true
+	});
+}
+//#endregion
+//#region src/components/tree/manifest.ts
+/**
+* Le manifeste de l'Arbre (ADR 0005, ADR 0015). Il documente les deux exports du même
+* atome : `Tree` (navigation, sélection simple) et `SelectionTree` (sélection multiple),
+* comme le Meter documente ses deux tailles.
+*/
+var treeManifest = {
+	name: "tree",
+	title: "Arbre",
+	summary: "Une hiérarchie de nœuds, l'ouverture et la sélection **portées par l'app** (props contrôlées + rappels). Deux exports : `Tree` navigue, `SelectionTree` coche plusieurs nœuds. Le focus clavier est interne, la donnée ne l’est jamais.",
+	level: "bloc",
+	example: {
+		nodes: [{
+			id: "src",
+			label: "src",
+			children: [{
+				id: "src/components",
+				label: "components"
+			}, {
+				id: "src/lib",
+				label: "lib"
+			}]
+		}, {
+			id: "docs",
+			label: "docs"
+		}],
+		expandedIds: ["src"],
+		selectedId: "src/lib",
+		ariaLabel: "Arborescence de démonstration"
+	},
+	variants: [],
+	props: [
+		{
+			name: "nodes",
+			type: "TreeNode[]",
+			required: true,
+			check: "accepted",
+			description: "La hiérarchie : chaque nœud a un `id`, un `label` et d'éventuels `children`."
+		},
+		{
+			name: "expandedIds",
+			type: "string[]",
+			required: false,
+			check: "accepted",
+			description: "Les ids des nœuds ouverts (contrôlé) : l'app porte l'expansion, pas l'arbre."
+		},
+		{
+			name: "selectedId",
+			type: "string | null",
+			required: false,
+			check: "rendered",
+			description: "Le nœud sélectionné de `Tree` (contrôlé, sélection simple)."
+		},
+		{
+			name: "onToggle",
+			type: "(id: string) => void",
+			required: false,
+			check: "accepted",
+			description: "Appelé pour ouvrir/fermer un nœud (flèche droite/gauche, chevron)."
+		},
+		{
+			name: "onSelect",
+			type: "(id: string) => void",
+			required: false,
+			check: "accepted",
+			description: "Appelé au clic ou à Entrée/Espace — l'app décide de la suite."
+		},
+		{
+			name: "ariaLabel",
+			type: "string",
+			required: false,
+			check: "rendered",
+			description: "Le nom accessible de l'arbre : le cœur n'a pas d'i18n (ADR 0015)."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du composant."
+		}
+	],
+	usages: [
+		{
+			when: "une navigation hiérarchique (fichiers, catégories) où un nœud est actif",
+			use: "<Tree nodes={nodes} expandedIds={open} onToggle={…} selectedId={active} onSelect={…} />",
+			avoid: "laisser l’arbre posséder l’état : la donnée appartient à l’app"
+		},
+		{
+			when: "cocher plusieurs nœuds (filtres, périmètre)",
+			use: "<SelectionTree nodes={nodes} expandedIds={open} onToggle={…} selectedIds={checked} onSelect={…} />",
+			avoid: "<Tree>, qui ne porte qu’un nœud actif à la fois"
+		},
+		{
+			when: "le nom accessible de l’arbre",
+			use: "ariaLabel={t.tree.label} (le texte vient de l’app)",
+			avoid: "un aria-label en dur dans le cœur : il serait monolingue"
+		}
+	]
+};
+//#endregion
+//#region src/components/counter/counter.tsx
+function Counter({ value, suffix, label, className, ...props }) {
+	return /* @__PURE__ */ jsxs("span", {
+		className: cn("inline-flex items-baseline gap-1", className),
+		...props,
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: "font-mono text-2xl font-semibold tabular-nums",
+				children: value
+			}),
+			suffix ? /* @__PURE__ */ jsx("span", {
+				className: "text-sm text-muted-foreground",
+				children: suffix
+			}) : null,
+			label ? /* @__PURE__ */ jsx("span", {
+				className: "text-xs text-muted-foreground",
+				children: label
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/components/counter/manifest.ts
+/** Le manifeste du Counter (ADR 0005). */
+var counterManifest = {
+	name: "counter",
+	title: "Compteur",
+	summary: "Un nombre mis en avant, avec un suffixe et un libellé fournis par l’app. Aucun formatage ni unité dans le cœur : le texte et le nombre viennent de l’appelant.",
+	level: "primitive",
+	example: {
+		value: 128,
+		suffix: "issues",
+		label: "ouvertes"
+	},
+	variants: [],
+	props: [
+		{
+			name: "value",
+			type: "number",
+			required: true,
+			check: "rendered",
+			description: "Le nombre mis en avant."
+		},
+		{
+			name: "suffix",
+			type: "string",
+			required: false,
+			check: "rendered",
+			description: "L'unité ou le signe qui suit le nombre, fourni par l'appelant."
+		},
+		{
+			name: "label",
+			type: "string",
+			required: false,
+			check: "rendered",
+			description: "Le nom de ce qui est compté."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du composant."
+		}
+	],
+	usages: [{
+		when: "un total à lire au premier coup d’œil (issues ouvertes, PR en attente)",
+		use: "<Counter value={128} suffix=\"issues\" label=\"ouvertes\" />",
+		avoid: "un nombre noyé dans une phrase : le compteur est fait pour être vu seul"
+	}, {
+		when: "un chiffre sans unité",
+		use: "<Counter value={7} />",
+		avoid: "inventer une unité dans le cœur : elle appartient à l’app"
+	}]
+};
+//#endregion
+//#region src/components/progress-bar/progress-bar.tsx
+/**
+* La barre de progression (ADR 0015) : une valeur sur un total, sémantique ARIA
+* `progressbar` (`aria-valuenow/min/max`). Là où le `Meter` situe une valeur sur une
+* échelle avec un seuil, elle montre l'avancement d'une tâche. Aucun libellé n'est
+* inventé : l'appelant fournit `label`, ou rien.
+*/
+function clamp01(value) {
+	return Math.max(0, Math.min(1, value));
+}
+/** Une valeur non numérique est une donnée cassée : on la ramène à 0 plutôt qu'un CSS invalide. */
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function ProgressBar({ value, max = 100, label, showValue = false, className, ...props }) {
+	const shown = finite(value);
+	const peak = finite(max);
+	const ratio = peak > 0 ? clamp01(shown / peak) : 0;
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("flex flex-col gap-1", className),
+		...props,
+		children: [label || showValue ? /* @__PURE__ */ jsxs("div", {
+			className: "flex items-baseline justify-between gap-2 text-xs",
+			children: [label ? /* @__PURE__ */ jsx("span", {
+				className: "text-muted-foreground",
+				children: label
+			}) : /* @__PURE__ */ jsx("span", {}), showValue ? /* @__PURE__ */ jsxs("span", {
+				className: "font-mono tabular-nums",
+				children: [Math.round(ratio * 100), "%"]
+			}) : null]
+		}) : null, /* @__PURE__ */ jsx("div", {
+			role: "progressbar",
+			"aria-label": label,
+			"aria-valuenow": shown,
+			"aria-valuemin": 0,
+			"aria-valuemax": peak,
+			className: "h-2 w-full overflow-hidden rounded-full bg-muted",
+			children: /* @__PURE__ */ jsx("div", {
+				className: "h-full rounded-full bg-primary",
+				style: { width: `${ratio * 100}%` }
+			})
+		})]
+	});
+}
+//#endregion
+//#region src/components/progress-bar/manifest.ts
+/** Le manifeste de la ProgressBar (ADR 0005). */
+var progressBarManifest = {
+	name: "progress-bar",
+	title: "Barre de progression",
+	summary: "L'avancement d'une tâche sur un total, sémantique ARIA `progressbar`. À préférer au `Meter` quand il n’y a ni échelle ni seuil, juste une part accomplie.",
+	level: "primitive",
+	example: {
+		value: 60,
+		max: 100,
+		label: "synchronisation",
+		showValue: true
+	},
+	variants: [],
+	props: [
+		{
+			name: "value",
+			type: "number",
+			required: true,
+			check: "rendered",
+			description: "L'avancement, borné à `0..max` : c'est lui qui remplit la barre."
+		},
+		{
+			name: "max",
+			type: "number",
+			required: false,
+			check: "rendered",
+			description: "Le total (100 par défaut)."
+		},
+		{
+			name: "label",
+			type: "string",
+			required: false,
+			check: "rendered",
+			description: "Le nom de ce qui avance ; sert de nom accessible au rôle progressbar."
+		},
+		{
+			name: "showValue",
+			type: "boolean",
+			required: false,
+			check: "rendered",
+			description: "Affiche le pourcentage calculé à droite."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du composant."
+		}
+	],
+	usages: [{
+		when: "une tâche qui avance vers un total (import, synchronisation)",
+		use: "<ProgressBar value={60} max={100} label=\"import\" showValue />",
+		avoid: "le Meter, réservé à une valeur située avec un seuil"
+	}, {
+		when: "une part accomplie sans échelle ni seuil",
+		use: "<ProgressBar value={3} max={10} />",
+		avoid: "un libellé en dur dans le cœur : le texte vient de l’app"
+	}]
+};
+//#endregion
+//#region src/components/rating/rating.tsx
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function Rating({ value, max = 5, onValueChange, readOnly = false, ariaLabel, className }) {
+	const count = Math.max(0, Math.floor(max));
+	const stars = Array.from({ length: count }, (_, index) => index + 1);
+	const interactive = !readOnly && Boolean(onValueChange);
+	const buttons = useRef(/* @__PURE__ */ new Map());
+	const fill = (star) => star <= value ? "fill-current text-primary" : "text-muted-foreground";
+	if (!interactive) return /* @__PURE__ */ jsx("span", {
+		role: "img",
+		"aria-label": ariaLabel,
+		className: cn("inline-flex items-center gap-0.5", className),
+		children: stars.map((star) => /* @__PURE__ */ jsx(Star, {
+			"aria-hidden": true,
+			className: cn("size-4", fill(star))
+		}, star))
+	});
+	function select(next) {
+		const chosen = clamp(next, 1, count);
+		onValueChange?.(chosen);
+		buttons.current.get(chosen)?.focus();
+	}
+	function onKeyDown(event) {
+		switch (event.key) {
+			case "ArrowRight":
+			case "ArrowUp":
+				event.preventDefault();
+				select((value || 0) + 1);
+				break;
+			case "ArrowLeft":
+			case "ArrowDown":
+				event.preventDefault();
+				select((value || 1) - 1);
+				break;
+			case "Home":
+				event.preventDefault();
+				select(1);
+				break;
+			case "End":
+				event.preventDefault();
+				select(count);
+		}
+	}
+	return /* @__PURE__ */ jsx("div", {
+		role: "radiogroup",
+		"aria-label": ariaLabel,
+		onKeyDown,
+		className: cn("inline-flex items-center gap-0.5", className),
+		children: stars.map((star) => /* @__PURE__ */ jsx("button", {
+			ref: (element) => {
+				if (element) buttons.current.set(star, element);
+				else buttons.current.delete(star);
+			},
+			type: "button",
+			role: "radio",
+			"aria-checked": star === value,
+			"aria-label": String(star),
+			tabIndex: star === (value || 1) ? 0 : -1,
+			onClick: () => select(star),
+			className: "rounded p-0.5 outline-none focus-visible:ring-2 focus-visible:ring-ring",
+			children: /* @__PURE__ */ jsx(Star, {
+				"aria-hidden": true,
+				className: cn("size-4", fill(star))
+			})
+		}, star))
+	});
+}
+//#endregion
+//#region src/components/rating/manifest.ts
+/** Le manifeste du Rating (ADR 0005). */
+var ratingManifest = {
+	name: "rating",
+	title: "Note",
+	summary: "Une note sur `max` étoiles, **contrôlée**. Interactive seulement si l’app fournit `onValueChange` ; sinon un affichage. A11y `radiogroup` (flèches, Home/End).",
+	level: "primitive",
+	example: {
+		value: 3,
+		max: 5,
+		ariaLabel: "Note",
+		onValueChange: () => {}
+	},
+	variants: [],
+	props: [
+		{
+			name: "value",
+			type: "number",
+			required: true,
+			check: "rendered",
+			description: "La note actuelle, de 0 à `max`."
+		},
+		{
+			name: "max",
+			type: "number",
+			required: false,
+			check: "rendered",
+			description: "Le nombre d'étoiles (5 par défaut)."
+		},
+		{
+			name: "onValueChange",
+			type: "(value: number) => void",
+			required: false,
+			check: "accepted",
+			description: "Rend la note interactive quand fourni ; l'app décide de la suite."
+		},
+		{
+			name: "readOnly",
+			type: "boolean",
+			required: false,
+			check: "rendered",
+			description: "Force l’affichage seul, même si `onValueChange` est fourni."
+		},
+		{
+			name: "ariaLabel",
+			type: "string",
+			required: false,
+			check: "rendered",
+			description: "Le nom accessible du groupe : le cœur n'a pas d'i18n."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du composant."
+		}
+	],
+	usages: [{
+		when: "recueillir une note de l’utilisateur",
+		use: "<Rating value={note} onValueChange={setNote} ariaLabel={t.rating.label} />",
+		avoid: "laisser le Rating posséder la valeur : la donnée appartient à l’app"
+	}, {
+		when: "montrer une note déjà posée",
+		use: "<Rating value={4} readOnly ariaLabel={t.rating.label} />",
+		avoid: "un `onValueChange` sans intention de le consommer"
+	}]
+};
+//#endregion
+//#region src/components/timeline/timeline.tsx
+function Timeline({ items, ariaLabel, className, ...props }) {
+	return /* @__PURE__ */ jsx("ol", {
+		"aria-label": ariaLabel,
+		className: cn("relative flex flex-col", className),
+		...props,
+		children: items.map((item, index) => /* @__PURE__ */ jsxs("li", {
+			className: "relative flex gap-3 pb-4 last:pb-0",
+			children: [
+				index < items.length - 1 ? /* @__PURE__ */ jsx("span", {
+					"aria-hidden": true,
+					className: "absolute left-1 top-4 h-full w-px bg-border"
+				}) : null,
+				/* @__PURE__ */ jsx("span", {
+					"aria-hidden": true,
+					className: "relative z-10 mt-1 size-2.5 shrink-0 rounded-full bg-primary ring-4 ring-background"
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "min-w-0",
+					children: [/* @__PURE__ */ jsxs("div", {
+						className: "flex flex-wrap items-baseline gap-x-2",
+						children: [/* @__PURE__ */ jsx("span", {
+							className: "text-sm font-medium",
+							children: item.label
+						}), /* @__PURE__ */ jsx("time", {
+							className: "font-mono text-xs text-muted-foreground",
+							children: item.at
+						})]
+					}), item.detail ? /* @__PURE__ */ jsx("p", {
+						className: "text-xs text-muted-foreground",
+						children: item.detail
+					}) : null]
+				})
+			]
+		}, item.id))
+	});
+}
+//#endregion
+//#region src/components/timeline/manifest.ts
+/** Le manifeste de la Timeline (ADR 0005). */
+var timelineManifest = {
+	name: "timeline",
+	title: "Frise",
+	summary: "Une suite d'événements datés, du plus récent au plus ancien. Présentation seule : l'ordre, la date formatée et le texte viennent de l'appelant.",
+	level: "bloc",
+	example: {
+		ariaLabel: "Activité récente",
+		items: [
+			{
+				id: "a",
+				at: "2026-10-01 09:12",
+				label: "sync health",
+				detail: "les deux produits, 0 gap"
+			},
+			{
+				id: "b",
+				at: "2026-10-01 08:40",
+				label: "sync prs",
+				detail: "3 PR routées"
+			},
+			{
+				id: "c",
+				at: "2026-09-30 18:05",
+				label: "sync triage"
+			}
+		]
+	},
+	variants: [],
+	props: [
+		{
+			name: "items",
+			type: "TimelineItem[]",
+			required: true,
+			check: "accepted",
+			description: "Les événements : `id`, `at` (date déjà formatée), `label`, `detail?`."
+		},
+		{
+			name: "ariaLabel",
+			type: "string",
+			required: false,
+			check: "rendered",
+			description: "Le nom accessible de la frise : le cœur n'a pas d'i18n."
+		},
+		{
+			name: "className",
+			type: "string",
+			required: false,
+			check: "class",
+			description: "Les classes de l'appelant, fusionnées après celles du composant."
+		}
+	],
+	usages: [{
+		when: "montrer une suite d’événements récents (synchronisations, déploiements)",
+		use: "<Timeline items={events} ariaLabel={t.timeline.label} />",
+		avoid: "faire formater la date par le cœur : le format appartient à l’app"
+	}, {
+		when: "un seul événement, sans suite",
+		use: "une ligne simple, pas une frise",
+		avoid: "une frise d’un seul point, qui suggère une chronologie inexistante"
+	}]
+};
+//#endregion
+//#region src/catalogue/contract.ts
+/**
+* Le contrat d'un manifeste de composant (ADR 0005).
+*
+* Le manifeste est écrit à la main, colocalisé avec son composant
+* (`src/components/<nom>/manifest.ts`), et validé ici : une erreur de forme se voit à
+* l'import du catalogue, pas dans la page de style ni dans le serveur MCP.
+*
+* `usages` est obligatoire et non vide : c'est la partie qu'un agent vient chercher —
+* l'intention (« quel badge pour un statut de production »), pas seulement le type.
+*/
+var componentPropSchema = z.strictObject({
+	name: z.string().min(1),
+	type: z.string().min(1),
+	required: z.boolean(),
+	default: z.string().optional(),
+	/** Comment le test de cohérence vérifie que la prop est réellement acceptée. */
+	check: z.enum([
+		"attribute",
+		"class",
+		"content",
+		"rendered",
+		"accepted"
+	]),
+	description: z.string().min(1)
+});
+var componentVariantSchema = z.strictObject({
+	/** Le nom de la prop qui porte les variantes (`variant`, `size`, `tone`…). */
+	name: z.string().min(1),
+	values: z.array(z.string().min(1)).min(1),
+	default: z.string().optional(),
+	description: z.string().min(1)
+});
+var componentUsageSchema = z.strictObject({
+	when: z.string().min(1),
+	use: z.string().min(1),
+	avoid: z.string().optional()
+});
+var componentManifestSchema = z.strictObject({
+	name: z.string().regex(/^[a-z][a-z0-9-]*$/, "le nom du composant est en kebab-case, comme son dossier"),
+	title: z.string().min(1),
+	summary: z.string().min(1),
+	level: z.enum([
+		"jeton",
+		"primitive",
+		"bloc"
+	]),
+	props: z.array(componentPropSchema),
+	variants: z.array(componentVariantSchema),
+	/**
+	* Les props avec lesquelles le composant se rend : la page de style s'en sert, et le
+	* test de cohérence s'en sert comme base pour éprouver une prop « rendue ». Un
+	* composant sans exemple reste documentable, mais il ne se rend pas tout seul.
+	*/
+	example: z.record(z.string(), z.unknown()).optional(),
+	usages: z.array(componentUsageSchema).min(1, "un manifeste porte des usages (l'intention), pas seulement des props")
+});
+/** Le message d'erreur d'un manifeste invalide : quel composant, quel champ, quoi. */
+function errorMessage(schemaName, error) {
+	return `Catalogue : le manifeste de \`${schemaName}\` ne respecte pas le contrat — ${error.issues.map((issue) => `${issue.path.join(".") || "(racine)"} : ${issue.message}`).join(" ; ")}`;
+}
+//#endregion
+//#region src/catalogue/registry.ts
+var catalogueEntries = [
+	{
+		manifest: alertManifest,
+		component: Alert,
+		variantsConfig: { tone: {
+			variants: { tone: toneClasses },
+			defaultVariants: { tone: "info" }
+		} }
+	},
+	{
+		manifest: badgeManifest,
+		component: Badge,
+		variantsConfig: { variant: badgeVariantsConfig }
+	},
+	{
+		manifest: buttonManifest,
+		component: Button,
+		variantsConfig: {
+			variant: buttonVariantsConfig,
+			size: buttonVariantsConfig
+		}
+	},
+	{
+		manifest: cardManifest,
+		component: Card,
+		variantsConfig: {}
+	},
+	{
+		manifest: emptyStateManifest,
+		component: EmptyState,
+		variantsConfig: {}
+	},
+	{
+		manifest: chipManifest,
+		component: Chip,
+		variantsConfig: {
+			tone: {
+				variants: { tone: toneClasses },
+				defaultVariants: { tone: "neutral" }
+			},
+			size: {
+				variants: { size: chipSizeClasses },
+				defaultVariants: { size: "default" }
+			}
+		}
+	},
+	{
+		manifest: freshnessManifest,
+		component: Freshness,
+		variantsConfig: {}
+	},
+	{
+		manifest: inputManifest,
+		component: Input,
+		variantsConfig: {}
+	},
+	{
+		manifest: numberFieldManifest,
+		component: NumberField,
+		variantsConfig: {}
+	},
+	{
+		manifest: searchFieldManifest,
+		component: SearchField,
+		variantsConfig: {}
+	},
+	{
+		manifest: labelManifest,
+		component: Label,
+		variantsConfig: {}
+	},
+	{
+		manifest: fieldsetManifest,
+		component: Fieldset,
+		variantsConfig: {}
+	},
+	{
+		manifest: fieldManifest,
+		component: Field,
+		variantsConfig: {}
+	},
+	{
+		manifest: formManifest,
+		component: Form,
+		variantsConfig: {}
+	},
+	{
+		manifest: facetFilterManifest,
+		component: FacetFilter,
+		variantsConfig: {}
+	},
+	{
+		manifest: dataTableToolbarManifest,
+		component: DataTableToolbar,
+		variantsConfig: {}
+	},
+	{
+		manifest: dataTablePaginationManifest,
+		component: DataTablePagination,
+		variantsConfig: {}
+	},
+	{
+		manifest: meterManifest,
+		component: Meter,
+		variantsConfig: {}
+	},
+	{
+		manifest: separatorManifest,
+		component: Separator,
+		variantsConfig: {}
+	},
+	{
+		manifest: skeletonManifest,
+		component: Skeleton,
+		variantsConfig: {}
+	},
+	{
+		manifest: tableManifest,
+		component: Table,
+		variantsConfig: {}
+	},
+	{
+		manifest: textareaManifest,
+		component: Textarea,
+		variantsConfig: {}
+	},
+	{
+		manifest: checkboxManifest,
+		component: Checkbox,
+		variantsConfig: {}
+	},
+	{
+		manifest: switchManifest,
+		component: Switch,
+		variantsConfig: {}
+	},
+	{
+		manifest: radioManifest,
+		component: RadioGroup,
+		variantsConfig: {}
+	},
+	{
+		manifest: toggleManifest,
+		component: Toggle,
+		variantsConfig: {
+			variant: toggleVariantsConfig,
+			size: toggleVariantsConfig
+		}
+	},
+	{
+		manifest: toggleGroupManifest,
+		component: ToggleGroup,
+		variantsConfig: {
+			variant: toggleVariantsConfig,
+			size: toggleVariantsConfig
+		}
+	},
+	{
+		manifest: toastManifest,
+		component: Toast,
+		variantsConfig: { tone: {
+			variants: { tone: toneClasses },
+			defaultVariants: { tone: "info" }
+		} }
+	},
+	{
+		manifest: treeManifest,
+		component: Tree,
+		variantsConfig: {}
+	},
+	{
+		manifest: counterManifest,
+		component: Counter,
+		variantsConfig: {}
+	},
+	{
+		manifest: progressBarManifest,
+		component: ProgressBar,
+		variantsConfig: {}
+	},
+	{
+		manifest: ratingManifest,
+		component: Rating,
+		variantsConfig: {}
+	},
+	{
+		manifest: timelineManifest,
+		component: Timeline,
+		variantsConfig: {}
+	}
+];
+/**
+* Valide l'index : chaque manifeste respecte le contrat, et deux composants ne portent
+* pas le même nom. Une entrée refusée dit laquelle et pourquoi.
+*/
+function validateCatalogue(entries) {
+	const seen = /* @__PURE__ */ new Set();
+	return entries.map((entry) => {
+		const name = entry.manifest?.name ?? "(sans nom)";
+		const parsed = componentManifestSchema.safeParse(entry.manifest);
+		if (!parsed.success) throw new Error(errorMessage(name, parsed.error));
+		if (seen.has(parsed.data.name)) throw new Error(`Catalogue : deux manifestes portent le nom \`${parsed.data.name}\`.`);
+		seen.add(parsed.data.name);
+		return {
+			...entry,
+			manifest: parsed.data
+		};
+	});
+}
+/** Le catalogue validé — c'est celui-là qu'on expose. */
+var catalogue = validateCatalogue(catalogueEntries);
+/** Les noms des composants du catalogue, dans l'ordre de l'index. */
+var componentNames = catalogue.map((entry) => entry.manifest.name);
+/** Le composant et son manifeste, ou une erreur qui dit ce qui manque. */
+function findComponent(name) {
+	const entry = catalogue.find((candidate) => candidate.manifest.name === name);
+	if (!entry) throw new Error(`Catalogue : composant introuvable : \`${name}\` (connus : ${componentNames.join(", ")}).`);
+	return entry;
+}
+//#endregion
+//#region src/tokens/build.mjs
+/**
+* La dérivation des tokens : une source JSON, deux rendus (ADR 0004).
+*
+* `renderCss` produit les custom properties CSS que l'app consomme ; `buildResource`
+* produit l'inventaire plat que le serveur MCP du design system servira.
+*
+* Ce module est pur : il ne lit ni n'écrit aucun fichier, il prend le document DTCG
+* déjà parsé et rend du texte. Le CLI (`scripts/build-tokens.mjs`) fait l'entrée/sortie,
+* et les tests importent ces fonctions pour vérifier qu'un emplacement oublié les fait
+* échouer plutôt que de produire un blanc silencieux (ADR 0009).
+*/
+/** Un chemin d'alias DTCG : `{primitive.color.ink.950}`. */
+var ALIAS = /^\{([^}]+)\}$/;
+function modes$1(doc) {
+	const declared = doc?.$extensions?.["org.nomos"]?.modes;
+	if (!Array.isArray(declared) || declared.length === 0) throw new Error("tokens.json : `$extensions[\"org.nomos\"].modes` doit déclarer au moins un mode.");
+	return [...declared];
+}
+function defaultMode$1(doc) {
+	const declared = doc?.$extensions?.["org.nomos"]?.defaultMode;
+	const all = modes$1(doc);
+	if (!declared || !all.includes(declared)) throw new Error(`tokens.json : \`defaultMode\` doit être l'un des modes déclarés (${all.join(", ")}).`);
+	return declared;
+}
+/** Les densités déclarées (ADR 0008) : un nom et son multiplicateur d'espacement. */
+function densities$1(doc) {
+	const declared = doc?.$extensions?.["org.nomos"]?.densities;
+	if (!declared || typeof declared !== "object" || Object.keys(declared).length === 0) throw new Error("tokens.json : `$extensions[\"org.nomos\"].densities` doit déclarer au moins une densité.");
+	return declared;
+}
+function defaultDensity$1(doc) {
+	const declared = doc?.$extensions?.["org.nomos"]?.defaultDensity;
+	const all = Object.keys(densities$1(doc));
+	if (!declared || !all.includes(declared)) throw new Error(`tokens.json : \`defaultDensity\` doit être l'une des densités déclarées (${all.join(", ")}).`);
+	return declared;
+}
+/** Aplatit un nœud DTCG en `chemin -> token`, en s'arrêtant aux feuilles (`$value`). */
+function flatten(node, prefix = []) {
+	const tokens = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(node ?? {})) {
+		if (key.startsWith("$")) continue;
+		const path = [...prefix, key];
+		if (value && typeof value === "object" && "$value" in value) tokens.set(path.join("."), value);
+		else if (value && typeof value === "object") for (const [p, t] of flatten(value, path)) tokens.set(p, t);
+	}
+	return tokens;
+}
+function semanticTokens(doc) {
+	return flatten(doc.semantic);
+}
+/**
+* Tous les tokens du document, aplatis depuis sa racine : c'est là qu'un alias DTCG
+* résout son chemin (`{primitive.color.ink.950}` part de la racine du fichier, pas du
+* groupe `primitive`).
+*/
+function allTokens(doc) {
+	return flatten(doc);
+}
+/**
+* Résout un token sémantique pour un mode jusqu'à sa valeur concrète : une chaîne
+* d'alias `{primitive…}` est suivie jusqu'au bout, avec détection de cycle.
+*/
+function resolve(doc, path, mode) {
+	const known = allTokens(doc);
+	const token = semanticTokens(doc).get(path);
+	if (!token) throw new Error(`tokens.json : token sémantique introuvable : ${path}`);
+	const value = token.$value;
+	let raw = value;
+	if (value && typeof value === "object" && !Array.isArray(value) && !("colorSpace" in value) && !("value" in value)) {
+		if (!(mode in value)) throw new Error(`tokens.json : le mode \`${mode}\` n'emplit pas l'emplacement \`${path}\` (modes présents : ${Object.keys(value).join(", ")}).`);
+		raw = value[mode];
+	}
+	const seen = /* @__PURE__ */ new Set();
+	while (typeof raw === "string" && ALIAS.test(raw)) {
+		const target = raw.match(ALIAS)[1];
+		if (seen.has(target)) throw new Error(`tokens.json : alias cyclique autour de \`${target}\` (${path}).`);
+		seen.add(target);
+		const found = known.get(target);
+		if (!found) throw new Error(`tokens.json : \`${path}\` pointe vers \`${target}\`, qui n'existe pas dans \`primitive\`.`);
+		raw = found.$value;
+	}
+	return raw;
+}
+/** Rend une valeur DTCG en texte CSS. `type` n'est lu que pour une valeur tableau. */
+function cssValue(value, type) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return String(value);
+	if (Array.isArray(value)) {
+		if (type === "fontFamily") return value.map((f) => f.includes(" ") ? `"${f}"` : f).join(", ");
+		throw new Error(type ? `tokens.json : valeur tableau non rendue pour le type \`${type}\`.` : "tokens.json : une valeur tableau exige le `$type` de son token (aucun reçu).");
+	}
+	if (value && typeof value === "object") {
+		if (value.colorSpace === "hsl") {
+			const [h, s, l] = value.components;
+			return `${h} ${s}% ${l}%`;
+		}
+		if ("value" in value && "unit" in value) return `${value.value}${value.unit}`;
+	}
+	throw new Error(`tokens.json : valeur non rendue : ${JSON.stringify(value)}`);
+}
+/** Le nom de la custom property d'un emplacement sémantique. */
+function cssName(path, namespace) {
+	return `${namespace}-${path.replace(/\./g, "-")}`;
+}
+/** L'ensemble des emplacements sémantiques d'un mode, `nom CSS -> valeur`. */
+function slotsFor(doc, mode) {
+	const namespace = doc?.$extensions?.["org.nomos"]?.cssNamespace ?? "--nomos";
+	const slots = {};
+	for (const [path, token] of semanticTokens(doc)) slots[cssName(path, namespace)] = cssValue(resolve(doc, path, mode), token.$type);
+	return slots;
+}
+var HEADER = `/*
+ * Généré par scripts/build-tokens.mjs — ne pas éditer à la main.
+ * Source unique : tokens/tokens.json (format DTCG, ADR 0004).
+ * Rejouer : npm run tokens
+ */`;
+/**
+* Le CSS dérivé. Les couleurs et les dimensions remplissent chaque mode à l'identique :
+* `:root` porte le mode par défaut, `@media (prefers-color-scheme: light)` suit le
+* système tant qu'aucune classe n'a été posée, puis les classes `.dark` / `.light` et
+* `[data-theme=…]` tranchent explicitement (ADR 0009).
+*
+* `color-scheme` accompagne chaque mode : sans lui, les contrôles natifs (barres de
+* défilement, champs) restent au thème du système dans un thème forcé.
+*/
+function renderCss(doc) {
+	const namespace = doc?.$extensions?.["org.nomos"]?.cssNamespace ?? "--nomos";
+	const def = defaultMode$1(doc);
+	const other = modes$1(doc).find((m) => m !== def);
+	const block = (mode, indent) => {
+		const pad = " ".repeat(indent);
+		const lines = [`${pad}color-scheme: ${mode};`];
+		for (const [name, value] of Object.entries(slotsFor(doc, mode))) lines.push(`${pad}${name}: ${value};`);
+		return lines.join("\n");
+	};
+	const selectorBlock = (selector, mode, indent = 2) => `${" ".repeat(indent)}${selector} {\n${block(mode, indent + 2)}\n${" ".repeat(indent)}}`;
+	const parts = [
+		HEADER,
+		"",
+		"@layer base {",
+		selectorBlock(":root", def),
+		""
+	];
+	if (other === "light" || other === "dark") parts.push(`  /* Aucun mode posé sur la racine : c’est le système qui décide (ADR 0009). */`, `  @media (prefers-color-scheme: ${other}) {`, `    :root:not(${modes$1(doc).map((m) => `.${m}`).join("):not(")}) {`, block(other, 6), "    }", "  }", "");
+	for (const mode of modes$1(doc)) parts.push(selectorBlock(`.${mode}, [data-theme='${mode}']`, mode), "");
+	parts.push(`  :root { ${namespace}-density: ${densities$1(doc)[defaultDensity$1(doc)]}; }`, "");
+	for (const [name, value] of Object.entries(densities$1(doc))) parts.push(`  [data-density='${name}'], .${name} { ${namespace}-density: ${value}; }`, "");
+	parts.push("}", "", `/* namespace : ${namespace} — un thème d'app remplace ces emplacements (ADR 0003). */`, "");
+	return parts.join("\n");
+}
+//#endregion
+//#region src/tokens/skin.ts
+function resolveSkin(defaultDoc, overlay) {
+	if (overlay == null) return defaultDoc;
+	if (overlay.primitive) throw new Error("skin : un skin ne porte pas de `primitive` — il ne remplace que des emplacements sémantiques (ADR 0022).");
+	const known = semanticTokens(defaultDoc);
+	const overlaid = semanticTokens(overlay);
+	if (overlaid.size === 0) return defaultDoc;
+	const merged = structuredClone(defaultDoc);
+	merged.semantic ??= {};
+	for (const [path, token] of overlaid) {
+		const base = known.get(path);
+		if (!base) throw new Error(`skin : emplacement inconnu \`${path}\` — l'interface de thème est celle du défaut du cœur (ADR 0022).`);
+		setSemantic(merged.semantic, path, {
+			...base.$type ? { $type: base.$type } : {},
+			...token
+		});
+	}
+	return merged;
+}
+/** Pose un token à son chemin (`color.background`) en créant les groupes manquants. */
+function setSemantic(root, path, token) {
+	const keys = path.split(".");
+	let node = root;
+	for (const key of keys.slice(0, -1)) {
+		node[key] ??= {};
+		node = node[key];
+	}
+	node[keys[keys.length - 1]] = token;
+}
+//#endregion
+//#region src/tokens/resource.ts
+/**
+* La ressource de tokens, servie telle quelle à la page de style (et, plus tard, au
+* serveur MCP). C'est le rendu dérivé de `tokens/tokens.json` par
+* `npm run tokens` — ne pas l'éditer à la main : le test des tokens échoue si le
+* fichier committé n'est plus celui que la source produit.
+*/
+var tokensResource = {
+	$description: "La ressource `tokens` : la source unique aplatie, un inventaire par mode. Dérivée de `tokens/tokens.json` — ne pas éditer.",
+	namespace: "--nomos",
+	defaultMode: "dark",
+	modes: ["dark", "light"],
+	densities: {
+		"comfortable": 1,
+		"compact": .8
+	},
+	defaultDensity: "comfortable",
+	slots: {
+		"dark": {
+			"--nomos-color-background": "240 7% 8%",
+			"--nomos-color-foreground": "240 10% 94%",
+			"--nomos-color-card": "240 17% 12%",
+			"--nomos-color-card-foreground": "240 10% 94%",
+			"--nomos-color-popover": "240 17% 12%",
+			"--nomos-color-popover-foreground": "240 10% 94%",
+			"--nomos-color-primary": "174 100% 39%",
+			"--nomos-color-primary-foreground": "0 0% 0%",
+			"--nomos-color-secondary": "240 8% 16%",
+			"--nomos-color-secondary-foreground": "240 10% 94%",
+			"--nomos-color-muted": "240 8% 19%",
+			"--nomos-color-muted-foreground": "0 0% 60%",
+			"--nomos-color-accent": "240 8% 16%",
+			"--nomos-color-accent-foreground": "240 10% 94%",
+			"--nomos-color-destructive": "0 72% 71%",
+			"--nomos-color-destructive-foreground": "0 0% 0%",
+			"--nomos-color-border": "240 8% 19%",
+			"--nomos-color-input": "240 8% 19%",
+			"--nomos-color-ring": "174 100% 39%",
+			"--nomos-color-brand": "#00c9b1",
+			"--nomos-color-status-info": "199 89% 48%",
+			"--nomos-color-status-info-ink": "198 93% 74%",
+			"--nomos-color-status-progress": "258 90% 66%",
+			"--nomos-color-status-progress-ink": "255 92% 85%",
+			"--nomos-color-status-attention": "38 92% 50%",
+			"--nomos-color-status-attention-ink": "46 97% 65%",
+			"--nomos-color-status-warning": "25 95% 53%",
+			"--nomos-color-status-warning-ink": "31 97% 72%",
+			"--nomos-color-status-danger": "0 84% 60%",
+			"--nomos-color-status-danger-ink": "0 94% 82%",
+			"--nomos-color-status-success": "160 84% 39%",
+			"--nomos-color-status-success-ink": "156 72% 67%",
+			"--nomos-radius-pill": "9999px",
+			"--nomos-radius-control": "0.625rem",
+			"--nomos-radius-field": "0.5rem",
+			"--nomos-radius-chip": "0.375rem",
+			"--nomos-space-hairline": "2px",
+			"--nomos-space-tight": "4px",
+			"--nomos-space-snug": "8px",
+			"--nomos-space-base": "12px",
+			"--nomos-space-comfy": "16px",
+			"--nomos-space-loose": "24px",
+			"--nomos-space-section": "32px",
+			"--nomos-type-size-micro": "0.6875rem",
+			"--nomos-type-size-caption": "0.75rem",
+			"--nomos-type-size-body": "0.875rem",
+			"--nomos-type-size-lead": "1rem",
+			"--nomos-type-size-title": "1.125rem",
+			"--nomos-type-size-display": "1.5rem",
+			"--nomos-type-leading-micro": "0.875rem",
+			"--nomos-type-leading-caption": "1rem",
+			"--nomos-type-leading-body": "1.25rem",
+			"--nomos-type-leading-lead": "1.5rem",
+			"--nomos-type-leading-title": "1.75rem",
+			"--nomos-type-leading-display": "2rem",
+			"--nomos-type-weight-regular": "400",
+			"--nomos-type-weight-medium": "500",
+			"--nomos-type-weight-strong": "600",
+			"--nomos-type-family-sans": "ui-sans-serif, system-ui, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif"
+		},
+		"light": {
+			"--nomos-color-background": "0 0% 100%",
+			"--nomos-color-foreground": "240 10% 10%",
+			"--nomos-color-card": "0 0% 98%",
+			"--nomos-color-card-foreground": "240 10% 10%",
+			"--nomos-color-popover": "0 0% 100%",
+			"--nomos-color-popover-foreground": "240 10% 10%",
+			"--nomos-color-primary": "174 100% 35%",
+			"--nomos-color-primary-foreground": "0 0% 100%",
+			"--nomos-color-secondary": "240 5% 92%",
+			"--nomos-color-secondary-foreground": "240 10% 10%",
+			"--nomos-color-muted": "240 5% 92%",
+			"--nomos-color-muted-foreground": "240 4% 46%",
+			"--nomos-color-accent": "240 5% 92%",
+			"--nomos-color-accent-foreground": "240 10% 10%",
+			"--nomos-color-destructive": "0 72% 51%",
+			"--nomos-color-destructive-foreground": "0 0% 100%",
+			"--nomos-color-border": "240 6% 85%",
+			"--nomos-color-input": "240 6% 85%",
+			"--nomos-color-ring": "174 100% 35%",
+			"--nomos-color-brand": "#00c9b1",
+			"--nomos-color-status-info": "199 89% 48%",
+			"--nomos-color-status-info-ink": "201 96% 32%",
+			"--nomos-color-status-progress": "258 90% 66%",
+			"--nomos-color-status-progress-ink": "263 70% 50%",
+			"--nomos-color-status-attention": "38 92% 50%",
+			"--nomos-color-status-attention-ink": "26 90% 37%",
+			"--nomos-color-status-warning": "25 95% 53%",
+			"--nomos-color-status-warning-ink": "17 88% 40%",
+			"--nomos-color-status-danger": "0 84% 60%",
+			"--nomos-color-status-danger-ink": "0 74% 42%",
+			"--nomos-color-status-success": "160 84% 39%",
+			"--nomos-color-status-success-ink": "161 94% 25%",
+			"--nomos-radius-pill": "9999px",
+			"--nomos-radius-control": "0.625rem",
+			"--nomos-radius-field": "0.5rem",
+			"--nomos-radius-chip": "0.375rem",
+			"--nomos-space-hairline": "2px",
+			"--nomos-space-tight": "4px",
+			"--nomos-space-snug": "8px",
+			"--nomos-space-base": "12px",
+			"--nomos-space-comfy": "16px",
+			"--nomos-space-loose": "24px",
+			"--nomos-space-section": "32px",
+			"--nomos-type-size-micro": "0.6875rem",
+			"--nomos-type-size-caption": "0.75rem",
+			"--nomos-type-size-body": "0.875rem",
+			"--nomos-type-size-lead": "1rem",
+			"--nomos-type-size-title": "1.125rem",
+			"--nomos-type-size-display": "1.5rem",
+			"--nomos-type-leading-micro": "0.875rem",
+			"--nomos-type-leading-caption": "1rem",
+			"--nomos-type-leading-body": "1.25rem",
+			"--nomos-type-leading-lead": "1.5rem",
+			"--nomos-type-leading-title": "1.75rem",
+			"--nomos-type-leading-display": "2rem",
+			"--nomos-type-weight-regular": "400",
+			"--nomos-type-weight-medium": "500",
+			"--nomos-type-weight-strong": "600",
+			"--nomos-type-family-sans": "ui-sans-serif, system-ui, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif"
+		}
+	}
+};
+//#endregion
+export { Alert, Badge, Button, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, Chip, CompactMeter, Counter, DataTablePagination, DataTableToolbar, EmptyState, FacetFilter, FacetedDataTable, Field, Fieldset, Form, Freshness, Input, Label, Meter, NumberField, ProgressBar, RadioGroup, RadioGroupItem, Rating, SearchField, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectSeparator, SelectTrigger, SelectValue, SelectionTree, Separator, SheetDescription, SheetHeader, SheetTitle, Skeleton, Switch, TONES, Table, TableBody, TableCell, TableHead, TableHeader, TableRow, Textarea, Timeline, Toast, ToastProvider, Toggle, ToggleGroup, ToggleGroupItem, TooltipProvider, Tree, alertManifest, badgeManifest, badgeVariants, badgeVariantsConfig, buttonManifest, buttonVariants, buttonVariantsConfig, cardManifest, catalogue, checkboxManifest, chipManifest, cn, componentManifestSchema, componentNames, counterManifest, dataTableFeatures, dataTablePaginationManifest, dataTableToolbarManifest, emptyStateManifest, facetFilterManifest, fieldManifest, fieldsetManifest, findComponent, formManifest, freshnessManifest, inputManifest, labelManifest, meterManifest, numberFieldManifest, progressBarManifest, radioManifest, ratingManifest, renderCss, resolveSkin, searchFieldManifest, separatorManifest, skeletonManifest, switchManifest, tableManifest, textareaManifest, timelineManifest, toastManifest, toggleGroupManifest, toggleManifest, toggleVariants, toggleVariantsConfig, tokensResource, toneClasses, treeManifest, useToast, validateCatalogue };