fix(outils): un seul repère main, tabpanel sur le panneau ; doublons retirés de l'arbre fmhy (B6-M5)

Le repère <main> passe à la racine de la page et le panneau d'onglet devient
un <div role="tabpanel"> (Lighthouse signalait role=tabpanel sur <main>).
FreeCAD, Blender, Inkscape, GIMP, LibreOffice Draw et Joplin sortent de
fmhy-curated.json : ils sont désormais dans la sélection open source.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0136n5xMLHuaBDLcPJYCDjRW

DESIGN-SYSTEM.md

@@ -101,6 +101,8 @@ Contenus de détail en place : `/` → `FicheDetail` (`compact`, `etiquettes-cli
 3. Le slot `#carte`, et le slot `#detail` (contenu de la fiche ; une page sans contenu de détail affiche seulement les actions). Les épingles appellent `vf.ouvrirFiche(id)`.
 4. Ajouter des cas à `scripts/test-vue-fiches.mjs` si la page introduit une règle nouvelle.
 
+**Troisième page en place : `/outils?tab=partir-de-soi` (B6-M2)** — sept fiches, une par mot de la slide 17 (`components/OutilsPartirDeSoi.vue`, adaptateur `toMiniMot`). Trois extensions optionnelles du composant, sans effet sur `/` et `/agences` : tri `ordre` (ordre du tableau d'entrée) avec `config.triDefaut` (tri sans filtre ; la pertinence reste prioritaire dès qu'un filtre est actif) et `config.libellesTri` ; prop `libelles-vue` (`{ carte: 'Graphe' }` : le bouton, et « Voir dans le graphe » au lieu de « Voir sur la carte » ; l'URL garde `vue=carte`). Le slot `#carte` y est `GrapheMots.vue`, un SVG statique (nœud central, mots en couronne, ressources en feuilles) dans le vocabulaire du motif maillage. La page vit dans un onglet : `tab=` est un paramètre que la vue ne gère pas, donc recopié à chaque écriture.
+
 **`FicheMiniCard`** : racine `<article>`, toute la carte ouvre la fiche par un bouton étiré (`::after`) ; avec `etiquettes-cliquables`, les chips deviennent des boutons (impossible dans l'ancienne racine `<button>`). Props `actif` (liseré safran au survol d'épingle), `etiquettes-actives`. Résumé et « Sans localisation » en `color-mix(--text 78 %)` : `--text-muted` et `--text-subtle` échouaient au contraste.
 
 ## Intention d'abord

components/GrapheMots.vue

@@ -0,0 +1,314 @@
+<!--
+  GrapheMots — B6-M2. Le graphe des sept mots de « Partir de soi » : un nœud
+  central, les mots en couronne (ordre de la slide, sens horaire depuis le
+  haut), et autour de chaque mot ses ressources en petits nœuds-feuilles.
+  Vocabulaire du motif maillage (DESIGN-SYSTEM) : nœuds pleins, arêtes fines,
+  un nœud central mis en avant. Statique et déterministe : pas de simulation,
+  rien ne bouge ; la mise en page est une fonction pure de la taille mesurée.
+
+  Il vit dans le slot #carte de VueFiches et ne connaît que `vf` :
+  clic / Entrée sur un mot ouvre sa fiche (`vf.ouvrirFiche`), le mot ouvert
+  (`vf.ficheId`) et le mot survolé dans la liste (`vf.survolId`) s'allument,
+  les mots hors du résultat (`vf.idsResultat`) s'estompent sans disparaître.
+  Les feuilles ne sont pas dans l'ordre de tabulation (on y accède par leur
+  mot) ; leur libellé apparaît au survol.
+-->
+<template>
+  <div ref="racine" class="gm">
+    <svg
+      class="gm__svg"
+      :viewBox="`0 0 ${taille.w} ${taille.h}`"
+      preserveAspectRatio="xMidYMid meet"
+      role="group"
+      aria-labelledby="gm-titre"
+    >
+      <title id="gm-titre">Graphe des sept mots de « Partir de soi » et des ressources de chacun</title>
+
+      <!-- Arêtes : centre → mot, mot → feuilles -->
+      <g class="gm__aretes" aria-hidden="true">
+        <template v-for="n in noeuds" :key="`a-${n.id}`">
+          <line
+            :x1="centre.x" :y1="centre.y" :x2="n.x" :y2="n.y"
+            class="gm__arete" :class="{ 'gm__arete--vif': allume(n.id), 'gm__arete--hors': hors(n.id) }"
+          />
+          <line
+            v-for="f in n.feuilles" :key="`a-${n.id}-${f.id}`"
+            :x1="n.x" :y1="n.y" :x2="f.x" :y2="f.y"
+            class="gm__arete gm__arete--feuille" :class="{ 'gm__arete--vif': allume(n.id), 'gm__arete--hors': hors(n.id) }"
+          />
+        </template>
+      </g>
+
+      <!-- Nœud central -->
+      <g class="gm__centre" aria-hidden="true">
+        <circle :cx="centre.x" :cy="centre.y" :r="RAYON_CENTRE" class="gm__centre-rond" />
+        <text :x="centre.x" :y="centre.y - 7" class="gm__centre-texte" text-anchor="middle">Partir</text>
+        <text :x="centre.x" :y="centre.y + 8" class="gm__centre-texte" text-anchor="middle">de soi</text>
+      </g>
+
+      <!-- Feuilles (ressources) -->
+      <g v-for="n in noeuds" :key="`f-${n.id}`" class="gm__feuilles" :class="{ 'gm__feuilles--hors': hors(n.id) }">
+        <circle
+          v-for="f in n.feuilles" :key="f.id"
+          :cx="f.x" :cy="f.y" r="5.5"
+          class="gm__feuille" :class="{ 'gm__feuille--vive': allume(n.id) || survolFeuille === `${n.id}/${f.id}` }"
+          @click="vf.ouvrirFiche(n.id)"
+          @mouseenter="survolerFeuille(n.id, f.id)"
+          @mouseleave="survolerFeuille(null, null)"
+        >
+          <title>{{ f.titre }}</title>
+        </circle>
+      </g>
+
+      <!-- Mots -->
+      <g
+        v-for="n in noeuds"
+        :key="n.id"
+        class="gm__mot"
+        :class="{ 'gm__mot--actif': allume(n.id), 'gm__mot--hors': hors(n.id), 'gm__mot--vide': n.vide }"
+        role="button"
+        tabindex="0"
+        :aria-label="n.aria"
+        :aria-pressed="actif(n.id)"
+        @click="vf.ouvrirFiche(n.id)"
+        @keydown.enter.prevent="vf.ouvrirFiche(n.id)"
+        @keydown.space.prevent="vf.ouvrirFiche(n.id)"
+        @mouseenter="vf.survolId = n.id"
+        @mouseleave="vf.survolId = null"
+        @focus="vf.survolId = n.id"
+        @blur="vf.survolId = null"
+      >
+        <rect
+          :x="n.x - n.l / 2" :y="n.y - n.h / 2" :width="n.l" :height="n.h" :rx="n.h / 2"
+          class="gm__pilule"
+        />
+        <text :x="n.x" :y="n.y" text-anchor="middle" class="gm__libelle" aria-hidden="true">
+          <tspan v-for="(ligne, i) in n.lignes" :key="i" :x="n.x" :y="n.y + (i - (n.lignes.length - 1) / 2) * INTERLIGNE + 4.5">{{ ligne }}</tspan>
+        </text>
+      </g>
+
+      <!-- Libellé de la feuille survolée, au-dessus de tout -->
+      <g v-if="bulle" class="gm__bulle" aria-hidden="true">
+        <rect :x="bulle.x - bulle.l / 2" :y="bulle.y - 11" :width="bulle.l" height="22" rx="6" class="gm__bulle-fond" />
+        <text :x="bulle.x" :y="bulle.y + 4" text-anchor="middle" class="gm__bulle-texte">{{ bulle.texte }}</text>
+      </g>
+    </svg>
+  </div>
+</template>
+
+<script setup lang="ts">
+import type { VueFichesEtat } from '~/composables/useVueFiches'
+
+const props = defineProps<{
+  vf: VueFichesEtat
+  mots: { id: string; mot: string; ressources: { id: string; titre: string }[]; vide?: boolean }[]
+}>()
+
+const RAYON_CENTRE = 36
+const INTERLIGNE = 15
+const CARACTERES_LIGNE = 16
+const PORTEE_FEUILLES = 46
+const MARGE = 10
+
+// ── Taille : mesurée au montage (le rendu serveur part d'une taille plausible) ──
+const racine = ref<HTMLElement | null>(null)
+const taille = reactive({ w: 720, h: 600 })
+onMounted(() => {
+  const el = racine.value
+  if (!el || typeof ResizeObserver === 'undefined') return
+  const maj = (w: number, h: number) => {
+    if (w > 40 && h > 40) { taille.w = Math.round(w); taille.h = Math.round(h) }
+  }
+  maj(el.clientWidth, el.clientHeight)
+  const ro = new ResizeObserver((entrees) => {
+    const r = entrees[0]?.contentRect
+    if (r) maj(r.width, r.height)
+  })
+  ro.observe(el)
+  onBeforeUnmount(() => ro.disconnect())
+})
+
+// ── Mise en page : fonction pure de (taille, mots) ──
+/** Une ligne si ça tient, sinon deux lignes équilibrées (« naviguer / avec soi », pas « naviguer avec / soi »). */
+function couper(texte: string): string[] {
+  if (texte.length <= CARACTERES_LIGNE) return [texte]
+  const mots = texte.split(' ')
+  let meilleur: string[] = [texte]
+  let pire = Infinity
+  for (let i = 1; i < mots.length; i++) {
+    const l = [mots.slice(0, i).join(' '), mots.slice(i).join(' ')]
+    const m = Math.max(l[0].length, l[1].length)
+    if (m < pire) { pire = m; meilleur = l }
+  }
+  return meilleur
+}
+
+function tronquer(t: string, max = 44): string {
+  return t.length > max ? `${t.slice(0, max - 1).trimEnd()}…` : t
+}
+
+const centre = computed(() => ({ x: taille.w / 2, y: taille.h / 2 }))
+
+const noeuds = computed(() => {
+  const n = props.mots.length
+  const { w, h } = taille
+  const base = props.mots.map((m) => {
+    const lignes = couper(m.mot)
+    return { m, lignes, l: Math.max(...lignes.map((x) => x.length)) * 6.9 + 24, h: lignes.length * INTERLIGNE + 11 }
+  })
+  const lMax = Math.max(...base.map((b) => b.l))
+  const hMax = Math.max(...base.map((b) => b.h))
+  const rx = Math.max(48, w / 2 - lMax / 2 - PORTEE_FEUILLES - MARGE)
+  const ry = Math.max(70, h / 2 - hMax / 2 - PORTEE_FEUILLES - MARGE)
+  const cx = centre.value.x
+  const cy = centre.value.y
+
+  // Colonne étroite : la couronne ne tient plus (les mots du bas se chevaucheraient).
+  // Les mots s'étagent alors en zigzag autour du centre, une rangée chacun, dans le
+  // même sens de lecture (haut, puis la droite en descendant, puis la gauche en remontant),
+  // et leurs ressources se rangent SOUS le mot.
+  const etroit = rx < lMax * 1.3
+  let place: { x: number; y: number }[]
+  if (etroit) {
+    const droite = Math.ceil((n - 1) / 2)
+    const rangsDroite = Array.from({ length: droite }, (_, i) => 1 + 2 * i)
+    const rangsGauche = Array.from({ length: n }, (_, i) => i).filter((r) => r > 0 && !rangsDroite.includes(r)).reverse()
+    const rang = (i: number) => (i === 0 ? 0 : i <= droite ? rangsDroite[i - 1] : rangsGauche[i - droite - 1])
+    const y0 = hMax / 2 + MARGE
+    const y1 = h - hMax / 2 - MARGE - 24 // de la place sous le dernier mot pour ses feuilles
+    const pas = n > 1 ? (y1 - y0) / (n - 1) : 0
+    const dx = Math.max(0, w / 2 - lMax / 2 - 6)
+    place = base.map((_, i) => ({ x: i === 0 ? cx : i <= droite ? cx + dx : cx - dx, y: y0 + rang(i) * pas }))
+  } else {
+    place = base.map((_, i) => {
+      const a = -Math.PI / 2 + (i * 2 * Math.PI) / n // depuis le haut, sens horaire
+      return { x: cx + rx * Math.cos(a), y: cy + ry * Math.sin(a) }
+    })
+  }
+
+  return base.map((b, i) => {
+    const { x, y } = place[i]
+    const k = b.m.ressources.length
+    let feuilles: { id: string; titre: string; x: number; y: number }[]
+    if (etroit) {
+      const ecart = k > 1 ? Math.min(17, (b.l - 20) / (k - 1)) : 0
+      feuilles = b.m.ressources.map((r, j) => ({
+        id: r.id,
+        titre: r.titre,
+        x: x + (j - (k - 1) / 2) * ecart,
+        y: y + b.h / 2 + 13 + (j % 2 ? 9 : 0),
+      }))
+    } else {
+      // direction « vers l'extérieur » réelle (l'ellipse n'est pas un cercle)
+      const dir = Math.atan2(y - cy, x - cx)
+      const pas = Math.min(0.55, 2.3 / Math.max(k, 1))
+      const dist = Math.abs(Math.cos(dir)) * (b.l / 2) + Math.abs(Math.sin(dir)) * (b.h / 2) + 20
+      feuilles = b.m.ressources.map((r, j) => {
+        const t = dir + (j - (k - 1) / 2) * pas
+        const d = dist + (j % 2 ? 12 : 0)
+        return {
+          id: r.id,
+          titre: r.titre,
+          x: Math.min(w - 8, Math.max(8, x + d * Math.cos(t))),
+          y: Math.min(h - 8, Math.max(8, y + d * Math.sin(t))),
+        }
+      })
+    }
+    return {
+      id: b.m.id,
+      x, y, l: b.l, h: b.h, lignes: b.lignes,
+      vide: !!b.m.vide || k === 0,
+      aria: `${b.m.mot}, ${k === 0 ? 'aucune ressource pour l’instant' : k === 1 ? '1 ressource' : `${k} ressources`}`,
+      feuilles,
+    }
+  })
+})
+
+// ── États (tout vient de vf) ──
+const actif = (id: string) => String(props.vf.ficheId ?? '') === id
+const survol = (id: string) => props.vf.survolId != null && String(props.vf.survolId) === id
+const allume = (id: string) => actif(id) || survol(id)
+const hors = (id: string) => !props.vf.idsResultat.has(id)
+
+const survolFeuille = ref<string | null>(null)
+function survolerFeuille(mot: string | null, feuille: string | null) {
+  survolFeuille.value = mot && feuille ? `${mot}/${feuille}` : null
+  props.vf.survolId = mot
+}
+
+const bulle = computed(() => {
+  if (!survolFeuille.value) return null
+  const [mot, feuille] = survolFeuille.value.split('/')
+  const f = noeuds.value.find((n) => n.id === mot)?.feuilles.find((x) => x.id === feuille)
+  if (!f) return null
+  const texte = tronquer(f.titre)
+  const l = texte.length * 6.3 + 16
+  const x = Math.min(taille.w - l / 2 - 4, Math.max(l / 2 + 4, f.x))
+  const y = f.y < 30 ? f.y + 24 : f.y - 18
+  return { x, y, l, texte }
+})
+</script>
+
+<style scoped>
+.gm {
+  position: relative;
+  flex: 1;
+  min-height: 0;
+  min-width: 0;
+  overflow: hidden;
+  background: var(--bg-alt);
+}
+.gm__svg {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  display: block;
+  font-family: inherit;
+}
+
+/* Arêtes fines */
+.gm__arete { stroke: var(--nav-primary-solid); stroke-width: 1; stroke-opacity: 0.35; }
+.gm__arete--feuille { stroke-opacity: 0.28; }
+.gm__arete--vif { stroke-width: 2; stroke-opacity: 0.8; }
+.gm__arete--hors { stroke-opacity: 0.12; }
+
+/* Nœud central, mis en avant */
+.gm__centre-rond { fill: var(--nav-primary-solid); stroke: var(--accent); stroke-width: 3; }
+.gm__centre-texte { fill: var(--nav-text-on-primary); font-size: 12px; font-weight: 700; }
+
+/* Feuilles : petits nœuds pleins */
+.gm__feuille {
+  fill: var(--nav-primary-solid);
+  stroke: var(--bg-alt);
+  stroke-width: 1.5;
+  cursor: pointer;
+  transition: fill 120ms ease-out;
+}
+.gm__feuille--vive { fill: var(--accent); stroke: var(--nav-primary-solid); }
+.gm__feuilles--hors { opacity: 0.3; }
+
+/* Mots : pastilles qui portent leur libellé */
+.gm__mot { cursor: pointer; outline: none; transition: opacity 120ms ease-out; }
+.gm__pilule {
+  fill: var(--surface);
+  stroke: var(--nav-primary-solid);
+  stroke-width: 2;
+  transition: fill 120ms ease-out, stroke 120ms ease-out;
+}
+.gm__libelle { fill: var(--text); font-size: 12.5px; font-weight: 600; pointer-events: none; }
+.gm__mot--vide .gm__pilule { stroke-dasharray: 5 4; }
+.gm__mot--actif .gm__pilule { fill: var(--accent); stroke: var(--nav-primary-solid); }
+.gm__mot--actif .gm__libelle { fill: var(--on-accent); }
+.gm__mot--hors { opacity: 0.4; }
+.gm__mot:focus-visible .gm__pilule { stroke: var(--focus-ring); stroke-width: 4; }
+
+/* Libellé de feuille */
+.gm__bulle { pointer-events: none; }
+.gm__bulle-fond { fill: var(--surface); stroke: var(--nav-primary-solid); stroke-width: 1; }
+.gm__bulle-texte { fill: var(--text); font-size: 11.5px; font-weight: 500; }
+
+@media (prefers-reduced-motion: reduce) {
+  .gm__feuille, .gm__mot, .gm__pilule { transition: none; }
+}
+</style>

components/OutilsPartirDeSoi.vue

@@ -0,0 +1,225 @@
+<!--
+  OutilsPartirDeSoi — B6-M2. Le sous-onglet « Partir de soi » de /outils : les
+  sept mots de la slide 17 de la conférence, un mot = une fiche, rendus par
+  la vue fiches partagée (état Mixte : liste des mots | graphe | fiche ouverte).
+  Troisième page branchée sur VueFiches (DESIGN-SYSTEM §Brancher une troisième
+  page). Les données viennent de `partir_de_soi` dans public/data/outils.json.
+
+  Monté seulement quand `?tab=partir-de-soi` : l'état de la vue (q, filtres,
+  fiche…) vit dans l'URL et disparaît avec l'onglet. `tab=` est recopié par la
+  vue à chacune de ses écritures (paramètre qu'elle ne gère pas).
+-->
+<template>
+  <div class="ops">
+    <VueFiches
+      :vf="vf"
+      intention="Sept mots de la conférence, et pour chacun des ressources libres qui m'ont aidé ou qu'on m'a confiées. Ouvre un mot."
+      libelle-recherche="Rechercher une ressource…"
+      :libelles-vue="{ carte: 'Graphe' }"
+      :lien-page="() => null"
+    >
+      <template #carte>
+        <GrapheMots :vf="vf" :mots="motsGraphe" />
+      </template>
+
+      <template #detail="{ fiche, filtrer }">
+        <article v-if="parId.get(String(fiche.id))" class="mot">
+          <h2 class="mot__titre">{{ parId.get(String(fiche.id))!.mot }}</h2>
+          <p class="mot__resume">{{ parId.get(String(fiche.id))!.resume }}</p>
+
+          <template v-if="parId.get(String(fiche.id))!.vide">
+            <p class="mot__vide">{{ parId.get(String(fiche.id))!.vide }}</p>
+            <NuxtLink to="/proposer?categorie=outils" class="mot__proposer">Proposer une ressource</NuxtLink>
+          </template>
+
+          <ul v-else class="ress" :aria-label="`Ressources pour ${parId.get(String(fiche.id))!.mot}`">
+            <li v-for="r in ressourcesDe(String(fiche.id))" :key="r.id" class="ress__carte">
+              <p class="ress__titre">
+                <a v-if="r.url" :href="r.url" target="_blank" rel="noopener noreferrer">{{ r.titre }}<span class="ress__ext" aria-hidden="true"> ↗</span><span class="vf-sr-mot"> (nouvel onglet)</span></a>
+                <template v-else>{{ r.titre }}</template>
+              </p>
+
+              <ChipGroup :aria-label="`Format et accès de ${r.titre}`" class="ress__chips">
+                <Chip
+                  :label="r.format"
+                  variant="fonction"
+                  :active="(vf.etat.filtres.format ?? []).includes(slugEtiquette(r.format))"
+                  :aria-label="`Filtrer par format : ${r.format}`"
+                  @toggle="filtrer('format', slugEtiquette(r.format))"
+                />
+                <Chip
+                  :label="r.acces"
+                  variant="echelle"
+                  :active="(vf.etat.filtres.acces ?? []).includes(slugEtiquette(r.acces))"
+                  :aria-label="`Filtrer par accès : ${r.acces}`"
+                  @toggle="filtrer('acces', slugEtiquette(r.acces))"
+                />
+              </ChipGroup>
+
+              <p v-if="r.pourquoi" class="ress__pourquoi">{{ r.pourquoi }}</p>
+              <p v-if="r.urls?.length" class="ress__liens">
+                <template v-for="(u, i) in r.urls" :key="u">
+                  <span v-if="i > 0" aria-hidden="true"> · </span>
+                  <a :href="u" target="_blank" rel="noopener noreferrer">{{ u.replace(/^https:\/\//, '') }}<span class="vf-sr-mot"> (nouvel onglet)</span></a>
+                </template>
+              </p>
+              <p v-if="r.note" class="ress__note">{{ r.note }}</p>
+
+              <ul v-if="r.episodes?.length" class="eps" :aria-label="`Épisodes de ${r.titre}`">
+                <li v-for="ep in r.episodes" :key="ep.ep" class="eps__item" :class="{ 'eps__item--muet': !ep.url }">
+                  <span class="eps__ep">EP/{{ ep.ep }}</span>
+                  <span class="eps__corps">
+                    <a v-if="ep.url" :href="ep.url" target="_blank" rel="noopener noreferrer" class="eps__titre">{{ ep.titre }}<span class="vf-sr-mot"> (nouvel onglet)</span></a>
+                    <span v-else class="eps__titre">{{ ep.titre }}</span>
+                    <span class="eps__personnes"> — {{ ep.personnes }}</span>
+                    <span v-if="ep.note" class="eps__note"> ({{ ep.note }})</span>
+                  </span>
+                </li>
+              </ul>
+            </li>
+          </ul>
+        </article>
+      </template>
+    </VueFiches>
+  </div>
+</template>
+
+<script setup lang="ts">
+import type { ConfigVueFiches } from '~/utils/vueFiches'
+import { toMiniMot, valeursRessources, slugEtiquette, type FicheMot, type RessourceMot } from '~/composables/useFicheAdapter'
+
+interface RessourceComplete extends RessourceMot {
+  url?: string | null
+  urls?: string[]
+  note?: string
+  episodes?: { ep: string; titre: string; personnes: string; url?: string | null; note?: string }[]
+}
+interface DonneesPartirDeSoi {
+  fiches: (FicheMot & { vide?: string | null })[]
+  ressources: RessourceComplete[]
+}
+
+const props = defineProps<{ data: DonneesPartirDeSoi }>()
+
+const ressourcesDe = (motId: string) => props.data.ressources.filter((r) => r.fiches.includes(motId))
+const parId = computed(() => new Map(props.data.fiches.map((f) => [f.id, f])))
+
+// Étape 1 : adaptateur (un mot → une MiniFiche). L'ordre du tableau est celui de la slide.
+const fichesMini = computed(() => props.data.fiches.map((f) => toMiniMot(f, ressourcesDe(f.id))))
+
+// Étape 2 : configuration. Sept fiches, pas de groupe ; tri « ordre de la slide » par défaut.
+const config = computed<ConfigVueFiches>(() => ({
+  dimensions: [
+    { cle: 'format', libelle: 'Format', variante: 'fonction', valeurs: valeursRessources(props.data.ressources, 'format') },
+    { cle: 'acces', libelle: 'Accès', variante: 'echelle', valeurs: valeursRessources(props.data.ressources, 'acces') },
+  ],
+  tris: ['ordre', 'pertinence', 'nom'],
+  triDefaut: 'ordre',
+  libellesTri: { ordre: 'Ordre de la slide' },
+  groupes: [],
+  etats: ['carte', 'mixte', 'fiches'],
+}))
+
+const vf = useVueFiches(fichesMini, config)
+
+// Étape 3 : le graphe (slot #carte) lit les mêmes données et l'état de la vue.
+const motsGraphe = computed(() =>
+  props.data.fiches.map((f) => ({
+    id: f.id,
+    mot: f.mot,
+    vide: !!f.vide,
+    ressources: ressourcesDe(f.id).map((r) => ({ id: r.id, titre: r.titre })),
+  })),
+)
+
+// Une fiche ouverte donne son nom à l'onglet du navigateur.
+useSeoMeta({
+  title: () => (vf.ficheOuverte ? `${vf.ficheOuverte.nom} — Partir de soi — AEP` : 'Outils — AEP — Partir de soi'),
+})
+</script>
+
+<style scoped>
+.ops { height: 100%; min-height: 0; min-width: 0; }
+
+/* Lecteurs d'écran seulement */
+.vf-sr-mot {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+}
+
+/* Fiche d'un mot */
+.mot__titre { margin: 0 0 var(--space-xs); font-size: 1.25rem; font-weight: var(--fw-bold); line-height: 1.25; }
+.mot__resume {
+  margin: 0 0 var(--space-md);
+  font-size: var(--fs-sm);
+  line-height: 1.55;
+  color: color-mix(in srgb, var(--text) 78%, transparent);
+}
+.mot__vide {
+  margin: 0 0 var(--space-sm);
+  padding: var(--space-sm);
+  border: 1.5px dashed var(--border-strong);
+  border-radius: var(--radius-md);
+  font-size: var(--fs-sm);
+  line-height: 1.55;
+}
+.mot__proposer {
+  display: inline-flex;
+  align-items: center;
+  min-height: 40px;
+  padding: 0 var(--space-md);
+  border-radius: var(--radius-md);
+  background: var(--accent);
+  color: var(--on-accent);
+  font-size: var(--fs-sm);
+  font-weight: var(--fw-semibold);
+  text-decoration: none;
+}
+.mot__proposer:hover { opacity: 0.9; }
+.mot__proposer:focus-visible { outline: 2px solid var(--focus-ring); outline-offset: 2px; }
+
+/* Ressources */
+.ress { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: var(--space-sm); }
+.ress__carte {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-xs);
+  min-width: 0;
+  padding: var(--space-sm);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-md);
+  background: var(--bg);
+}
+.ress__carte p { margin: 0; overflow-wrap: anywhere; }
+.ress__titre { font-size: var(--fs-sm); font-weight: var(--fw-semibold); line-height: 1.35; }
+.ress__titre a,
+.ress__liens a { color: var(--nav-primary-solid); text-underline-offset: 2px; }
+.ress__titre a:focus-visible,
+.ress__liens a:focus-visible,
+.eps__titre:focus-visible { outline: 2px solid var(--focus-ring); outline-offset: 2px; border-radius: var(--radius-sm); }
+.ress__pourquoi { font-size: var(--fs-sm); line-height: 1.5; }
+.ress__liens { font-size: var(--fs-xs, 0.75rem); }
+.ress__note { font-size: var(--fs-xs, 0.75rem); font-style: italic; color: color-mix(in srgb, var(--text) 78%, transparent); }
+
+/* Épisodes OFQA */
+.eps { list-style: none; margin: var(--space-2xs) 0 0; padding: 0; display: flex; flex-direction: column; gap: var(--space-2xs); }
+.eps__item { display: flex; gap: var(--space-xs); align-items: baseline; font-size: var(--fs-sm); line-height: 1.4; }
+.eps__ep {
+  flex: 0 0 3.6rem;
+  font-family: var(--font-mono, 'JetBrains Mono', 'Courier New', monospace);
+  font-size: var(--fs-xs, 0.75rem);
+  font-weight: var(--fw-semibold);
+  color: color-mix(in srgb, var(--text) 78%, transparent);
+}
+.eps__corps { min-width: 0; overflow-wrap: anywhere; }
+.eps__titre { font-weight: var(--fw-medium); color: var(--text); }
+a.eps__titre { color: var(--nav-primary-solid); }
+.eps__personnes,
+.eps__note { color: color-mix(in srgb, var(--text) 78%, transparent); font-size: var(--fs-xs, 0.75rem); }
+.eps__note { font-style: italic; }
+.eps__item--muet .eps__titre { color: color-mix(in srgb, var(--text) 78%, transparent); }
+</style>

components/SimulateurFeature.vue

@@ -14,6 +14,7 @@
             <span v-if="tag" :class="['simu-feature__badge', `simu-feature__badge--${tag}`]">{{ tagLabel }}</span>
           </div>
           <p class="simu-feature__desc">{{ description }}</p>
+          <p v-if="mention" class="simu-feature__mention">{{ mention }}</p>
         </div>
       </div>
       <span v-if="cta && url" class="simu-feature__cta">{{ cta }}</span>
@@ -29,6 +30,8 @@ const props = defineProps<{
   description?: string
   cta?: string
   tag?: string
+  /** Ligne de réserve datée sous la description (ex. « Ordre de grandeur — version du … »). */
+  mention?: string | null
 }>()
 
 const tagLabels: Record<string, string> = {
@@ -127,6 +130,13 @@ const tagLabel = computed(() => props.tag ? (tagLabels[props.tag] ?? props.tag)
   line-height: 1.55;
 }
 
+.simu-feature__mention {
+  font-size: 0.78rem;
+  font-style: italic;
+  color: color-mix(in srgb, var(--text) 78%, transparent);
+  margin: 0.4rem 0 0;
+}
+
 .simu-feature__cta {
   display: inline-flex;
   align-items: center;
@@ -145,6 +155,12 @@ const tagLabel = computed(() => props.tag ? (tagLabels[props.tag] ?? props.tag)
   opacity: 0.88;
 }
 
+@media (max-width: 640px) {
+  .simu-feature { padding: 1.1rem 1rem; }
+  .simu-feature__inner { flex-direction: column; align-items: stretch; gap: 1rem; }
+  .simu-feature__cta { justify-content: center; }
+}
+
 :global(.dark) .simu-feature__badge {
   background: #064e3b;
   color: #a7f3d0;

components/VueFiches.vue

@@ -23,7 +23,7 @@
           :class="`vf-seg__btn--${e}`"
           :aria-pressed="vf.vueAffichee === e"
           @click="vf.setVue(e)"
-        >{{ LIBELLES_VUE[e] }}<span v-if="e === 'fiches'" class="vf-seg__n"> · {{ vf.resultat.length }}</span></button>
+        >{{ libellesVue?.[e] ?? LIBELLES_VUE[e] }}<span v-if="e === 'fiches'" class="vf-seg__n"> · {{ vf.resultat.length }}</span></button>
       </div>
 
       <label class="vf-recherche">
@@ -79,7 +79,7 @@
       <label class="vf-select vf-select--tri">
         <span>Tri</span>
         <select :value="vf.tri" @change="vf.setTri(($event.target as HTMLSelectElement).value as TriFiches)">
-          <option v-for="t in vf.cfg.tris" :key="t" :value="t" :selected="t === vf.tri">{{ LIBELLES_TRI[t] }}</option>
+          <option v-for="t in vf.cfg.tris" :key="t" :value="t" :selected="t === vf.tri">{{ vf.cfg.libellesTri?.[t] ?? LIBELLES_TRI[t] }}</option>
         </select>
       </label>
 
@@ -248,7 +248,7 @@
           <template v-if="vf.ficheOuverte">
             <div class="vf-detail__actions">
               <a v-if="lienPageFiche" :href="lienPageFiche" class="vf-lien">Ouvrir la page de la fiche</a>
-              <button v-if="peutCentrer" type="button" class="vf-lien" @click="vf.voirSurCarte(vf.ficheOuverte.id)">Voir sur la carte</button>
+              <button v-if="peutCentrer" type="button" class="vf-lien" @click="vf.voirSurCarte(vf.ficheOuverte.id)">{{ libelleVoirCarte }}</button>
               <button type="button" class="vf-lien" @click="copierLien">Copier le lien</button>
               <span class="vf-detail__statut" role="status">{{ statutLien }}</span>
             </div>
@@ -311,6 +311,8 @@ const props = defineProps<{
   selectedId?: string | number | null
   /** Page propre de la fiche (`/fiche/:id` pour l'Entraide) ; null = pas de page, le lien partagé est l'URL avec `fiche=`. */
   lienPage?: (f: MiniFiche) => string | null
+  /** Libellés des trois états quand « Carte » n'est pas le mot juste (ex. { carte: 'Graphe' }). Le paramètre d'URL reste `vue=carte`. */
+  libellesVue?: Partial<Record<EtatVue, string>>
 }>()
 
 const emit = defineEmits<{
@@ -319,6 +321,8 @@ const emit = defineEmits<{
 }>()
 
 const LIBELLES_VUE: Record<EtatVue, string> = { carte: 'Carte', mixte: 'Mixte', fiches: 'Fiches' }
+/** « Voir sur la carte » suit le mot choisi pour l'état Carte : « Voir dans le graphe ». */
+const libelleVoirCarte = computed(() => (props.libellesVue?.carte ? `Voir dans le ${props.libellesVue.carte.toLowerCase()}` : 'Voir sur la carte'))
 const etatsBoutons = computed(() => (['carte', 'mixte', 'fiches'] as EtatVue[]).filter((e) => props.vf.cfg.etats.includes(e)))
 
 // ── Pastilles actives (état Carte, et téléphone en Fiches) ──

composables/useFicheAdapter.ts

@@ -27,7 +27,7 @@ export interface MiniFiche {
   chipsDimension?: string
   echelle?: string
   geoloc: boolean
-  kind: 'org' | 'structure'
+  kind: 'org' | 'structure' | 'mot'
   /** Étiquettes complètes par dimension (valeurs telles qu'écrites dans l'URL). */
   etiquettes?: Record<string, string[]>
   coords?: [number, number]
@@ -134,6 +134,65 @@ export function toMini(source: Org | StructureV2): MiniFiche {
   }
 }
 
+// ── Partir de soi (B6-M2) : un mot de la slide 17 = une fiche ─────────────
+
+/** Une fiche de `public/data/outils.json` → `partir_de_soi.fiches[]`. */
+export interface FicheMot {
+  id: string
+  mot: string
+  resume: string
+  vide?: string | null
+}
+
+/** Une ressource de `partir_de_soi.ressources[]`, reliée à ses mots par `fiches`. */
+export interface RessourceMot {
+  id: string
+  titre: string
+  format: string
+  acces: string
+  pourquoi?: string
+  fiches: string[]
+}
+
+/** « don libre » → `don-libre` : la forme d'une valeur de filtre dans l'URL (`acces=don-libre`). */
+export function slugEtiquette(s: string): string {
+  return s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
+}
+
+/** Valeurs distinctes d'un champ des ressources, dans l'ordre de première apparition (ordre stable des chips). */
+export function valeursRessources(ressources: RessourceMot[], champ: 'format' | 'acces'): { valeur: string; libelle: string }[] {
+  const vus = new Map<string, string>()
+  for (const r of ressources) {
+    const l = r[champ]
+    if (l && !vus.has(slugEtiquette(l))) vus.set(slugEtiquette(l), l)
+  }
+  return [...vus].map(([valeur, libelle]) => ({ valeur, libelle }))
+}
+
+/**
+ * Un mot de la conférence → `MiniFiche`. `ressources` = celles qui portent ce mot.
+ * Pas de carte géographique : `geoloc: true` (aucune fiche « sans adresse »).
+ * La recherche couvre aussi les titres et les « pourquoi » des ressources.
+ */
+export function toMiniMot(fiche: FicheMot, ressources: RessourceMot[]): MiniFiche {
+  const formats = [...new Set(ressources.map((r) => r.format).filter(Boolean))]
+  const acces = [...new Set(ressources.map((r) => r.acces).filter(Boolean))]
+  return {
+    id: fiche.id,
+    nom: fiche.mot,
+    resume: buildResume([fiche.resume, fiche.vide]),
+    chips: formats.slice(0, 3),
+    chipsDimension: 'format',
+    geoloc: true,
+    kind: 'mot',
+    etiquettes: {
+      format: formats.map(slugEtiquette),
+      acces: acces.map(slugEtiquette),
+    },
+    texte: [fiche.resume, ...ressources.flatMap((r) => [r.titre, r.pourquoi])].filter(Boolean).join(' '),
+  }
+}
+
 export function useFicheAdapter() {
-  return { toMini }
+  return { toMini, toMiniMot }
 }

public/data/fmhy-curated.json

@@ -1,6 +1,6 @@
 {
   "name": "FMHY — Sélection Architecte",
-  "description": "~50 ressources curées depuis FMHY (Free Media Heck Yeah) — pertinentes pour un architecte, un praticien de la transition, un créateur solo.",
+  "description": "Une quarantaine de ressources légales curées depuis FMHY (Free Media Heck Yeah) — pertinentes pour un architecte, un praticien de la transition, un créateur solo.",
   "children": [
     {
       "name": "IA & Outils cognitifs",
@@ -16,10 +16,6 @@
     {
       "name": "Lecture & Documentation",
       "children": [
-        { "name": "Anna's Archive", "url": "https://annas-archive.org/", "desc": "Bibliothèque shadow la plus complète du web. Livres, articles, thèses." },
-        { "name": "Sci-Hub", "url": "https://sci-hub.se/", "desc": "Accès libre aux articles scientifiques payants." },
-        { "name": "Library Genesis", "url": "https://libgen.is/", "desc": "Livres techniques et académiques en PDF." },
-        { "name": "Z-Library", "url": "https://z-lib.id/", "desc": "Bibliothèque numérique massive, interface soignée." },
         { "name": "OpenLibrary (Internet Archive)", "url": "https://openlibrary.org/", "desc": "Prêt numérique gratuit, millions de livres." },
         { "name": "Calibre", "url": "https://calibre-ebook.com/", "desc": "Gestion de bibliothèque numérique, convertisseur de formats." }
       ]
@@ -27,12 +23,7 @@
     {
       "name": "Dessin & Modélisation",
       "children": [
-        { "name": "FreeCAD", "url": "https://www.freecad.org/", "desc": "Modélisation 3D open source, paramétrique. Alternative à Rhino pour usage simple." },
+        { "name": "Krita", "url": "https://krita.org/", "desc": "Dessin digital et croquis. Excellent pour les concepts." }
-        { "name": "Blender", "url": "https://www.blender.org/", "desc": "3D, rendu, animation. La référence open source." },
-        { "name": "Inkscape", "url": "https://inkscape.org/", "desc": "Dessin vectoriel. Alternative à Illustrator." },
-        { "name": "GIMP", "url": "https://www.gimp.org/", "desc": "Retouche photo. Alternative à Photoshop." },
-        { "name": "Krita", "url": "https://krita.org/", "desc": "Dessin digital et croquis. Excellent pour les concepts." },
-        { "name": "LibreOffice Draw", "url": "https://www.libreoffice.org/", "desc": "Diagrammes, plans rapides, sans suite Adobe." }
       ]
     },
     {
@@ -92,7 +83,6 @@
       "name": "Divers Utiles",
       "children": [
         { "name": "Nextcloud", "url": "https://nextcloud.com/", "desc": "Cloud personnel self-hosted. Alternative à Google Drive/Dropbox." },
-        { "name": "Joplin", "url": "https://joplinapp.org/", "desc": "Notes chiffrées, sync Nextcloud, open source." },
         { "name": "draw.io / diagrams.net", "url": "https://app.diagrams.net/", "desc": "Diagrammes et schémas, gratuit, pas de compte requis." },
         { "name": "Excalidraw", "url": "https://excalidraw.com/", "desc": "Tableau blanc collaboratif, style hand-drawn, open source." },
         { "name": "Fmhy.net (complet)", "url": "https://fmhy.net/", "desc": "L'arbre complet. Des milliers de ressources organisées par thème." }

scripts/check-liens-outils.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+/**
+ * Contrôle des liens de /outils (B6-M4) — outil de revue, PAS un test : ne fait jamais échouer le build.
+ * Lit public/data/outils.json (toutes les URL, y compris `urls[]` et `episodes[].url`) et
+ * public/data/fmhy-curated.json, fait un GET (redirections suivies, délai 15 s, 4 requêtes en parallèle)
+ * et liste les réponses hors 2xx/3xx.
+ *
+ * Un 403/429 d'un site qui bloque les robots n'est pas un lien mort : lire la liste avant de retirer quoi que ce soit.
+ * Usage : node scripts/check-liens-outils.mjs
+ */
+
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const lire = (nom) => JSON.parse(readFileSync(join(__dirname, '..', 'public', 'data', nom), 'utf8'))
+
+const DELAI_MS = 15000
+const PARALLELE = 4
+const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36'
+
+/** url -> Set des entrées qui la portent. Toute chaîne https:// est prise, quel que soit son champ. */
+const urls = new Map()
+function ajoute(url, qui) {
+  if (!urls.has(url)) urls.set(url, new Set())
+  urls.get(url).add(qui)
+}
+
+/** Titre lisible de l'entrée courante : nom / titre / mot, sinon l'id. */
+const titreDe = (o) => o.nom ?? o.titre ?? o.name ?? o.mot ?? o.id
+
+function parcourt(valeur, fichier, contexte) {
+  if (typeof valeur === 'string') {
+    if (/^https:\/\//i.test(valeur) || /^http:\/\//i.test(valeur)) ajoute(valeur, `${fichier} › ${contexte}`)
+  } else if (Array.isArray(valeur)) {
+    for (const v of valeur) parcourt(v, fichier, contexte)
+  } else if (valeur && typeof valeur === 'object') {
+    // `lien_texte`-like chaînes ne commencent pas par https:// : seules les vraies URL sont retenues.
+    const ctx = titreDe(valeur) ? `${contexte ? contexte + ' › ' : ''}${titreDe(valeur)}` : contexte
+    for (const [, v] of Object.entries(valeur)) parcourt(v, fichier, ctx)
+  }
+}
+
+parcourt(lire('outils.json'), 'outils.json', '')
+parcourt(lire('fmhy-curated.json'), 'fmhy-curated.json', '')
+
+async function verifie(url) {
+  const ctrl = new AbortController()
+  const minuteur = setTimeout(() => ctrl.abort(), DELAI_MS)
+  try {
+    const r = await fetch(url, {
+      method: 'GET',
+      redirect: 'follow',
+      signal: ctrl.signal,
+      headers: { 'user-agent': UA, accept: 'text/html,application/xhtml+xml,*/*;q=0.8', 'accept-language': 'fr-FR,fr;q=0.9,en;q=0.7' },
+    })
+    r.body?.cancel().catch(() => {})
+    return r.status
+  } catch (e) {
+    return e?.name === 'AbortError' ? 'délai' : `erreur (${e?.cause?.code ?? e?.message ?? 'réseau'})`
+  } finally {
+    clearTimeout(minuteur)
+  }
+}
+
+const liste = [...urls.keys()]
+const resultats = new Map()
+let curseur = 0
+async function travailleur() {
+  while (curseur < liste.length) {
+    const url = liste[curseur++]
+    resultats.set(url, await verifie(url))
+  }
+}
+await Promise.all(Array.from({ length: PARALLELE }, travailleur))
+
+const ko = liste.filter((u) => {
+  const c = resultats.get(u)
+  return !(typeof c === 'number' && c >= 200 && c < 400)
+})
+
+console.log(`Contrôle de ${liste.length} URL (GET, délai ${DELAI_MS / 1000} s, ${PARALLELE} en parallèle)\n`)
+if (ko.length) {
+  console.log('code'.padEnd(18) + 'URL  ·  entrée')
+  for (const u of ko) {
+    console.log(String(resultats.get(u)).padEnd(18) + `${u}  ·  ${[...urls.get(u)].join(' | ')}`)
+  }
+}
+console.log(`\n${ko.length} réponse(s) hors 2xx/3xx sur ${liste.length} URL.`)
+// Outil de revue : toujours code de sortie 0.

scripts/test-outils-data.mjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+/**
+ * Test des données de /outils (B6-M1).
+ * Garde-fou pour les ajouts futurs (à la main, par M3, ou par un pipe n8n) :
+ * fiches de l'onglet « Partir de soi », ressources, purge des liens litigieux, URL en https.
+ * Charge le VRAI utils/echelles.ts via jiti (même patron que test-echelles-nav.mjs).
+ * Usage : node scripts/test-outils-data.mjs
+ */
+
+import { createJiti } from 'jiti'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const jiti = createJiti(import.meta.url)
+const { ECHELLES } = await jiti.import(join(__dirname, '..', 'utils', 'echelles.ts'))
+
+const lire = (nom) => JSON.parse(readFileSync(join(__dirname, '..', 'public', 'data', nom), 'utf8'))
+const outils = lire('outils.json')
+const fmhy = lire('fmhy-curated.json')
+
+const LISTE_NOIRE = [
+  'annas-archive', 'z-lib', 'libgen', 'sci-hub', 'mobilism', 'zone-ebook', 'rivestream', 'cineby',
+  'flixer', 'miruro', 'monochrome.tf', 'lucida', 'spotx', 'fitgirl', 'steamrip', '1337x',
+]
+const FORMATS = ['film', 'vidéo', 'podcast', 'guide PDF', 'livret PDF', 'appli', 'retraite', 'atelier', 'formation', 'association', 'fiches', 'événement', 'récit']
+const ACCES = ['libre', 'don libre', 'gratuit avec inscription', 'prix libre', 'financé selon région']
+const SOURCES = ['inventaire S 27/09', 'outils.json (avant B6)']
+
+let n = 0
+const echecs = []
+function verifie(ok, message) {
+  n++
+  if (!ok) echecs.push(message)
+}
+
+/** Parcourt un JSON à tous les niveaux : (chemin, clé, valeur) pour chaque chaîne. */
+function chaines(valeur, chemin, visiteur) {
+  if (typeof valeur === 'string') visiteur(chemin, valeur)
+  else if (Array.isArray(valeur)) valeur.forEach((v, i) => chaines(v, `${chemin}[${i}]`, visiteur))
+  else if (valeur && typeof valeur === 'object') for (const [k, v] of Object.entries(valeur)) chaines(v, `${chemin}.${k}`, visiteur)
+}
+
+// ── Fiches ────────────────────────────────────────────────────
+const p = outils.partir_de_soi
+const fiches = p?.fiches ?? []
+const mots = ECHELLES.S.mots
+verifie(outils.version === 2, 'version doit valoir 2')
+verifie(fiches.length === 7, `7 fiches attendues, ${fiches.length} trouvées`)
+verifie(new Set(fiches.map((f) => f.id)).size === fiches.length, 'ids de fiches non uniques')
+verifie(
+  JSON.stringify(fiches.map((f) => f.mot)) === JSON.stringify(mots),
+  `mots des fiches ≠ ECHELLES.S.mots (dans l'ordre) : ${JSON.stringify(fiches.map((f) => f.mot))}`,
+)
+const idsFiches = new Set(fiches.map((f) => f.id))
+
+// ── Ressources ────────────────────────────────────────────────
+const ressources = p?.ressources ?? []
+const idsRes = new Set()
+const DATE = /^\d{4}-\d{2}-\d{2}$/
+for (const r of ressources) {
+  const nom = `ressource « ${r.id ?? r.titre ?? '?'} »`
+  verifie(typeof r.id === 'string' && r.id && !idsRes.has(r.id), `${nom} : id manquant ou en double`)
+  idsRes.add(r.id)
+  verifie(typeof r.titre === 'string' && r.titre, `${nom} : titre manquant`)
+  verifie(FORMATS.includes(r.format), `${nom} : format « ${r.format} » hors liste`)
+  verifie(ACCES.includes(r.acces), `${nom} : accès « ${r.acces} » hors liste`)
+  verifie(typeof r.pourquoi === 'string' && r.pourquoi, `${nom} : pourquoi manquant`)
+  verifie(Array.isArray(r.fiches) && r.fiches.length > 0, `${nom} : fiches vide`)
+  verifie((r.fiches ?? []).every((id) => idsFiches.has(id)), `${nom} : fiche inconnue dans ${JSON.stringify(r.fiches)}`)
+  verifie(SOURCES.includes(r.source), `${nom} : source « ${r.source} » hors liste`)
+  verifie(['socle', 'actualite'].includes(r.couche), `${nom} : couche « ${r.couche} »`)
+  verifie(['vivant', 'dormant', 'archive'].includes(r.statut), `${nom} : statut « ${r.statut} »`)
+  verifie(DATE.test(r.verifie_le ?? ''), `${nom} : verifie_le « ${r.verifie_le} » n'est pas AAAA-MM-JJ`)
+}
+
+// ── Fiche vide ⇔ sans ressource ───────────────────────────────
+for (const f of fiches) {
+  const nb = ressources.filter((r) => r.fiches?.includes(f.id)).length
+  if (nb === 0) verifie(typeof f.vide === 'string' && f.vide, `fiche « ${f.id} » sans ressource : \`vide\` doit être renseigné`)
+  else verifie(f.vide == null, `fiche « ${f.id} » a ${nb} ressource(s) : \`vide\` doit être nul`)
+}
+
+// ── URL : https partout, rien de la liste noire ───────────────
+for (const [fichier, donnees] of [['outils.json', outils], ['fmhy-curated.json', fmhy]]) {
+  chaines(donnees, fichier, (chemin, s) => {
+    const cle = chemin.split('.').pop().replace(/\[\d+\]$/, '')
+    const estUrl = /^https?:\/\//i.test(s) || ['url', 'urls', 'lien', 'avertissement_lien'].includes(cle)
+    // `lien` de contribution est un chemin interne (/proposer…) : seul le préfixe http est contrôlé.
+    if (/^https?:\/\//i.test(s)) {
+      verifie(s.startsWith('https://'), `${chemin} : URL non https (${s})`)
+      const bas = s.toLowerCase()
+      const hit = LISTE_NOIRE.find((d) => bas.includes(d))
+      verifie(!hit, `${chemin} : domaine de la liste noire « ${hit} » (${s})`)
+    } else if (estUrl && cle !== 'lien' && s) {
+      verifie(false, `${chemin} : URL sans https (${s})`)
+    }
+  })
+}
+
+// Liste noire aussi dans les noms/titres (un lien retiré ne doit pas survivre en texte).
+chaines({ outils, fmhy }, 'données', (chemin, s) => {
+  const bas = s.toLowerCase()
+  verifie(!bas.includes('tantra'), `${chemin} : contient « tantra »`)
+  verifie(!bas.includes('the nest'), `${chemin} : contient « The Nest »`)
+  const hit = ['sci-hub', 'z-library', 'library genesis', "anna's archive", 'fitgirl', 'steamrip', '1337x'].find((d) => bas.includes(d))
+  verifie(!hit, `${chemin} : contient « ${hit} »`)
+})
+
+// ── Structure minimale des autres blocs ───────────────────────
+verifie(Array.isArray(outils.conception?.outils) && outils.conception.outils.length > 0, 'conception.outils vide')
+verifie(
+  (outils.conception?.outils ?? []).every((o) => o.mention && DATE.test(o.verifie_le ?? '')),
+  'conception.outils : `mention` et `verifie_le` obligatoires',
+)
+verifie(Array.isArray(outils.open_source?.rubriques) && outils.open_source.rubriques.every((r) => r.liens?.length > 0), 'open_source.rubriques : une rubrique vide doit disparaître')
+verifie(!!outils.contribution?.texte && !!outils.contribution?.lien && !!outils.contribution?.cta, 'contribution incomplète')
+
+// ── Open source : sélection (B6-M4) ───────────────────────────
+// Chaque lien de la sélection est vérifié par une personne (licence, date) ; la liste noire
+// piraterie s'applique déjà à toute chaîne d'outils.json (voir plus haut), sélection comprise.
+const sel = outils.open_source?.selection
+verifie(!!sel && typeof sel.intention === 'string' && sel.intention, 'open_source.selection : intention manquante')
+verifie(Array.isArray(sel?.rubriques) && sel.rubriques.length >= 1, 'open_source.selection : au moins une rubrique attendue')
+const idsRub = new Set()
+for (const r of sel?.rubriques ?? []) {
+  const rub = `sélection « ${r.id ?? r.titre ?? '?'} »`
+  verifie(typeof r.id === 'string' && r.id && !idsRub.has(r.id), `${rub} : id manquant ou en double`)
+  idsRub.add(r.id)
+  verifie(typeof r.titre === 'string' && r.titre, `${rub} : titre manquant`)
+  verifie(Array.isArray(r.liens) && r.liens.length > 0, `${rub} : rubrique vide`)
+  for (const l of r.liens ?? []) {
+    const nom = `${rub} › ${l.nom ?? '?'}`
+    verifie(typeof l.nom === 'string' && l.nom, `${nom} : nom manquant`)
+    verifie(typeof l.url === 'string' && l.url.startsWith('https://'), `${nom} : url https manquante (${l.url})`)
+    verifie(typeof l.desc === 'string' && l.desc, `${nom} : desc manquante`)
+    verifie(typeof l.licence === 'string' && l.licence, `${nom} : licence manquante`)
+    verifie(DATE.test(l.verifie_le ?? ''), `${nom} : verifie_le « ${l.verifie_le} » n'est pas AAAA-MM-JJ`)
+    const bas = (l.url ?? '').toLowerCase()
+    const hit = LISTE_NOIRE.find((d) => bas.includes(d))
+    verifie(!hit, `${nom} : domaine de la liste noire « ${hit} »`)
+  }
+}
+
+// Aucun doublon d'URL dans tout open_source (sélection + recommandés + rubriques fmhy), à la barre finale et à la casse près.
+const norm = (u) => u.toLowerCase().replace(/^https?:\/\//, '').replace(/^www\./, '').replace(/\/+$/, '')
+const vues = new Map()
+const urlsOS = [
+  ...(sel?.rubriques ?? []).flatMap((r) => (r.liens ?? []).map((l) => [`sélection › ${l.nom}`, l.url])),
+  ...(outils.open_source?.recommandes ?? []).filter((o) => o.url).map((o) => [`recommandé › ${o.titre}`, o.url]),
+  ...(outils.open_source?.rubriques ?? []).flatMap((r) => (r.liens ?? []).map((l) => [`fmhy › ${l.nom}`, l.url])),
+]
+for (const [qui, url] of urlsOS) {
+  const k = norm(url)
+  verifie(!vues.has(k), `open_source : URL en double « ${url} » (${vues.get(k)} et ${qui})`)
+  vues.set(k, qui)
+}
+
+if (echecs.length) {
+  for (const e of echecs) console.log(`FAIL ${e}`)
+  console.log(`\n${n - echecs.length}/${n} vérifications OK — ${echecs.length} échec(s)`)
+  process.exit(1)
+}
+console.log(`${n} vérifications OK`)

scripts/test-vue-fiches.mjs

@@ -186,5 +186,62 @@ nav = navigateur(qListe)
 nav.ouvrir(1); nav.filtrer({ ...nav.cur(), echelle: 'National' }); nav.fermer()
 ok(nav.cur().echelle === 'National' && V.lireFiche(nav.cur()) === null, 'filtre changé fiche ouverte : fermer garde le nouveau filtre (pas de retour arrière)')
 
+// ── Partir de soi : sept mots, ordre de la slide (B6-M2) ──
+const MOTS = [
+  { id: 'quete-de-sens', mot: 'quête de sens', resume: 'Bifurquer, donner du sens à son métier.' },
+  { id: 'gagner-sa-vie', mot: 'gagner sa vie', resume: 'Créer son activité et en vivre.', vide: 'Rien encore.' },
+  { id: 'sante-mentale', mot: 'santé mentale', resume: 'Repérer, comprendre, se faire accompagner.' },
+  { id: 'naviguer-avec-soi', mot: 'naviguer avec soi', resume: 'Méditation et pratiques d’introspection.' },
+]
+const RESS = [
+  { id: 'film', titre: 'En quête de sens', format: 'film', acces: 'don libre', pourquoi: 'Le film nommé dans le deck.', fiches: ['quete-de-sens'] },
+  { id: 'ofqa', titre: 'OFQA', format: 'vidéo', acces: 'libre', pourquoi: 'Diplômés qui ont bifurqué.', fiches: ['quete-de-sens'] },
+  { id: 'psc', titre: 'Premiers secours en santé mentale', format: 'formation', acces: 'financé selon région', pourquoi: 'Repérer les signes.', fiches: ['sante-mentale'] },
+  { id: 'vipassana', titre: 'Vipassana', format: 'retraite', acces: 'don libre', pourquoi: 'Dix jours de silence.', fiches: ['naviguer-avec-soi'] },
+  { id: 'insight', titre: 'Insight Timer', format: 'appli', acces: 'gratuit avec inscription', pourquoi: 'Méditations guidées.', fiches: ['naviguer-avec-soi', 'sante-mentale'] },
+]
+const parMot = (id) => RESS.filter((r) => r.fiches.includes(id))
+const mots = MOTS.map((m) => A.toMiniMot(m, parMot(m.id)))
+const cfgMots = {
+  dimensions: [
+    { cle: 'format', libelle: 'Format', variante: 'fonction', valeurs: A.valeursRessources(RESS, 'format') },
+    { cle: 'acces', libelle: 'Accès', variante: 'echelle', valeurs: A.valeursRessources(RESS, 'acces') },
+  ],
+  tris: ['ordre', 'pertinence', 'nom'],
+  triDefaut: 'ordre',
+  libellesTri: { ordre: 'Ordre de la slide' },
+  groupes: [],
+  etats: ['carte', 'mixte', 'fiches'],
+}
+const etatM = (query = {}, over = {}) => ({ ...V.lireQuery(query, cfgMots), ...over })
+const sansDefaut = { ...cfgMots, triDefaut: undefined, tris: ['pertinence', 'nom'] }
+
+ok(mots[0].kind === 'mot' && mots[0].nom === 'quête de sens' && eq(mots[0].chips, ['film', 'vidéo']) && mots[0].chipsDimension === 'format' && mots[0].geoloc === true, 'mot → kind mot, nom = le mot, chips = formats, geoloc true (pas de carte géographique)')
+ok(eq(mots[0].etiquettes, { format: ['film', 'video'], acces: ['don-libre', 'libre'] }), 'mot → étiquettes en slug (sans accent, sans espace) pour l’URL', JSON.stringify(mots[0].etiquettes))
+ok(eq(mots[3].etiquettes.acces, ['don-libre', 'gratuit-avec-inscription']) && mots[3].chips.length === 2, 'mot → union des formats et des accès de ses ressources')
+ok(mots[1].resume === 'Créer son activité et en vivre.' && eq(mots[1].etiquettes, { format: [], acces: [] }), 'mot sans ressource (gagner sa vie) → résumé gardé, aucune étiquette')
+ok(A.toMiniMot({ id: 'x', mot: 'x', resume: '', vide: 'Rien encore. Propose.' }, []).resume === 'Rien encore.', 'mot sans résumé → texte « vide » (première phrase)')
+ok(eq(A.valeursRessources(RESS, 'acces').map((v) => v.libelle), ['don libre', 'libre', 'financé selon région', 'gratuit avec inscription']) && A.slugEtiquette('financé selon région') === 'finance-selon-region', 'valeurs de dimension : libellé lisible, valeur en slug, ordre de première apparition')
+const idsM = (q, tri) => ids(V.trierFiches(V.filtrerFiches(mots, etatM(q), cfgMots), tri ?? V.triEffectif(etatM(q), cfgMots), etatM(q)))
+ok(eq(idsM({}), ['quete-de-sens', 'gagner-sa-vie', 'sante-mentale', 'naviguer-avec-soi']), 'tri ordre : l’ordre du tableau d’entrée, pas A → Z')
+ok(eq(ids(V.trierFiches([...mots].reverse(), 'ordre', etatM())), ['naviguer-avec-soi', 'sante-mentale', 'gagner-sa-vie', 'quete-de-sens']), 'tri ordre : stable, suit l’entrée quelle qu’elle soit')
+ok(V.triEffectif(etatM(), cfgMots) === 'ordre', 'triDefaut respecté sans filtre')
+ok(V.triEffectif(etatM({ q: 'vipassana' }), cfgMots) === 'ordre', 'triDefaut respecté avec une recherche seule (pas de filtre d’étiquette)')
+ok(V.triEffectif(etatM({ acces: 'don-libre' }), cfgMots) === 'pertinence', 'pertinence prioritaire dès qu’un filtre est actif, même avec triDefaut')
+ok(V.triEffectif(etatM({ acces: 'don-libre', tri: 'ordre' }), cfgMots) === 'ordre', 'tri explicite (tri=ordre dans l’URL) prioritaire')
+ok(V.lireQuery({ tri: 'ordre' }, cfgMots).tri === 'ordre', 'tri=ordre lu dans l’URL quand la page l’offre')
+ok(V.lireQuery({ tri: 'ordre' }, cfg).tri === null && V.lireQuery({ tri: 'ordre' }, sansDefaut).tri === null, 'tri=ordre ignoré quand la page ne l’offre pas (/ et /agences)')
+ok(V.triEffectif(etatM(), sansDefaut) === 'nom' && V.triEffectif(etat0(), cfg) === 'nom', 'sans triDefaut : comportement inchangé (nom)')
+ok(V.triEffectif(etatM(), { ...cfgMots, triDefaut: 'recent' }) === 'nom', 'triDefaut absent de tris → ignoré')
+ok(eq(idsM({ acces: 'don-libre' }), ['naviguer-avec-soi', 'quete-de-sens']), 'filtre Accès « don libre » : pertinence (ex æquo → A → Z), pas l’ordre de la slide', JSON.stringify(idsM({ acces: 'don-libre' })))
+ok(eq(idsM({ q: 'vipassana' }), ['naviguer-avec-soi']), 'recherche « Vipassana » (titre d’une ressource) → le mot « naviguer avec soi »')
+ok(eq(idsM({ q: 'VIPASSANA' }), ['naviguer-avec-soi']) && eq(idsM({ q: 'quete' }), ['quete-de-sens']), 'recherche insensible à la casse et aux accents')
+const cm = V.compterEtiquettes(mots, etatM({ acces: 'don-libre' }), cfgMots)
+ok(cm.format.film === 1 && cm.format.retraite === 1 && cm.format.formation === 0 && cm.acces['don-libre'] === 2 && cm.acces.libre === 1, 'compteurs : format dans le résultat du filtre Accès, accès dans celui des formats', JSON.stringify(cm))
+const eMot = V.lireQuery({ tab: 'partir-de-soi', acces: 'don-libre', format: 'film,retraite', fiche: 'quete-de-sens' }, cfgMots)
+const qMot = V.ecrireQuery(eMot, cfgMots, { tab: 'partir-de-soi', acces: 'don-libre', fiche: 'quete-de-sens' })
+ok(qMot.tab === 'partir-de-soi' && qMot.fiche === 'quete-de-sens' && qMot.acces === 'don-libre' && qMot.format === 'film,retraite', 'tab= et fiche= survivent à l’écriture des filtres')
+ok(V.queryAvecFiche({ tab: 'partir-de-soi', vue: 'carte' }, 'sante-mentale').tab === 'partir-de-soi' && V.queryAvecFiche({ tab: 'partir-de-soi', fiche: 'x' }, null).tab === 'partir-de-soi', 'tab= survit à l’ouverture et à la fermeture d’une fiche')
+
 console.log(`\n${n - fail}/${n}`)
 process.exit(fail ? 1 : 0)

utils/vueFiches.ts

@@ -10,13 +10,14 @@
 import type { MiniFiche } from '../composables/useFicheAdapter'
 
 export type EtatVue = 'carte' | 'mixte' | 'fiches'
-export type TriFiches = 'pertinence' | 'nom' | 'recent'
+export type TriFiches = 'pertinence' | 'nom' | 'recent' | 'ordre'
 
 export const ETATS_VUE: EtatVue[] = ['carte', 'mixte', 'fiches']
 export const LIBELLES_TRI: Record<TriFiches, string> = {
   pertinence: 'Pertinence',
   nom: 'A → Z',
   recent: 'Récentes',
+  ordre: 'Ordre d’origine',
 }
 
 export interface ValeurFiltre {
@@ -57,6 +58,10 @@ export interface ConfigVueFiches {
   groupes: GroupeDef[]
   etats: EtatVue[]
   sousVues?: SousVuesCarte
+  /** Tri sans filtre actif (défaut : `nom`). Doit figurer dans `tris`. */
+  triDefaut?: TriFiches
+  /** Libellés de tri propres à la page (sinon `LIBELLES_TRI`). */
+  libellesTri?: Partial<Record<TriFiches, string>>
 }
 
 export interface EtatFiches {
@@ -227,6 +232,7 @@ export function triEffectif(etat: EtatFiches, cfg: ConfigVueFiches): TriFiches {
   if (etat.tri) return etat.tri
   const filtreEtiquette = Object.values(etat.filtres).some((v) => v.length > 0)
   if (filtreEtiquette && cfg.tris.includes('pertinence')) return 'pertinence'
+  if (cfg.triDefaut && cfg.tris.includes(cfg.triDefaut)) return cfg.triDefaut
   return cfg.tris.includes('nom') ? 'nom' : cfg.tris[0] ?? 'nom'
 }
 
@@ -250,6 +256,7 @@ function idNum(f: MiniFiche): number {
 
 export function trierFiches(fiches: MiniFiche[], tri: TriFiches, etat: EtatFiches): MiniFiche[] {
   const copie = [...fiches]
+  if (tri === 'ordre') return copie // ordre du tableau d'entrée (déjà filtré, jamais réordonné)
   if (tri === 'nom') return copie.sort(parNom)
   if (tri === 'pertinence') {
     const score = new Map(copie.map((f) => [f, pertinence(f, etat)]))