@indos/bibliotheque 2.4.0 → 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (115) hide show
  1. package/CLAUDE.md +361 -0
  2. package/LICENSE +4 -18
  3. package/README.md +6 -11
  4. package/bin/page-de-l-espace.js +12 -6
  5. package/package.json +16 -13
  6. package/src/app.js +2 -2
  7. package/src/appeler.js +4 -5
  8. package/src/compte.d.ts +222 -8
  9. package/src/compte.js +250 -22
  10. package/src/description-des-comptes.d.ts +16 -0
  11. package/src/direct/page.js +1 -1
  12. package/src/direct.js +1 -1
  13. package/src/ecran.js +2 -2
  14. package/src/espace/apercu.js +10 -23
  15. package/src/espace/cadre.d.ts +3 -5
  16. package/src/espace/cadre.js +29 -31
  17. package/src/espace/chose-seule.d.ts +1 -4
  18. package/src/espace/chose-seule.js +7 -16
  19. package/src/espace/choses.d.ts +9 -5
  20. package/src/espace/choses.js +9 -4
  21. package/src/espace/comptes.js +146 -103
  22. package/src/espace/coquille.d.ts +5 -5
  23. package/src/espace/coquille.js +93 -63
  24. package/src/espace/doubles-de-jsdom.js +11 -4
  25. package/src/espace/ecran-d-une-chose.js +10 -9
  26. package/src/espace/ecran.js +1 -2
  27. package/src/espace/edition-de-la-barre.js +35 -11
  28. package/src/espace/essai.js +4 -4
  29. package/src/espace/fenetre-du-don.d.ts +11 -0
  30. package/src/espace/fenetre-du-don.js +41 -0
  31. package/src/espace/index.d.ts +3 -3
  32. package/src/espace/index.js +3 -3
  33. package/src/espace/liste-des-choses.js +28 -24
  34. package/src/espace/menu-d-une-chose.js +15 -51
  35. package/src/espace/ouvrir.d.ts +3 -3
  36. package/src/espace/ouvrir.js +15 -14
  37. package/src/espace/panneau-du-partage.d.ts +8 -3
  38. package/src/espace/panneau-du-partage.js +36 -14
  39. package/src/espace/routes-des-choses.js +6 -5
  40. package/src/espace/session.d.ts +1 -0
  41. package/src/faux-core.d.ts +15 -3
  42. package/src/faux-core.js +71 -3
  43. package/src/fichiers.d.ts +2 -0
  44. package/src/fichiers.js +6 -4
  45. package/src/flux.js +1 -1
  46. package/src/format.d.ts +3 -0
  47. package/src/format.js +20 -1
  48. package/src/forme-du-direct.js +1 -1
  49. package/src/jeton.js +2 -2
  50. package/src/liens.js +1 -1
  51. package/src/mcp.js +3 -3
  52. package/src/notifier.d.ts +10 -0
  53. package/src/notifier.js +47 -0
  54. package/src/page.d.ts +17 -0
  55. package/src/page.js +139 -14
  56. package/src/partage.d.ts +5 -1
  57. package/src/partage.js +61 -16
  58. package/src/presence.js +1 -1
  59. package/src/sans-accents.js +1 -1
  60. package/src/session.js +4 -4
  61. package/src/theme.js +1 -1
  62. package/src/ui/blocs.d.ts +5 -2
  63. package/src/ui/blocs.js +11 -6
  64. package/src/ui/choix.d.ts +2 -1
  65. package/src/ui/choix.js +3 -2
  66. package/src/ui/fenetre.d.ts +8 -3
  67. package/src/ui/fenetre.js +34 -9
  68. package/src/ui/focus.d.ts +2 -0
  69. package/src/ui/focus.js +5 -0
  70. package/src/ui/gestes-du-contenu.d.ts +21 -0
  71. package/src/ui/gestes-du-contenu.js +24 -0
  72. package/src/ui/icones.d.ts +7 -0
  73. package/src/ui/icones.js +12 -1
  74. package/src/ui/index.d.ts +5 -4
  75. package/src/ui/index.js +4 -3
  76. package/src/ui/lien.d.ts +1 -0
  77. package/src/ui/lien.js +2 -2
  78. package/src/ui/menu-d-une-ligne.d.ts +2 -0
  79. package/src/ui/panneau.d.ts +1 -2
  80. package/src/ui/panneau.js +8 -4
  81. package/src/ui/reglages.d.ts +47 -0
  82. package/src/ui/reglages.js +101 -0
  83. package/src/ui/tableau.d.ts +1 -2
  84. package/src/ui/tableau.js +8 -12
  85. package/src/ui/vues.js +1 -1
  86. package/src/vite.d.ts +3 -0
  87. package/src/vite.js +50 -18
  88. package/CHANGELOG.md +0 -295
  89. package/bin/bibliotheque.d.ts +0 -1
  90. package/bin/bibliotheque.js +0 -62
  91. package/modeles/app-du-client/.dockerignore +0 -3
  92. package/modeles/app-du-client/DOCUMENTATION.md +0 -27
  93. package/modeles/app-du-client/Dockerfile +0 -36
  94. package/modeles/app-du-client/README.md +0 -53
  95. package/modeles/app-du-client/USAGE.md +0 -3
  96. package/modeles/app-du-client/espace/ecrans/entrees.tsx +0 -57
  97. package/modeles/app-du-client/espace/index.html +0 -9
  98. package/modeles/app-du-client/espace/page.tsx +0 -6
  99. package/modeles/app-du-client/espace/requetes/entrees.ts +0 -16
  100. package/modeles/app-du-client/espace/routes.ts +0 -12
  101. package/modeles/app-du-client/espace/tsconfig.json +0 -7
  102. package/modeles/app-du-client/gitignore +0 -2
  103. package/modeles/app-du-client/logo.svg +0 -1
  104. package/modeles/app-du-client/migrations/0001-creer-les-entrees.sql +0 -10
  105. package/modeles/app-du-client/module.json +0 -12
  106. package/modeles/app-du-client/package.json +0 -17
  107. package/modeles/app-du-client/src/demarrer.ts +0 -17
  108. package/modeles/app-du-client/src/outils.ts +0 -48
  109. package/modeles/app-du-client/src/serveur.ts +0 -46
  110. package/modeles/app-du-client/tests/espace/entrees.test.tsx +0 -57
  111. package/modeles/app-du-client/tests/serveur.test.ts +0 -119
  112. package/modeles/app-du-client/tests/sources-de-la-page.test.ts +0 -23
  113. package/modeles/app-du-client/tsconfig.json +0 -22
  114. package/src/ui/repli.d.ts +0 -12
  115. package/src/ui/repli.js +0 -6
package/CLAUDE.md ADDED
@@ -0,0 +1,361 @@
1
+ # indos/bibliotheque
2
+
3
+ Le code que les apps partagent, intégré à l'image de chaque app au build, et le contrat d'une app : les règles que toute app suit, que le core, la bibliothèque, le kit ou les tests vérifient. À lire en entier avant d'écrire ou de changer une app.
4
+
5
+ Sa version est celle de la pièce `indos` (`indos/manifeste.json`), publiée sur npm sous `@indos/bibliotheque` ; `indos/CHANGELOG.md` dit ce que chaque version change pour une app. Une app du catalogue, dans `apps/<nom>/` d'ind-os/sources, la cite par un lien de dossier ; une app du client, son propre dépôt cloné dans `code/<nom>/` du dépôt de l'OS, cite le paquet à une version exacte (« Comment une app s'en sert »). La copie d'`indos/` ne se modifie pas.
6
+
7
+ ## Commandes
8
+
9
+ ```sh
10
+ # dans ind-os/sources, depuis indos/bibliotheque/, avant toute app du catalogue
11
+ npm ci
12
+ # depuis la racine du dépôt d'un OS : créer une app du client à partir du modèle
13
+ node indos/bibliotheque/bin/bibliotheque.ts creer-une-app <nom>
14
+ # depuis le dossier de l'app (apps/<nom>/ ou code/<nom>/)
15
+ npm install # la première fois, puis commiter package-lock.json
16
+ npm test # construit la page, vérifie les types, tests de Node puis de la page
17
+ npm run build # la page dans dist/
18
+ npm run dev # la page à chaud sur localhost:5173
19
+ ```
20
+
21
+ ## La forme d'une app
22
+
23
+ Le dossier de l'app porte :
24
+
25
+ - `manifeste.json` :
26
+ - `nom` : celui du dossier, `^[a-z][a-z0-9-]*$`, son chemin `https://<domaine>/<nom>` et son entrée dans `os.json`. Il ne change plus une fois l'app installée.
27
+ - `titre` ; `description`, la phrase de sa carte, pour le dirigeant, sans mot technique ; `famille`, facultative, 1 à 40 caractères ; `version`, `<majeure>.<mineure>.<correctif>`.
28
+ - `dependances` : les bornes npm des pièces, dont le core. `>=1.1` pour appeler une autre app, `>=1.2 <3` pour lire le logo, `>=1.7 <3` pour une app réservée ou qui partage, `>=2.3 <3` pour un logo, une documentation ou des réglages, `>=2.9 <3` pour une app à page. Le kit refuse une montée sur un core plus ancien.
29
+ - `appelle` : les apps dont elle appelle les outils (`["fichiers"]`). Une app appelée n'est pas une dépendance : sans elle, l'app dit ce qu'elle n'a pas pu faire.
30
+ - `pour`, `ecrans`, `reglages` (« Qui ouvre une app », « Les pages d'une app »).
31
+ - Une app du client ne déclare pas `sousDomaine` : le kit le refuse.
32
+ - `Dockerfile` et `Dockerfile.dockerignore` côte à côte (`**/node_modules`, `**/dist`, `.git`). Aucun `.dockerignore` à la racine du dépôt. Le modèle est `modeles/app-du-client/Dockerfile` :
33
+ - une app du client se construit sur son seul dossier (`docker build .`), la bibliothèque prise du paquet, par la CI de son dépôt (`.github/workflows/publier-l-image.yml`, du modèle), qui pousse l'image sur ghcr.io ; une app du catalogue reproduit l'arbre du dépôt (`/depot/indos/bibliotheque`, `/depot/apps/<nom>`) et ne prend, hors de son dossier, que `indos/bibliotheque/` ;
34
+ - elle ne prend aucun fichier de `indos/bibliotheque/tests/`, absent chez un client (la CI le vérifie) ;
35
+ - l'étape `tests` lance `npm test` et l'image prend `dist/` de cette étape : un test qui échoue arrête la construction ;
36
+ - les étapes des tests sont à la plateforme du poste (`FROM --platform=$BUILDPLATFORM <image de Node>`), l'image à celle du serveur ;
37
+ - l'image de Node est citée par sa version et son empreinte ; un seul `EXPOSE`, un `HEALTHCHECK` sur `/sante`, `USER node`.
38
+ - `package.json` et `package-lock.json` : un paquet autonome, chaque outil à une version exacte, sans espace de travail npm. Le serveur est en TypeScript exécuté par Node, sans build.
39
+ - `src/` (le serveur), `migrations/` (`.sql`), `tests/`, `espace/` (la page), `dist/` (hors de git).
40
+ - `GUIDE.md` : le texte d'usage pour Claude, les instructions MCP de l'app. Son premier paragraphe la présente dans les instructions du core ; le texte entier est rendu par l'outil `guide` du core.
41
+ - `DOCUMENTATION.md`, facultatif : pour la personne, rendu à `/documentation/<nom>` en Markdown restreint (`##`, `###`, paragraphes, listes, étapes, gras, code, liens).
42
+ - `logo.svg`, facultatif : 24×24, l'objet en graphite `currentColor`, en formes simples, le geste de l'agent tracé à la main au jaune `#F0B429` (entouré, coche, gribouillis, souligné, flèche), le même geste pour une même fonction. Sans logo, la carte porte l'initiale du titre.
43
+
44
+ Une app écoute sur `PORT`, répond 200 sur `GET /sante`, s'arrête en huit secondes au plus sur `docker stop`, et garde tout dans sa base, sans volume. Elle reçoit `DATABASE_URL`, `CLE` (32 octets en base64), `ADRESSE` (`https://<domaine>/<nom>`), `CORE_ADRESSE` et `CLE_D_APPEL`.
45
+
46
+ Ce que le kit lit d'une app du client, au commit publié et poussé, jamais depuis les fichiers du poste : son dépôt, rien d'autre. Il refuse un manifeste hors de forme avant tout geste, et refuse de publier quand `indos/` n'a plus l'empreinte que dit `indos.version`.
47
+
48
+ ## Qui ouvre une app
49
+
50
+ Le core tient l'accès à une app. Sans `pour`, elle s'ouvre à toute l'équipe à sa première déclaration ; `"pour": "proprietaire"` la ferme au propriétaire seul jusqu'à ce qu'il l'ouvre dans « Équipe ». Une montée ne change pas ce réglage. Une app fermée à une personne n'existe pas pour elle : ni barre, ni outils, ni `/outils`, et ses pages lui répondent introuvables. L'app ne refait pas ce contrôle. Dans une app ouverte, `pour` sur un outil ou un écran réserve ce geste au propriétaire.
51
+
52
+ ## Les pages d'une app
53
+
54
+ - `ecrans` : `[{ nom, titre, pour }]`, dans l'ordre de la barre et des onglets. `nom` est le chemin sous l'app : non vide, sans `/` au début ni à la fin, sans segment vide, `.`, `..`, espace, `?`, `#`, `\` ni `%` ; son premier segment n'est ni `reglages`, `outils`, `mcp`, `sante` ni `espace`. `pour: "proprietaire"` : le core ne le montre qu'au propriétaire, l'app reste juge sur sa page.
55
+ - `reglages: true`, ou `{ "pour": "proprietaire" }` : l'écran `/<app>/reglages`. Celui d'une app à comptes branchés est `EcranDesComptes`.
56
+ - La racine (`GET /`) renvoie vers le premier écran, sinon les réglages, sinon répond 404 : `creerLaRacine`.
57
+ - Les scripts et les feuilles sont servis par l'app, de son chemin : aucun script en ligne, jamais un script qu'elle n'a pas écrit.
58
+ - Une page sans coquille se sert sous le chemin de l'app sans rien déclarer.
59
+
60
+ ## Le démarrage et l'arrêt d'une app
61
+
62
+ `src/demarrer.ts` est un appel à `demarrerLApp({ dossier, migrations, traiter, chemin })` (`@indos/bibliotheque/app`), sur le modèle de `modeles/app-du-client/src/demarrer.ts`.
63
+
64
+ - `ADRESSE` absente ou mal formée : l'app ne démarre pas. Sans `CORE_ADRESSE`, elle démarre, mais son MCP répond 503.
65
+ - `migrations: true` ouvre la base et applique `migrations/` dans l'ordre des noms, chacune une fois. Une migration publiée ne se modifie plus : la suivante la corrige.
66
+ - `traiter(app)` reçoit `base`, `adresse`, `adresseDuCore`, `manifeste`, `instructions`, `serveur` (pour un WebSocket), et rend le traitement ou `{ traiter, avantDeQuitter }`.
67
+ - `chemin(requete)` dit si le chemin de l'app se retire de la requête (oui par défaut). L'app le garde sur son hôte public, sur les chemins de ses écrans (le modèle), ou partout (les codes courts de Liens).
68
+ - Une erreur d'un traitement s'écrit au journal ; la requête reçoit la page simple en 500 pour une navigation, `{ "erreur": … }` en 500 sinon.
69
+ - Sur `SIGTERM` ou `SIGINT` : le serveur cesse d'accepter, flux et connexions se coupent, puis `avantDeQuitter` écrit les choses ouvertes. Aucune requête ne reçoit de réponse pendant ou après `avantDeQuitter` : une écriture confirmée est une écriture qu'il enregistre. Au-delà de huit secondes, l'app quitte en échec.
70
+
71
+ ## Les pièces
72
+
73
+ Une entrée de `exports` par fonction (`package.json`), nommée par ce qu'elle fait : `@indos/bibliotheque/<entrée>`. Le serveur est dans les `.ts` de la racine de `src/`, le navigateur dans `src/ui/` et `src/espace/`.
74
+
75
+ - Le code que l'image lance n'importe aucune dépendance de développement : `faux-core`, `base-d-essai`, `espace-d-essai`, `src/vite.ts` et le code du navigateur restent hors des autres entrées du serveur.
76
+ - `deriver(cle, contexte)` (HKDF-SHA256, 32 octets) et les liens signés de `liens` (`signerUnLien(cle, sorte, charge)`, dix minutes, rien en base) ont des formats figés : le kit refait la même dérivation sans importer la bibliothèque, et un lien déjà donné se lit toujours.
77
+ - Des octets servis en pièce jointe prennent `enTetesDUnTelechargement` (`sandbox`, `nosniff`).
78
+ - `identifiant(id)` rend l'UUID en minuscules, ou rien : l'app répond alors « absente » sans demander à la base.
79
+ - Le type d'un fichier qui entre se lit par `typeDuFichier`.
80
+ - Le jeton du core (`jeton`) est vérifié en Ed25519 seul, pour l'app visée, une minute.
81
+
82
+ ## Le MCP d'une app
83
+
84
+ `creerLeMcp({ app, version, instructions, outils, adresse })` sert `/mcp` (Streamable HTTP sans état) et `POST /outils/<nom>`. Chaque outil déclare son schéma d'entrée et, s'il n'est pas pour tous, `pour`. Le jeton du core se vérifie à chaque requête (401 sinon, 503 sans `CORE_ADRESSE` ou si le core ne répond pas) ; l'app ne montre et n'exécute que les outils permis à la personne. Des arguments hors schéma donnent un résultat en erreur.
85
+
86
+ - Un geste définitif (supprimer, publier, émettre, annuler) prend `confirmer: true` ; sans lui, un `Refus` qui dit quoi demander à la personne.
87
+ - Un argument manquant ou un choix à faire est un refus qui nomme les choix (« Préciser `compte` parmi : … ») ; un choix unique se prend sans demander.
88
+
89
+ ### Un écran appelle ses outils
90
+
91
+ L'app route `POST /outils/<nom>` vers `creerLeMcp`, comme `/mcp`. Les contrôles d'un geste d'écran s'appliquent (méthode, `Origin`, personne, corps), puis : outil hors de portée 403, inconnu 404, arguments hors schéma 400, refus 422 avec son texte, échec 500 sans sa cause, sinon 200 et le résultat MCP. L'outil reçoit la personne de la session, ses groupes compris.
92
+
93
+ ## Un refus
94
+
95
+ Un outil qui ne fait pas ce qu'on lui demande ne rend jamais un succès.
96
+
97
+ - Il refuse quand une règle dit non (l'accord, le droit, une règle de l'app) : `throw new Refus(texte)`. Le texte, pour Claude, dit ce qui n'est pas fait et ce qu'il faut faire. Le core l'écrit refusé au journal.
98
+ - Le reste est un échec (valeur hors forme, service muet, erreur de l'app) : `throw new Error`, rendu « <outil> a échoué : <message> ».
99
+ - Un geste qui rattrape une erreur pour la reformuler laisse passer un `Refus` tel quel.
100
+ - `appeler` rend le résultat d'une autre app sans lever : `isError` dit qu'il n'a pas abouti, `estUnRefus` que c'est un refus. L'app qui appelle en fait un échec à elle, par `Error`, en citant le texte reçu.
101
+
102
+ ## Un outil qui montre une image
103
+
104
+ `executer` rend un texte ou un contenu MCP `{ content: [...] }` (`ResultatDOutil`), texte et images en base64, passé tel quel. Un écran n'en lit que le texte (`texteDe`). Un fichier entre et sort par un lien de dix minutes : seule une image réduite passe par MCP.
105
+
106
+ ## Les transactions
107
+
108
+ `enTransaction(base, geste, { verrou })` : tout ou rien, `geste(client)` lit et écrit par `client`, jamais par le pool, qui peut n'avoir qu'une connexion. Une erreur annule tout et passe telle quelle. `verrou`, une clé ou une liste, se prend d'abord, plusieurs clés dans l'ordre de leur nom ; c'est `pg_advisory_xact_lock(hashtextextended(<clé>, 0))`, la même clé que prend un déclencheur de la base pour la même chose.
109
+
110
+ ## La recherche sans accents
111
+
112
+ Un texte cherché ignore accents et casse, par la même normalisation en SQL (`sansAccentsEnSql(expression)`, `motifSansAccents(texte)` pour `like`) et en JavaScript (`sansAccents`). L'expression SQL est écrite par l'app, jamais par la personne. La base est en UTF-8.
113
+
114
+ ## Les formats
115
+
116
+ `@indos/bibliotheque/format`, jamais `Intl` ni `toLocaleString` : l'écran, un PDF et un courrier écrivent la même chose. Les jours et les heures sont à l'heure de `Europe/Zurich` ; les milliers prennent l'apostrophe droite.
117
+
118
+ - `jour` (« 28.10.2026 »), `jourEtHeure`, `tempsEcoule`, `nombre` (« 1'234 »).
119
+ - `montant` (« CHF 12'400.00 ») et `montantRond` écrivent « **** » quand la page masque les montants ; `montantEnClair` ne masque jamais, pour un formulaire et la question d'un geste. Un serveur ne masque jamais.
120
+
121
+ ### La pagination
122
+
123
+ Un outil ou un geste paginé reçoit `page`, un entier à partir de 1 (1 s'il manque), et rend `{ "lignes": [...], "total": <nombre> }`, 25 lignes au plus (`lignesParPage`). Une page au-delà du total rend des lignes vides et le total.
124
+
125
+ ## Les fichiers
126
+
127
+ Une app qui dépose un fichier dans les fichiers d'une personne, ou en lit un, passe par `@indos/bibliotheque/fichiers`, déclare `appelle: ["fichiers"]` et lui donne l'appel de `creerLAppel`. Aucun octet ne passe par l'appel : `televerser` et `telecharger` rendent un lien signé de dix minutes.
128
+
129
+ - `deposerUnFichier`, `donnerALEntreprise`, `demanderUnFichier`, `telechargerUnFichier` (jamais plus que la taille de la fiche, empreinte SHA-256 vérifiée).
130
+ - Une app qui copie un fichier de la personne dans une chose passe par `prendreUnFichier(appeler, personne, id, { plafond, app, rien, conseil })`, qui coupe la lecture au plafond quoi que dise la fiche ; un fichier trop gros est un `Refus`, la même phrase dans chaque app.
131
+ - L'app lit la fiche pour ses propres règles avant les octets : la taille contre son plafond, `publie` avant de montrer le fichier à d'autres.
132
+ - Le refus de fichiers lève `RefusDeFichiers`, qui ne dérive pas de `Refus` : c'est un échec de l'app qui appelle. Elle l'enveloppe dans son erreur, qui dit ce qu'elle n'a pas fait et que le reste marche.
133
+
134
+ ## Les fichiers d'une chose
135
+
136
+ Une app dont chaque chose porte ses fichiers les garde dans sa table `fichier` (la colonne de la chose, `chemin`, `type`, `contenu` de 2 Mo au plus, `taille` générée, `modifie_le`, clé `(<chose>, chemin)`), un déclencheur tenant le plafond de la chose. `creerLesFichiersDUneChose({ chose, laChose })` rend les lectures et les écritures (`poser`, `copier`, `retirer`), qui passent par `enTransaction` sous le verrou de la chose. Un chemin : des segments de lettres, chiffres, `.`, `_`, `-`, aucun ne commençant par un point ou un tiret, 300 caractères au plus (`estUnChemin`).
137
+
138
+ ## Les remplacements
139
+
140
+ `appliquerLesRemplacements(contenu, [{ avant, apres }])` applique tout ou rien : un « avant » absent ou présent plusieurs fois lève une erreur qui montre le passage le plus proche. `schemaDesRemplacements` : 1 à 100. L'app les applique à ce qu'elle lit sous le verrou de la chose, dans la transaction qui écrit.
141
+
142
+ ## Les signaux d'une chose
143
+
144
+ `creerLesSignaux<Quoi>()` rend `signaler(id, quoi)` et `ecouter(id, rappel)`. Les signaux vivent en mémoire de l'app : toute écriture d'une chose passe par elle et donne son signal.
145
+
146
+ ## Un flux d'événements
147
+
148
+ `ouvrirUnFlux(requete, reponse, { duree, entetes })` : `text/event-stream`, un battement toutes les 25 secondes (le proxy coupe une connexion muette à 90). Il se ferme à `duree`, quand la page part, quand plus d'un Mio attend, et à l'arrêt de l'app ; `surLaFermeture(geste)` défait ce que l'app a posé (un écouteur, une présence).
149
+
150
+ ## Le partage
151
+
152
+ Une chose est toujours à une personne et s'ouvre à des personnes, à des groupes ou à toute l'équipe, en lecture ou en modification. Le core tient l'accès à l'app ; l'app tient le partage de ses choses dans sa base, par `@indos/bibliotheque/partage`. Les groupes viennent du jeton et de la session, signés par le core. Le propriétaire de l'OS ouvre toute app, pas toute chose, sauf dans une app qui déclare `auProprietaireDeLOS`. Une app qui partage borne le core à `>=1.7 <3`.
153
+
154
+ - La table `partage` recopie `modeles/partage.sql` dans une migration de l'app : `(<chose>, avec, droit)`, `avec` valant `personne:<id>`, `groupe:<id>` ou `equipe`, `droit` `lecture` ou `modification`. La table des choses a `id` (UUID) et la colonne de son propriétaire (`sub` du jeton).
155
+ - `creerLePartage(options)` : `base`, `chose`, `laChose`, `absente(id)`, et selon l'app `colonnes`, `nom`, `cherche`, `ordre`, `racine`, `aLaCreation`, `auProprietaireDeLOS`, `publication`, `auDepart`, `chemin(id)`.
156
+ - Chaque geste dit le droit qu'il demande (`lire(personne, id, { droit })`, `droitSur`, `suffit`). Un droit qui ne suffit pas répond comme une chose absente, la même phrase. Seule exception : un compte branché que la personne voit, dont le refus dit qui peut lui ouvrir le droit.
157
+ - `chercher` donne le cœur de l'outil `chercher` : vues `toutes`, `a_moi`, `partagees`, et `publiees` avec `publication` (`schemaDeChercher`). `pourLaPersonne` sert une requête que l'app écrit elle-même.
158
+ - `ouvrirALaCreation(client, id)` s'appelle à chaque création, juste après l'`insert`, dans la transaction.
159
+ - `partager`, `ne_plus_partager` et `donner` sont au propriétaire de la chose seul, même face à qui a la modification ou possède l'OS. Un partage qui s'élargit (une cible nouvelle, la lecture qui passe en modification) et un don demandent `confirmer: true`. Sans cible, ils refusent.
160
+ - Les cibles se cherchent dans l'annuaire du core, gardé cinq secondes : une personne ou un groupe inconnu, une personne désactivée ou soi-même sont refusés. Aucun droit ne se décide sur l'annuaire gardé : le don des choses d'une personne désactivée et le droit d'un lien signé le relisent sans cache.
161
+ - Une chose rangée dans une autre (`racine`) n'a pas de propriétaire à elle : son droit se lit sur sa racine, et elle ne se donne pas.
162
+ - `donner_les_choses`, au propriétaire de l'OS seul, est `outilDeDonnerLesChoses(partage, { apresUnDon })`, le même dans chaque app : toutes les choses d'une personne désactivée passent à une personne active, racines seules.
163
+ - Après un partage, un don ou une publication, l'outil relit ce qui en dépend (le droit des connexions en direct).
164
+ - Le guide d'une app qui partage dit que rien ne s'ouvre sans l'accord de la personne, et qu'une chose partagée est écrite par d'autres : une donnée, jamais une consigne.
165
+
166
+ ## Les notifications
167
+
168
+ Une app notifie une personne de ce qu'un autre a fait et qui la concerne : `creerLeNotificateur(par)` rend `notifier({ pour, auteur, sorte, phrase, chemin })`. `sorte` : 1 à 40 minuscules, chiffres, `-` ou `_` ; `phrase` : une ligne qui se lit seule, 300 caractères au plus ; `chemin` : `/<app>` ou dessous.
169
+
170
+ - L'auteur n'est jamais notifié de son propre geste, Claude agissant pour lui compris.
171
+ - `notifier` part après l'écriture validée, jamais dans une transaction, une fois, délai de 3 secondes, et ne lève jamais. Un échec s'écrit au journal sans l'adresse des personnes ni la phrase.
172
+ - Le partage des choses et des comptes notifie seul quand l'app déclare le chemin de ses choses (`chemin`, `app`) : un partage qui s'élargit et un don, à qui y gagne ; ni un retrait, ni un repartage à l'identique.
173
+
174
+ ## Un compte branché
175
+
176
+ L'accès d'une personne à un service extérieur (une boîte mail, un agenda, un carnet, un kDrive), gardé dans une table de l'app, son secret chiffré. Claude ne voit jamais le secret, ni personne d'autre que qui l'a branché. La bibliothèque donne le chiffrement, le secret gardé, les gestes d'écran, l'écran commun et le partage ; l'app garde la table, la vérification des valeurs et l'essai du compte auprès du service.
177
+
178
+ ### Le chiffrement
179
+
180
+ `chiffrer(cle, compte, texte)` en AES-256-GCM, `dechiffrer` ; `compte`, l'UUID du compte tiré avant l'insertion, entre dans les données authentifiées. La clé se tire au démarrage par `deriver(lireLaCle('CLE'), '<usage>')` ; l'usage ne change plus, sinon les comptes branchés ne se relisent pas. Le format est figé.
181
+
182
+ ### Le secret gardé
183
+
184
+ À la modification, un secret laissé vide garde celui qui est enregistré, seulement vers la même destination : `garderLeSecret(cle, compte, chiffre, destination, enregistree)` dans le geste `modifier`, la destination comparée élément par élément, type compris (`993` n'est pas `'993'`). Sinon l'app demande de retaper le secret. La destination est le serveur, le port, l'identifiant, mis en forme comme l'app les enregistre ; `[]` pour un service à une seule adresse.
185
+
186
+ ### Les gestes des comptes
187
+
188
+ `creerLesGestesDesComptes({ adresse, adresseDuCore, textes, champs, comptesDe, brancher, modifier, retirer, partage, apresUnDon })` (`@indos/bibliotheque/compte`) sert `/espace/comptes/<geste>` (`decrire`, `lister`, `brancher`, `modifier`, `retirer`, et avec `partage` : `partage`, `partager`, `ne-plus-partager`, `donner`), chacun par `traiterUnGesteDEcran`. L'app le route avant `/espace/…`. Le contrat est typé dans `src/description-des-comptes.ts`.
189
+
190
+ - Un secret ne revient dans aucune réponse : `lister` retire tout champ `secret`.
191
+ - Les gestes de l'app ne voient que les comptes de la personne : `modifier` et `retirer` gardent leur `where proprietaire = $1`.
192
+ - Avec `partage`, le formulaire a en tête le champ `nom` : aucun champ de l'app ne prend ce nom, et l'app pose son nom par défaut quand il arrive vide.
193
+ - `brancher` et `modifier` de l'app vérifient les valeurs, essaient le compte et rendent le texte du refus, ou rien ; `brancher` peut rendre `{ connexion }`, une adresse de l'origine de l'app.
194
+ - Le `lien` d'un compte est une route de l'app elle-même ; une autre origine est une erreur.
195
+ - Avec `partage`, le partage, le don, `modifier` et `retirer` sont réservés au propriétaire du compte : « Ce compte n'existe pas. » pour tout autre.
196
+
197
+ ### L'écran des comptes
198
+
199
+ `EcranDesComptes` (`@indos/bibliotheque/espace`), déclaré à la route `/<app>/reglages`, se dessine depuis `decrire` et `lister`. L'app déclare ses `textes` (`titre`, `presentation` en deux phrases : ce que Claude fait avec ces comptes, puis qui les voit ; `aucun`, `brancher`, `retirer`, `etapes`, `fournisseur`, `connecter`, `faits`…), et ses `champs` (genres `texte`, `email`, `nombre`, `paragraphe`, `identifiant`, `secret`, `case`). Une route de l'app qui ramène à l'écran passe `?fait=<code>`, un code de `faits` ; aucun texte ne vient de l'adresse.
200
+
201
+ ### Le partage des comptes
202
+
203
+ `creerLePartageDesComptes({ base, table, laChose, colonnes, detail, donnable, app })` donne à la table des comptes le partage de toute chose ; `comptesVisibles`, `choisirLeCompte(personne, compte, { droit, aucun })`, `personneDuLien`, `quiRebranche`. La lecture consulte, la modification agit aussi, la propriété seule modifie le branchement, le retire, le partage, le donne et publie un lien chez le fournisseur ; le propriétaire de l'OS n'a aucun droit de plus. Partager et donner un compte ne sont que des gestes d'écran : aucun outil ne les offre. Au départ d'une personne, `donner_les_choses` ne passe que les comptes ouverts à quelqu'un et `donnable`.
204
+
205
+ ## La page de l'espace
206
+
207
+ Une app à page a sa page en React dans `espace/`, construite dans `dist/` (`dist/index.html`, ses fichiers sous `dist/espace/` nommés par leur empreinte). `servirLaPage({ dist, session, cadre, entetes })` la sert, `GET` et `HEAD` seuls : sur le chemin de chaque écran et sur `/espace/…`. Sans `dist/index.html`, l'app ne démarre pas. Sans session, la page mène à la connexion du core ; à une personne à qui l'app est fermée, la page simple en 404. La session est dans `<meta name="indos-session">`. Une app à choses lui confie aussi les chemins que reconnaît `estUnEcranDesChoses` (`/liste`, `/<id>`, `/<id>/seule`).
208
+
209
+ ### L'hôte public d'une app
210
+
211
+ Une app dont les choses se publient sert leur lien sur son hôte public (`ADRESSE_PUBLIQUE`, `https://<sousDomaine>.<domaine>`), sans compte : la session du core n'y arrive pas, et l'app y garde son chemin (`chemin`). `servirLHotePublic({ dist, adresse, balise, publiee, introuvable, sources, lectures })` le sert, et l'app lui confie chaque requête de cet hôte avant toute autre route.
212
+
213
+ - `publiee(id)` ne rend que ce que la page doit savoir (l'identifiant), ni le propriétaire ni le partage ; rien pour une chose absente ou non publiée.
214
+ - Une chose absente, une chose fermée, une adresse inconnue et toute autre méthode reçoivent la même page introuvable en 404.
215
+ - Sa politique est `entetesDeLaPagePublique` : `default-src 'none'`, le reste à `'self'` et au thème du core, puis les `sources` de l'app.
216
+
217
+ ## Les pages rendues par le serveur
218
+
219
+ Les pages d'auth du core et la page simple (`@indos/bibliotheque/ecran` : `pageDAuth`, `pageSimple`, `envoyerLaPage`) sont rendues par le serveur, sans script, sur les classes de `/theme/console.css` : une page n'en invente pas. Un paramètre de texte est échappé ; un paramètre de HTML l'est par l'appelant (`echapper`). Le message après un formulaire passe par un code fixe (`?fait=<code>`, `messageDuGeste`) : aucun texte ne vient de l'adresse.
220
+
221
+ ## Les gestes d'écran
222
+
223
+ Un geste d'écran est un appel de la page à sa pièce, en JSON, avec la session : l'appel d'un outil, ou un geste que Claude ne doit pas voir (un secret), `POST /<app>/espace/<geste>`, sans extension, routé avant `/espace/…`. Il ne passe ni par le core ni par son journal. `traiterUnGesteDEcran(requete, reponse, { origine, personneDe, executer })` vérifie dans l'ordre :
224
+
225
+ 1. la méthode : 405 hors de `POST` ;
226
+ 2. l'`Origin`, celle de la page : 403, avant toute question au core ;
227
+ 3. la personne (`personneDuGeste`) : 401 sans session, 403 si l'app lui est fermée, 503 si le core ne répond pas ;
228
+ 4. le corps : 415 hors de JSON, 413 au-delà de 4 Mio, 400 si ce n'est pas un objet ;
229
+ 5. `executer` : 200 et sa valeur ; un `Refus` en 422 avec son texte ; toute autre erreur en 500 sans sa cause, écrite au journal de l'app.
230
+
231
+ `executer` n'écrit jamais la réponse lui-même. Un fichier passe en base64 dans le corps (`fichierEnBase64`).
232
+
233
+ ## Écrire une page
234
+
235
+ `espace/` porte `index.html` (le même pour chaque pièce, sans script en ligne), `page.tsx` (les routes, puis `lancerLaPage`), `ecrans/` (un écran par fichier, qui n'exporte que son composant), `requetes/`, `tsconfig.json` (qui étend `tsconfig.page.json` de la bibliothèque) ; les tests de la page sont dans `tests/espace/*.test.tsx`. Le modèle est `modeles/app-du-client/espace/`.
236
+
237
+ - La page importe `@indos/bibliotheque/espace`, `@indos/bibliotheque/ui`, React, TanStack, Radix et Yjs tels quels : ils se résolvent depuis la bibliothèque, une seule copie de chacun. Une app du client les reçoit du paquet, dont ils sont les dépendances de pair que npm installe ; une app du catalogue lie `react` et `react-dom` à ceux de la bibliothèque (`file:../../indos/bibliotheque/node_modules/react`).
238
+ - Ses scripts npm lancent la commande de la page (`construire`, `developper`, `tester`) : `page-de-l-espace` pour une app du client, comme le modèle ; `node node_modules/@indos/bibliotheque/bin/page-de-l-espace.ts` pour une app du catalogue.
239
+ - `npm run build` refuse un script en ligne ; `page-de-l-espace tester` refuse le HTML brut dans `espace/` (`innerHTML`, `dangerouslySetInnerHTML`, `outerHTML`, `insertAdjacentHTML`, `document.write`).
240
+ - `npm run dev` : `INDOS_CORE` (le core de l'espace ou un core local), `INDOS_APP` (l'app lancée en local, `http://localhost:3000`), `INDOS_PORT`. L'app est lancée avec `ADRESSE=http://localhost:5173/<app>`. Relié à un espace en HTTPS, la session passe dans Chrome et Firefox, pas dans Safari.
241
+
242
+ ## La coquille
243
+
244
+ `lancerLaPage({ piece, base, ecrans })` (`@indos/bibliotheque/espace`) rend la page : la barre de l'OS à gauche, à droite le cadre de l'écran. Le cadre se dessine depuis la session et le chemin : l'app n'y déclare rien.
245
+
246
+ - Un écran est une route de TanStack Router sous `coquilleDeLEspace`, son chemin entier (`/<app>/<écran>`) ; en pleine fenêtre, sous `horsDeLaCoquille` ; jusqu'au bas de la fenêtre, `staticData: { pleineHauteur: true }`.
247
+ - Un écran rend `Ecran` (`titre`, `presentation`, `apresLeTitre`, `largeur: 'lecture'`) et lit `useSession()`, `usePiece()`.
248
+ - La ligne du haut est au cadre : les onglets de l'app, ou le fil d'Ariane, à gauche ; à droite, sur une chose seulement, le bloc de l'accès et le ⋯. Aucun geste d'une app, aucune épingle n'y entre : on épingle par l'édition de la barre.
249
+ - Les appels : `appeler(outil, arguments)` et `useAppel(outil)` vers ses outils, `faireUnGeste(chemin, corps)` vers un geste d'écran, `appelerUneApp(app, outil, arguments)` vers une autre app. Toute réponse autre que 200 lève `ErreurDUnAppel`, son texte mot pour mot (`refus` pour un 422) ; `RefusDUnAppel({ appel, verbe, sorte })` le montre et, avec `verbe`, rappelle l'outil avec `confirmer: true` : l'accord est ce clic. Une lecture en panne (5xx) se réessaie deux fois, un refus jamais.
250
+ - Un écran paginé prend `validateSearch: rechercheDUnePage` et `usePageDeLAdresse()` : la page est dans l'adresse.
251
+ - Un geste fait s'annonce par `useAnnoncer()`.
252
+ - Les montants masqués sont un masque d'écran, pas une protection : les données arrivent entières dans la page.
253
+
254
+ ## Les composants d'une page
255
+
256
+ `@indos/bibliotheque/ui` : les composants de shadcn/ui copiés dans `src/ui/`, sur Radix, au style Indos, en français et accessibles. Leurs propriétés sont dans leurs types.
257
+
258
+ - La feuille `@indos/bibliotheque/ui/theme.css` (Tailwind v4), importée après `/theme/variables.css`, ne déclare aucune couleur ni police : elle lit celles du core (`--papier`, `--encre`, `--accent`, `--gris`, `--erreur`, `--surface`, `--trait`…), les seules couleurs de Tailwind (`bg-surface`, `text-gris`). Les polices sont `font-sans`, `font-titre`, `font-mono`.
259
+ - Un rôle, un composant :
260
+ - `Bouton` (`principal`, `secondaire`, `detruit`, `discret`) ;
261
+ - `Champ`, `Saisie`, `ZoneDeTexte`, `CaseACocher`, `ChoixParmiPlusieurs`, `Suggestions` ;
262
+ - `Choix`, la seule liste déroulante, jamais un `<select>` ;
263
+ - `Section`, `TitreDeSection`, `Etiquette`, `Message`, `Lignes`, `Etapes`, `AdresseACopier` ;
264
+ - `Fenetre`, une question ou un formulaire court ; `Panneau`, un réglage de la chose ; `PanneauEnDeuxTemps`, un branchement ; `Confirmation`, un geste définitif ;
265
+ - `Tableau`, `Vues`, `Recherche`, `MenuDUneLigne` (le ⋯), `LignesDeReglages`, `SecretGarde`, `ValeurMontreeUneFois` ;
266
+ - `EtatDeLecture`, « Chargement… » ; `SansResultat`, la recherche vide ; `ChosePleine` ;
267
+ - `GesteDeLaSection`, `GesteAuBoutDeLaLigne`, `GesteApresLaValeur` ;
268
+ - `Colonnes` et `Barres`, les graphiques, dessinés en HTML, sans paquet de graphiques ;
269
+ - les icônes communes (`IconeDeLOeil` ne veut dire qu'« aperçu »).
270
+ - Une valeur montrée une fois (un mot de passe d'application, un lien, des codes) se lit à la dernière étape de la `Fenetre` qui l'a créée (`derniereEtape`), qui ne se ferme que par « Fermer » : ni Échap ni le voile.
271
+ - Les dépendances du navigateur sont de développement : l'image d'une app, où la bibliothèque s'installe par `npm ci --omit=dev`, n'en a aucune.
272
+
273
+ ## Les règles d'écran
274
+
275
+ Chaque écran prend de la bibliothèque ce qui se dessine pareil partout. Quatre principes tranchent un cas neuf : un signe, un sens ; un geste, une place ; la même chose, la même tête (liste, aperçu, écran, chose seule) ; le rare et le définitif se rangent dans le ⋯.
276
+
277
+ - La couleur porte un sens : l'accent dit ce qui est actif, le rouge d'erreur une erreur ou un geste qui détruit, le reste est gris. Une série de graphique qui ne dit rien est grise.
278
+ - Le survol ne change que la couleur : ni `translate`, ni `scale`, ni rotation.
279
+ - Un téléphone va jusqu'à 760 px : `max-[760px]:`, le seul seuil.
280
+ - Les gestes d'une chose vont sur la ligne de tête de son corps : trois boutons au plus, un principal, aucun geste définitif ni bouton rouge. Ce qui clôt la chose va dans le dernier groupe du ⋯, avant Supprimer.
281
+ - Un geste de création va à droite de la recherche de la liste qu'il remplit, le principal en dernier (`gestes` de `Recherche`, ou de `Vues` sans recherche).
282
+ - Les gestes du contenu ont trois hauteurs : `GesteDeLaSection` (à droite d'un titre, pour ajouter), `GesteAuBoutDeLaLigne` (retirer ou ouvrir), `GesteApresLaValeur` (la changer). Aucun lien gris ni bouton de ce rôle n'est écrit à la main. Au-delà de deux gestes, une ligne prend un ⋯.
283
+ - Un libellé de menu ou de lien gris dit ce qui suit : « … » pour une question ou un formulaire, « ↗ » pour un autre onglet, rien quand il agit aussitôt. Un bouton n'en prend pas.
284
+ - Par-dessus : une fenêtre pour une question ou un formulaire court, un panneau pour un réglage de la chose. Rien ne s'ouvre par-dessus un panneau, sauf une question.
285
+ - Un formulaire ou un texte se borne à 720 px (`largeur: 'lecture'`, `largeurDUnFormulaire`) ; une recherche fait 360 px ; un bouton dans une ligne est `taille="petite"`. Jamais une hauteur écrite à la main.
286
+ - Un titre est `Section` ou `TitreDeSection` : aucun surtitre en petites capitales.
287
+ - Un tableau s'empile sur un téléphone : les colonnes `tete: true` en tête, la colonne sans titre (`titre: ''`) pour les gestes de la ligne.
288
+ - La première vue est celle où la personne arrive.
289
+ - Les états : `EtatDeLecture` pendant la lecture, `SansResultat` pour une recherche vide, une phrase en gris pour une liste vide.
290
+ - Un geste fait s'annonce par `useAnnoncer()`, en phrase complète avec son point ; un `Message` ne reste que pour ce qu'il faut lire ou recopier, comme un refus. Un écran n'a pas d'`Annonce` à lui.
291
+ - Les mots : un bouton à l'infinitif, son verbe suivi de son objet ; une consigne à l'impératif, au vouvoiement ; « Supprimer » si la chose disparaît, « Retirer » si elle reste. « Chose » ne s'écrit pas à l'écran.
292
+ - Les écrans de réglages :
293
+ - au repos, un état, une ligne par chose réglée (`LignesDeReglages`), sans accordéon, sans chevron, sans bouton rouge ;
294
+ - ajouter et modifier ouvrent le même formulaire par-dessus la page : une `Fenetre` jusqu'à trois champs, un `Panneau` pour un compte ;
295
+ - les étapes chez le fournisseur viennent en premier temps (`PanneauEnDeuxTemps`) ;
296
+ - un secret enregistré se montre enregistré (`SecretGarde`) ;
297
+ - un refus se lit dans le formulaire ouvert, la saisie gardée ; la page ne défile jamais seule ;
298
+ - rien ne s'y remplit par déduction (des serveurs tirés du domaine d'un courriel), et chaque app branche ses propres comptes.
299
+ - Un compte en panne le dit sur sa ligne : l'app retient le dernier refus de son service et l'efface au premier appel qui réussit ; la ligne le dit en rouge, dans les mots de la personne, avec le geste qui répare ; un compte sain ne porte aucune étiquette de plus.
300
+
301
+ ## Une app à choses
302
+
303
+ Une app dont la personne liste et ouvre des choses (pages, documents, contacts, factures…) prend la liste, l'écran d'une chose, l'aperçu, le ⋯ et le panneau du partage de la bibliothèque ; elle les déclare et les nourrit par ses outils. Une app neuve naît dans cette liste et cet écran ; un écran à elle vient après, quand l'usage le demande.
304
+
305
+ - Son manifeste déclare un écran par liste : `liste` pour la première sorte de choses, puis un écran par autre sorte (`mandats`).
306
+ - Un outil par liste : `chercher` pour `liste`, `chercher_des_<écran>` pour les autres (un tiret devenant `_`), que l'édition de la barre appelle.
307
+ - `chercher`, le même pour Claude et pour l'écran, prend `{ texte?, vue?, page? }` et rend `{ lignes, total }` en JSON, 25 par page, le texte sans accents ni casse. Sans `vue`, il trouve tout ce que la personne voit ; la liste passe toujours sa vue.
308
+ - Chaque ligne (`ChoseTrouvee`) porte `id`, `nom`, `chemin` (`/<app>/<id>`), puis, quand l'app les a, `droit`, `auteur`, `partagee`, `publiee`, `adresse_publique`, `droit_public`, `modifie_le`, et ses champs propres. Une app dont d'autres chemins sont à la racine met ses choses sous `liste/`.
309
+ - Ses autres outils (`lire`, `creer`, `modifier`, `partager`, `ne_plus_partager`, `donner`, `supprimer`, le renommage, la publication) gardent ces noms ; ceux qui rendent une chose portent son `id`.
310
+ - La page déclare `DeclarationDesChoses` : `app`, `une`, `lire` et `corps` obligatoires ; puis selon l'app `feminin`, `ecran`, `sorte`, `nouvelle`, `colonnes`, `vues` (`vuesDuPartage`), `etat`, `date`, `plein`, `publication`, `motsDeLaSuppression`, `consequenceDeLaSuppression`, `vide`, `formulaire`, `ancetres`, `gestesDuMenu` (groupes `ouvrir`, `changer`, `copie`, `clore`), `etatDeLaChose`, `gestes`, `rendu`, `aPart`, `renommer`, `donner`, `peutDonner`, `supprimer`, `peutSupprimer`, `lirePartage`, `partager`, `nePlusPartager`, `publier`, `nouveau`, `gestesDeLaListe`. Ce qu'elle ne déclare pas ne se montre pas.
311
+ - `espace/routes.ts` : `routesDesChoses(declaration)`. Une route écrite à la main suit la même forme (`validateSearch: rechercheDeLaListe` et `ListeDesChoses` pour la liste ; `staticData: { ecranDUneChose: true, choses }` pour la chose).
312
+ - Le serveur sert la page sur les chemins de `estUnEcranDesChoses`, et ceux de ses autres listes.
313
+ - Une fiche (un contact, une facture) s'écrit dans `formulaire` (`FormulaireDUneFiche`) ; `modifier` n'envoie que ce qui a changé. Une chose qu'on écrit naît vide par `nouveau`.
314
+ - Un geste propre qui change les choses les relit par `useRelireLesChoses(app)`.
315
+ - Un geste définitif passe par `ConfirmationDUnGeste`. Quand seul le serveur connaît sa portée, l'écran appelle sans accord ; le refus qui demande l'accord (`demandeLAccord`) devient la question, en mots de la personne, et le verbe rappelle avec `confirmer: true`. Le texte du refus, écrit pour Claude, ne se montre jamais. Un autre refus se lit mot pour mot.
316
+ - Supprimer est toujours dans le ⋯. Une chose rangée dans une autre n'a pas « Partager… » : elle suit sa racine.
317
+ - `useDansLApercu()` dit qu'un corps est rendu dans l'aperçu.
318
+
319
+ ## Le direct à l'écran
320
+
321
+ Une chose écrite à plusieurs montre son direct de la même façon partout : la bibliothèque écrit l'état, les présences, la couleur et l'étiquette d'une personne ; l'app garde la forme de ce que fait un autre (un curseur, une cellule).
322
+
323
+ - Le corps déclare son direct par `useDeclarerLeDirect({ etat, personnes, lecture })` ; le cadre le dessine dans le bloc de l'accès.
324
+ - `couleurDe(id)` tire la couleur d'une personne de son identifiant, la même partout ; elle dit qui est là, rien d'autre.
325
+ - Le nom d'une autre personne passe par React (`EtiquetteDuNom`) ou par `elementDeLEtiquetteDuNom`, en texte : jamais en HTML.
326
+ - Une page hors de l'espace pose `EtatEtPresences`, ou `EtatSansPresence` en lecture publique.
327
+ - `useAnnoncerLeDroitQuiBaisse`, `useMontrerLaChoseIntrouvable`, `rechargerLaPage` pour une session fermée.
328
+
329
+ ## Le direct Yjs
330
+
331
+ Une chose écrite à plusieurs en Yjs prend son direct de la bibliothèque : `creerLeDirectYjs` (`@indos/bibliotheque/direct`) au serveur, `ouvrirUnDirectYjs` (`@indos/bibliotheque/direct/page`) à la page. Chaque chose ouverte est un document Yjs en mémoire de l'app, relayé par Hocuspocus, écrit en base par l'app : une seule instance par serveur.
332
+
333
+ - Une seule copie de Yjs, celle de la bibliothèque : une app du catalogue cite `yjs` et `y-protocols` par un lien vers sa copie (`file:../../indos/bibliotheque/node_modules/yjs`), une app du client ne les cite pas ; aucune ne cite Hocuspocus.
334
+ - L'app donne `droitDe(personne, chose)`, `droitPublic(chose)` pour une chose publiée, `charger`, `enregistrer` (un `UPDATE` seul, qui ne recrée jamais une chose supprimée), `limite` et ses `textes`.
335
+ - Le serveur contrôle à l'ouverture, avant toute donnée, l'`Origin`, la session ou le lien publié, et le droit ; il écrit lui-même la présence de chaque connexion. Un visiteur en lecture sur l'hôte public ne reçoit aucune présence.
336
+ - `relire(...choses)` après un partage, un don, une publication, un changement du droit du lien, un déplacement ou une suppression (et toutes les cinq minutes) : une connexion sans droit est coupée (4403), une dont le droit a changé aussi (4205).
337
+ - `ecrire(chose, geste, { avant, garder })`, une écriture de Claude, passe à côté du contrôle, ce que l'outil a vérifié avant ; un état qui passerait la `limite` n'écrit rien.
338
+ - `fermer()` dans `avantDeQuitter`.
339
+
340
+ ## Comment une app s'en sert
341
+
342
+ Une app du client cite le paquet publié à une version exacte : `"@indos/bibliotheque": "3.0.0"`. npm installe ses dépendances d'exécution et ses dépendances de pair (React, TanStack, Tailwind, Vite, Vitest, leurs types) ; l'image n'en garde aucune (`npm ci --omit=dev --omit=peer`). Une version publiée ne change plus : l'app ne prend la suivante qu'en changeant ce numéro. Le paquet est compilé, Node n'effaçant pas les types sous `node_modules` : `npm run paquet` l'écrit dans `paquet/` (`scripts/construire-le-paquet.ts`), et la release d'`indos` le publie.
343
+
344
+ Une app du catalogue cite la bibliothèque par un lien de dossier, au même commit : `"@indos/bibliotheque": "file:../../indos/bibliotheque"`. Le lien se résout hors de `node_modules` : ni `install-links` ni `--preserve-symlinks`. Les dépendances de la bibliothèque s'installent par son propre `package-lock.json` ; une version qui en ajoute une demande `npm install` dans chaque app. Ce que les tests d'une app prennent hors de `src/`, comme le Radicale d'essai (`radicale/`), est dans la copie.
345
+
346
+ ## Les aides des tests
347
+
348
+ Les tests de chaque app reposent sur ces aides ; ce qui reste dans ses tests lui est propre.
349
+
350
+ - Node : `lancerLeFauxCore` (sessions, annuaire, apps déclarées, notifications, `fabriquerUnJeton`), `ouvrirUneBaseDEssai` (PGlite, une connexion : `ouvrirLaBase(adresse, 1)`), `servirLApp`, `connecter` (un client MCP, comme le core qui relaie Claude), `appeler` (rend `{ erreur, refus, texte, json }`).
351
+ - Page, dans jsdom (Vitest) : `sessionDEssai`, `appDEssai`, `servir(routes)` à la place de `fetch`, `ouvrirLaPage`, `testerLEcranDesComptes`. Un test choisit dans un `Choix` par un clic sur le `combobox`, puis sur l'`option`.
352
+
353
+ ## Une app du client
354
+
355
+ Le modèle, `modeles/app-du-client/`, est une app à page qui ne prend que la bibliothèque : une migration, deux outils, un écran, ses tests, son `Dockerfile` et son `Dockerfile.dockerignore`, sans `package-lock.json`. `creer-une-app <nom>` le copie dans `code/<nom>/` du dépôt d'un OS, y pose le nom et cite le paquet à la version d'indos ; elle refuse un dossier qui existe et un nom hors de `^[a-z][a-z0-9-]*$`, et se lance avant toute installation.
356
+
357
+ Les gestes sont les skills `indos-creer-une-app` et `indos-publier-une-app` et la méthode `indos/METHODE.md`. Une app se développe sur une branche de son dépôt ; le clone de l'OS reste sur `main`, d'où elle se publie. La première publication écrit l'entrée de l'app dans `os.json` (`installer <app> <commit>` du kit) : ni `os.json`, ni `apps/`, ni `indos/` ne se modifient à la main.
358
+
359
+ ## La note des versions
360
+
361
+ `indos/CHANGELOG.md` s'écrit pour le développeur d'une app du client : une section `## <version>` par version, une rubrique « Ruptures » quand une version demande un geste dans les apps (et, pour une majeure, le core qu'elle demande), et « Pour monter : la PR de la copie, puis… ». Monter une app : sur la branche de la copie, les gestes des ruptures de chaque version sautée, puis la version du paquet dans `package.json`, `npm install` et `npm test` dans l'app.
package/LICENSE CHANGED
@@ -1,21 +1,7 @@
1
- MIT License
1
+ Copyright (c) 2026 AVQN. Tous droits réservés.
2
2
 
3
- Copyright (c) 2026 AVQN
3
+ Ce code est remis au client d'AVQN dans le dépôt de son OS.
4
4
 
5
- Permission is hereby granted, free of charge, to any person obtaining a copy
6
- of this software and associated documentation files (the "Software"), to deal
7
- in the Software without restriction, including without limitation the rights
8
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
- copies of the Software, and to permit persons to whom the Software is
10
- furnished to do so, subject to the following conditions:
5
+ Le client peut l'utiliser et le modifier pour les besoins de son entreprise, pendant la maintenance et après. Une personne qu'il charge de ce travail peut y travailler pour son compte.
11
6
 
12
- The above copyright notice and this permission notice shall be included in all
13
- copies or substantial portions of the Software.
14
-
15
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
- SOFTWARE.
7
+ Il ne peut ni le redistribuer, ni le revendre, ni le céder à un tiers, modifié ou non.
package/README.md CHANGED
@@ -1,15 +1,10 @@
1
- # @indos/bibliotheque
1
+ # La bibliothèque d'Indos
2
2
 
3
- La bibliothèque des apps d'Indos : le serveur HTTP d'une app, son MCP, sa base Postgres et ses migrations, la session du core, et la page de l'espace en React, avec sa coquille, ses composants et sa commande de build, `page-de-l-espace`.
3
+ Le code que les apps d'Indos partagent : le serveur d'une app, son MCP, sa base et ses migrations, la session du core, et la page de l'espace en React, avec sa coquille et ses composants. Elle vit dans `indos/bibliotheque/` du dépôt de l'OS, à la version d'`indos/manifeste.json` ; `indos/CHANGELOG.md` dit ce que change chaque version.
4
4
 
5
- Une app du client part du modèle que porte ce paquet, à sa version :
5
+ - `CLAUDE.md` : le contrat d'une app, à lire avant d'en écrire une.
6
+ - `modeles/app-du-client/` : le modèle d'une app, que copie `node indos/bibliotheque/bin/bibliotheque.ts creer-une-app <nom>`.
6
7
 
7
- ```sh
8
- npx @indos/bibliotheque creer-une-app <nom> [<dossier>]
9
- ```
8
+ Avant toute app, et après chaque nouvelle version : `npm ci` dans `indos/bibliotheque/`.
10
9
 
11
- La commande le copie dans un dossier neuf, `./<nom>` par défaut, et y cite ce paquet à version exacte ; le `README.md` de l'app dit la suite. Avec le paquet, npm installe dans l'app React, Vite, TanStack et les outils de test, à ses versions exactes : l'app ne les liste pas. Son image s'installe par `npm ci --omit=dev --omit=peer` et n'a que ce que le serveur lance.
12
-
13
- Chaque version est décrite dans `CHANGELOG.md` ; une version qui demande un geste dans l'app le dit dans sa rubrique « Ruptures ».
14
-
15
- Licence MIT : voir `LICENSE`.
10
+ Licence : tous droits réservés, AVQN (`indos/LICENSE`).
@@ -1,12 +1,13 @@
1
1
  #!/usr/bin/env node
2
2
  // La page de l'espace d'une pièce, lancée dans le dossier de la pièce par ses commandes npm
3
- // (bibliotheque/CLAUDE.md, « Écrire une page »), par le lien de la bibliothèque dans ses
3
+ // (indos/bibliotheque/CLAUDE.md, « Écrire une page »), par le lien de la bibliothèque dans ses
4
4
  // `node_modules` (`node node_modules/@indos/bibliotheque/bin/page-de-l-espace.ts <commande>`) :
5
5
  // - `construire` (`npm run build`) écrit le dossier construit, `dist/` ;
6
- // - `developper` (`npm run dev`) la sert à chaud sur http://localhost:5173, reliée au core de
7
- // `INDOS_CORE` et, pour une app, à l'app lancée en local à `INDOS_APP` ;
6
+ // - `developper` (`npm run dev`) la sert à chaud sur http://localhost:<port>, le port de
7
+ // `INDOS_PORT`, 5173 par défaut, reliée au core de `INDOS_CORE` et, pour une app, à l'app lancée
8
+ // en local à `INDOS_APP` ;
8
9
  // - `tester` lance ses tests de Vitest, `tests/espace/**/*.test.tsx`.
9
- import { construireLaPage, developperLaPage, testerLaPage } from '../src/vite.js';
10
+ import { construireLaPage, developperLaPage, portDeDeveloppement, testerLaPage } from '../src/vite.js';
10
11
  const [commande] = process.argv.slice(2);
11
12
  const dossier = process.cwd();
12
13
  if (commande === 'construire') {
@@ -15,10 +16,15 @@ if (commande === 'construire') {
15
16
  else if (commande === 'developper') {
16
17
  const core = process.env.INDOS_CORE;
17
18
  if (!core) {
18
- console.error('INDOS_CORE manque : le core auquel relier la page, le banc d\'essai (https://essai-sources.indos.ch) ou un core local.');
19
+ console.error('INDOS_CORE manque : le core auquel relier la page, celui de l\'espace où l\'app est installée (https://<domaine>) ou un core local.');
19
20
  process.exit(1);
20
21
  }
21
- await developperLaPage(dossier, { core, app: process.env.INDOS_APP ?? 'http://localhost:3000' });
22
+ const port = Number(process.env.INDOS_PORT ?? portDeDeveloppement);
23
+ if (!Number.isInteger(port) || port < 1 || port > 65535) {
24
+ console.error(`INDOS_PORT n'est pas un port : ${process.env.INDOS_PORT}. Un nombre de 1 à 65535, comme 5174.`);
25
+ process.exit(1);
26
+ }
27
+ await developperLaPage(dossier, { core, app: process.env.INDOS_APP ?? 'http://localhost:3000', port });
22
28
  }
23
29
  else if (commande === 'tester') {
24
30
  await testerLaPage(dossier);
package/package.json CHANGED
@@ -1,8 +1,8 @@
1
1
  {
2
2
  "name": "@indos/bibliotheque",
3
- "version": "2.4.0",
3
+ "version": "4.0.0",
4
4
  "description": "La bibliothèque des apps d'Indos : le serveur, le MCP, la base et la page de l'espace d'une app.",
5
- "license": "MIT",
5
+ "license": "SEE LICENSE IN LICENSE",
6
6
  "type": "module",
7
7
  "engines": {
8
8
  "node": ">=24"
@@ -16,6 +16,10 @@
16
16
  "types": "./src/appeler.d.ts",
17
17
  "default": "./src/appeler.js"
18
18
  },
19
+ "./notifier": {
20
+ "types": "./src/notifier.d.ts",
21
+ "default": "./src/notifier.js"
22
+ },
19
23
  "./base": {
20
24
  "types": "./src/base.d.ts",
21
25
  "default": "./src/base.js"
@@ -131,8 +135,7 @@
131
135
  "./ui/theme.css": "./src/ui/theme.css"
132
136
  },
133
137
  "bin": {
134
- "page-de-l-espace": "./bin/page-de-l-espace.js",
135
- "bibliotheque": "./bin/bibliotheque.js"
138
+ "page-de-l-espace": "./bin/page-de-l-espace.js"
136
139
  },
137
140
  "dependencies": {
138
141
  "@hocuspocus/common": "4.7.1",
@@ -143,26 +146,26 @@
143
146
  "pg": "8.23.1",
144
147
  "ws": "8.21.3",
145
148
  "y-protocols": "1.0.7",
146
- "yjs": "13.6.32"
149
+ "yjs": "13.6.33"
147
150
  },
148
151
  "peerDependencies": {
149
152
  "react": "19.3.1",
150
153
  "react-dom": "19.3.1",
151
154
  "radix-ui": "1.8.1",
152
155
  "tailwind-merge": "3.7.0",
153
- "tailwindcss": "4.3.3",
154
- "@tailwindcss/vite": "4.3.3",
156
+ "tailwindcss": "4.3.5",
157
+ "@tailwindcss/vite": "4.3.5",
155
158
  "@vitejs/plugin-react": "6.1.2",
156
- "vite": "8.3.5",
157
- "@tanstack/react-router": "1.170.44",
158
- "@tanstack/react-query": "5.104.2",
159
+ "vite": "8.3.7",
160
+ "@tanstack/react-router": "1.170.46",
161
+ "@tanstack/react-query": "5.104.5",
159
162
  "vitest": "5.0.5",
160
163
  "@testing-library/react": "16.3.3",
161
164
  "@testing-library/dom": "10.4.2",
162
- "@testing-library/user-event": "14.6.8",
165
+ "@testing-library/user-event": "14.6.9",
163
166
  "jsdom": "30.1.3",
164
- "@electric-sql/pglite": "0.5.10",
165
- "@electric-sql/pglite-socket": "0.2.13",
167
+ "@electric-sql/pglite": "0.5.16",
168
+ "@electric-sql/pglite-socket": "0.2.19",
166
169
  "@modelcontextprotocol/client": "2.3.1",
167
170
  "@types/react": "19.3.0",
168
171
  "@types/react-dom": "19.3.0",
package/src/app.js CHANGED
@@ -43,8 +43,8 @@ export function demarrer(nom, traiter) {
43
43
  // L'arrêt de l'app ne dure pas plus de huit secondes : Docker la coupe au bout de dix.
44
44
  export const delaiDArret = 8_000;
45
45
  export async function demarrerLApp(options) {
46
- const manifeste = JSON.parse(readFileSync(new URL('module.json', options.dossier), 'utf8'));
47
- const instructions = readFileSync(new URL('USAGE.md', options.dossier), 'utf8').trim();
46
+ const manifeste = JSON.parse(readFileSync(new URL('manifeste.json', options.dossier), 'utf8'));
47
+ const instructions = readFileSync(new URL('GUIDE.md', options.dossier), 'utf8').trim();
48
48
  const { nom } = manifeste;
49
49
  const adresse = lireLAdresse(nom);
50
50
  const prefixe = new URL(adresse).pathname.replace(/\/$/, '');
package/src/appeler.js CHANGED
@@ -4,10 +4,9 @@
4
4
  export function estUnRefus(resultat) {
5
5
  return resultat.isError === true && resultat._meta?.['indos/refus'] === true;
6
6
  }
7
- // L'appel d'une app à l'outil d'une autre, pour une personne, par le core (docs/architecture.md,
8
- // « Les apps entre elles »). `par` est le nom de l'app qui appelle ; elle déclare dans son
9
- // module.json les apps qu'elle appelle (`appelle`), et le kit lui passe alors la clé commune des
10
- // apps dans CLE_D_APPEL. Le résultat est celui de l'outil, refus compris ; une erreur ne vient que
7
+ // L'appel d'une app à l'outil d'une autre, pour une personne, par le core (indos/bibliotheque/CLAUDE.md,
8
+ // « Les pièces »). `par` est le nom de l'app qui appelle ; le kit passe la clé commune des apps dans
9
+ // CLE_D_APPEL à toute app dont le compose la cite. Le résultat est celui de l'outil, refus compris ; une erreur ne vient que
11
10
  // d'un appel que le core refuse (clé, personne ou app inconnue) ou qui n'aboutit pas.
12
11
  export function creerLAppel(par, adresseDuCore = process.env.CORE_ADRESSE, cle = process.env.CLE_D_APPEL) {
13
12
  return async function appeler(app, outil, arguments_, personne) {
@@ -15,7 +14,7 @@ export function creerLAppel(par, adresseDuCore = process.env.CORE_ADRESSE, cle =
15
14
  throw new Error('La variable CORE_ADRESSE manque : l\'adresse interne du core vient du kit.');
16
15
  }
17
16
  if (!cle) {
18
- throw new Error(`La variable CLE_D_APPEL manque : ${par} doit déclarer ${app} dans « appelle » de son module.json.`);
17
+ throw new Error(`La variable CLE_D_APPEL manque : le compose de ${par} doit la citer, pour appeler ${app}.`);
19
18
  }
20
19
  const reponse = await fetch(new URL('/appeler', adresseDuCore), {
21
20
  method: 'POST',