@nodefony/documentation 10.0.0-alpha.1

package/README.md

@@ -0,0 +1,168 @@
+# @nodefony/documentation
+
+**Data plane de documentation transverse de Nodefony** — un module _headless_ (back pur) qui indexe
+toute la documentation du projet, résout des variables dynamiques côté serveur, et l'expose en JSON
+sous `/nodefony/documentation/api/*`.
+
+Il ne rend **aucune page HTML**. Le rendu est laissé au consommateur : le front Studio (page React),
+un générateur de site statique, ou le pipeline RAG. Le module se contente de fournir un **index** et
+le **contenu résolu** des pages.
+
+## Ce qu'il indexe
+
+Conformément à [ADR-0001](https://github.com/nodefony/nodefony-core/blob/claude-ts/docs/adr/0001-docs-modules-emplacement-hybride.md) (emplacement
+hybride), la doc vit à deux endroits, et les deux sont scannés :
+
+1. **`docs/` racine** — la doc transverse, qui n'appartient à aucun module (guides, ADR, audits, releases).
+2. **`<module>/docs/*.md`** — la doc co-localisée à chaque module (`src/packages/@nodefony/<m>/docs/`,
+   `src/nodefony/docs/`). Activable/désactivable via `scan.includeModules`.
+
+## Installation / activation
+
+Le module est déclaré dans les `@modules()` de l'application, **après** `@nodefony/framework`
+(dépendance des décorateurs `@controller`) et **avant** `@nodefony/studio` (dont le front consomme ce
+data plane) :
+
+```ts
+// index.ts (racine app)
+@modules([
+  // …
+  "@nodefony/documentation",
+  "@nodefony/studio",
+])
+```
+
+## Configuration
+
+Surcharge depuis la config applicative sous la clé `module-documentation` (fusion récursive) :
+
+```ts
+// src/modules/app/nodefony/config/config.ts
+export default {
+  "module-documentation": {
+    scan: { includeModules: false }, // racine seule
+    repo: { url: "https://github.com/acme/app", editPathPrefix: "blob" },
+    cache: { ttlMs: 0 }, // rescan à chaque requête (dev)
+  },
+};
+```
+
+<!-- prettier-ignore -->
+| Option | Défaut | Rôle |
+| --- | --- | --- |
+| `enabled` | `true` | Active le data plane au boot |
+| `scan.rootDir` | `"docs"` | Dossier de doc transverse, relatif à `kernel.path` |
+| `scan.includeModules` | `true` | Scanne aussi les `<module>/docs/*.md` |
+| `scan.exclude` | `["session-retros","node_modules","dist"]` | Segments de chemin ignorés |
+| `repo.url` | dépôt nodefony-core | Base du lien « Modifier sur GitHub » (URL publique) |
+| `repo.branch` | _(auto)_ | Branche du lien ; si omise → branche git réelle (`GitService`) |
+| `repo.editPathPrefix` | `"edit"` | Segment GitHub : `edit` / `blob` / `tree` |
+| `cache.ttlMs` | `30000` | TTL (ms) du cache de l'**index** ; `0` = pas de cache |
+
+**Variables d'environnement** (précédence maximale, utiles en CI/conteneur sans `.git`) :
+`DOCS_REPO_URL`, `DOCS_REPO_BRANCH`.
+
+## API HTTP
+
+### `GET /nodefony/documentation/api/tree`
+
+Index transverse — sections (par dossier racine, et par module) → pages, taguées par audience.
+
+```jsonc
+{
+  "generatedAt": "2026-05-31T…",
+  "audiences": [{ "key": "developer", "label": "Développeur", "desc": "…" }, …],
+  "sections": [
+    { "id": "root-guides", "label": "Guides", "pages": [{ "slug": "root~guides~intro", "title": "Intro", "audience": [] }] },
+    { "id": "mod-http", "label": "Module @nodefony/http", "module": "@nodefony/http", "pages": [ … ] }
+  ]
+}
+```
+
+### `GET /nodefony/documentation/api/page/{slug}`
+
+Contenu d'une page : markdown sans frontmatter, variables `{{ }}` résolues, lien source assemblé.
+
+```jsonc
+{
+  "slug": "mod~http~index",
+  "title": "…",
+  "version": "10.0.0",
+  "status": "stable",
+  "updated": "2026-05-31",
+  "source": "src/packages/@nodefony/http/docs/index.md",
+  "sourceUrl": "https://github.com/nodefony/nodefony-core/edit/claude-ts/…",
+  "markdown": "# …",
+}
+```
+
+Slug inconnu ou non sûr → **404** avec un corps générique (`{ "slug": "…", "error": "Document inconnu." }`).
+
+## Schéma de slug
+
+Le slug est un identifiant **URL-safe sur un seul segment** (`{slug}` dans la route). C'est une **clé
+d'allowlist**, jamais un chemin de fichier.
+
+| Source | Exemple de fichier               | Slug                          |
+| ------ | -------------------------------- | ----------------------------- |
+| Racine | `docs/guides/session-storage.md` | `root~guides~session-storage` |
+| Module | `@nodefony/http/docs/index.md`   | `mod~http~index`              |
+
+Le `/` devient `~` ; le scope npm (`@nodefony/`) est retiré.
+
+## Frontmatter supporté
+
+Bloc optionnel en tête de fichier, encadré de `---`. YAML **plat** uniquement (clé → scalaire ou liste) :
+
+```markdown
+---
+title: La Socket Nodefony
+audience: [developer, devops]
+version: "10.0.0"
+status: stable
+updated: 2026-05-31
+---
+
+# Contenu…
+```
+
+Champs lus : `title`, `audience` (parmi `developer`/`devops`/`supervisor`/`admin`), `version`,
+`status` (`stable`/`draft`/`temporary`/`experimental`/`deprecated`), `updated`, `source`.
+Non supporté (volontaire) : objets imbriqués, blocs multilignes `|`/`>`, ancres YAML.
+
+## Variables dynamiques `{{ }}`
+
+Le serveur remplace `{{ name }}` dans le markdown par la valeur d'un fournisseur enregistré. Built-in :
+`{{ version }}`, `{{ branch }}`, `{{ commit }}`. Un nom inconnu est laissé tel quel (signale à l'auteur
+qu'il manque un provider). Enregistrer une variable :
+
+```ts
+documentationService.registerVar("rps", () => String(computeRps()));
+```
+
+> ⚠️ Un provider doit retourner une valeur **sûre** (publique, dérivée) — jamais un secret ni un
+> chemin FS absolu.
+
+## Sécurité
+
+- Le slug est validé (`isSafeSlug`) **avant** toute recherche ou lecture : rejet de `..`, `/`, `\`,
+  octet nul, charset non autorisé, longueur > 512.
+- La lecture se fait toujours sur le **chemin réel** mémorisé au scan, jamais reconstruit depuis le slug.
+- Les erreurs renvoient un message **générique** au client ; le détail est journalisé côté serveur.
+
+## Briques pures réutilisables
+
+Exportées pour un futur générateur de site statique ou le RAG (testées unitairement) :
+`parseFrontmatter`, `metaString`, `metaList`, `scanDocsDir`, `isSafeSlug`, `pathToSlug`.
+
+## Développement
+
+```bash
+cd src/packages/@nodefony/documentation
+npm test            # vitest — briques pures (frontmatter / slug / docScanner)
+npm run build       # rolldown + tsgo → dist/ + dist/types
+```
+
+## Licence
+
+CeCILL-B — Christophe CAMENSULI.

package/dist/_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { __decorate as default };

package/dist/_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js

@@ -0,0 +1,6 @@
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+export { __decorateMetadata as default };

package/dist/_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateParam.js

@@ -0,0 +1,8 @@
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+export { __decorateParam as default };

package/dist/index.js

@@ -0,0 +1,75 @@
+import config, { documentationConfigSchema } from "./nodefony/config/config.js";
+import { defineDocumentationConfig, documentationConfigJsonSchema } from "./nodefony/config/defineModuleConfig.js";
+import { metaList, metaString, parseFrontmatter } from "./nodefony/src/frontmatter.js";
+import { isSafeSlug, pathToSlug } from "./nodefony/src/slug.js";
+import { scanDocsDir } from "./nodefony/src/docScanner.js";
+import { rewriteInternalLinks } from "./nodefony/src/linkResolver.js";
+import { extractSearchText, foldText, searchDocs, splitSearchTerms } from "./nodefony/src/search.js";
+import { DocNotFoundError, DocUnsafeSlugError, DocumentationError } from "./nodefony/src/errors/DocumentationError.js";
+import DocumentationService, { ROOT_GROUPS, ROOT_PAGES } from "./nodefony/service/DocumentationService.js";
+import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import DocumentationController_default from "./nodefony/controller/DocumentationController.js";
+import { GitService, Kernel, Module, services } from "nodefony";
+import { controllers } from "@nodefony/framework";
+//#region index.ts
+/**
+* @nodefony/documentation — Data plane de documentation transverse de Nodefony.
+*
+* Module **headless** (back pur) : il indexe la documentation co-localisée
+* (`docs/` racine transverse + `<module>/docs/*.md`, ADR-0001), résout les
+* variables dynamiques `{{ }}` côté serveur, et expose le tout sous
+* `/nodefony/documentation/api/*`. Il ne rend AUCUN HTML — le front Studio (et,
+* demain, un générateur de site statique ou le RAG P12) consomme ce data plane.
+*
+* Pourquoi un module dédié (et pas un simple controller Studio) : la doc porte
+* de l'**état** (index scanné, cache TTL, registre de providers `{{ }}`) → un
+* cycle de vie propre, hors hot path request (tout lazy). Cf
+* [[project_doc_portal_faisabilite]].
+*
+* Voir aussi : CLAUDE.md (décisions figées), MEMORY.md (internals IA),
+* README.md (usage humain), docs/ (doc vulgarisée surfacée dans Studio).
+*/
+let Documentation = class Documentation extends Module {
+	/** Module optionnel : un échec de son boot ne tue jamais le process (résilience Ph.3). */
+	static critical = false;
+	constructor(kernel) {
+		super("documentation", kernel, import.meta.url, config);
+	}
+	/** JSON Schema de la config documentation → data plane admin (config riche Studio). */
+	configSchema() {
+		return documentationConfigJsonSchema();
+	}
+	/**
+	* Phase `onRegister` : valide la config (défauts + override `module-documentation`
+	* + env) via `defineDocumentationConfig`, puis la ré-assigne à `this.options`
+	* AVANT l'instanciation du `@services` (phase `onBoot`). Plante propre avec
+	* messages clairs si la config est invalide (convention Zod figée 2026-05-28).
+	*/
+	async onKernelRegister() {
+		this.options = defineDocumentationConfig(this.options);
+		return this;
+	}
+	/**
+	* Phase `onReady` : enregistre les fournisseurs de variables `{{ }}` built-in
+	* sur le service (tous les modules sont alors bootés). Sources SÛRES seulement
+	* (version, identité git) — jamais de secret ni de chemin FS absolu.
+	*/
+	async onKernelReady() {
+		const svc = this.get("documentation");
+		if (!svc) return this;
+		const root = this.kernel?.path;
+		svc.registerVar("version", () => this.kernel?.version ?? "");
+		svc.registerVar("branch", () => GitService.branch(root));
+		svc.registerVar("commit", () => GitService.read(root).commit);
+		return this;
+	}
+};
+Documentation = __decorate([
+	services([DocumentationService]),
+	controllers([DocumentationController_default]),
+	__decorateMetadata("design:paramtypes", [typeof Kernel === "undefined" ? Object : Kernel])
+], Documentation);
+var documentation_default = Documentation;
+//#endregion
+export { DocNotFoundError, DocUnsafeSlugError, DocumentationController_default as DocumentationController, DocumentationError, DocumentationService, ROOT_GROUPS, ROOT_PAGES, documentation_default as default, defineDocumentationConfig, documentationConfigJsonSchema, documentationConfigSchema, extractSearchText, foldText, isSafeSlug, metaList, metaString, parseFrontmatter, pathToSlug, rewriteInternalLinks, scanDocsDir, searchDocs, splitSearchTerms };

package/dist/nodefony/config/config.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+//#region nodefony/config/config.ts
+/**
+* @nodefony/documentation — CONFIGURATION DU MODULE (schéma Zod = source unique).
+*
+* ⭐ TL;DR : CE SCHÉMA EST LA CONFIG. Chaque `.default(...)` = la valeur d'usine ;
+* changer un défaut du module = ÉDITER ICI (et nulle part ailleurs). L'app, elle,
+* surcharge via `use("@nodefony/...", { … })` dans SON `nodefony.config.ts`.
+*
+* RÈGLE D'OR (ADR-0006) : ce fichier porte le **schéma Zod commenté** (type +
+* validation + défaut + doc) ET matérialise les défauts via `parse({})`. Aucune
+* valeur n'est re-tapée ailleurs. Le builder (`defineModuleConfig.ts` →
+* `defineDocumentationConfig`) importe le schéma D'ICI (nœud bas : ce fichier
+* n'importe que `zod` → pas de cycle).
+*
+* La config est validée au boot du Module class (hook `onKernelRegister`, via
+* le builder {@link defineDocumentationConfig}) → plante propre avec messages
+* clairs si la config est invalide, plutôt qu'un `undefined.x` silencieux.
+*
+* ⚠️ ENV : ce schéma reste PUR (pas de lecture `process.env` ici, sinon il
+* deviendrait non déterministe et non sérialisable en JSON Schema pour Studio).
+* La surcharge par variables d'environnement (`DOCS_REPO_URL`,
+* `DOCS_REPO_BRANCH`) est appliquée dans {@link defineDocumentationConfig},
+* APRÈS le parse.
+*
+* SURCHARGE PAR L'APPLICATION (fusion récursive) :
+*
+*   // nodefony.config.ts
+*   use("@nodefony/documentation", {
+*     scan: { includeModules: false },
+*     repo: { url: "https://github.com/acme/app", editPathPrefix: "blob" },
+*     cache: { ttlMs: 0 },
+*   })
+*
+* ⚠️ NE PAS éditer les défauts matérialisés en bas de fichier : modifier les
+* `.default(...)` du schéma. La validation + le merge env finaux sont faits dans
+* `index.ts` au hook `onKernelRegister` via `defineDocumentationConfig`.
+*/
+const scanSchema = z.strictObject({
+	rootDir: z.string().min(1).default("docs").describe("Dossier de documentation transverse, relatif à la racine du projet (`kernel.path`). Défaut `docs`. Scanné récursivement pour les `.md`. C'est la doc qui n'appartient à aucun module (guides, ADR, audits)."),
+	includeModules: z.boolean().default(true).describe("Scanne aussi les `<module>/docs/*.md` co-localisés à chaque module chargé (ADR-0001 : la doc d'un module vit DANS le module). true = index transverse complet (racine + modules). false = racine seule (parité POC). La découverte des modules passe par `kernel.modules`."),
+	includeInstalled: z.boolean().default(true).describe("Scanne aussi la doc des paquets Nodefony INSTALLÉS mais pas encore chargés (`node_modules/@nodefony/*/docs` + le cœur `nodefony`). Sans cela, la doc d'un module non activé est introuvable — alors que c'est précisément le moment où on la lit : pour décider de l'activer. Les chemins sont résolus en real-path, donc un lien de workspace pointe vers la source, pas vers le lien symbolique."),
+	exclude: z.array(z.string().min(1)).default([
+		"session-retros",
+		"node_modules",
+		"dist"
+	]).describe("Noms de segments de chemin EXCLUS du scan (comparaison par segment, pas par préfixe). Défaut : retex de session, deps et build. Évite de surfacer du bruit ou des fichiers générés dans le portail.")
+}).describe("Sources scannées pour construire l'index transverse de la doc.");
+const repoSchema = z.strictObject({
+	url: z.string().min(1).default("https://github.com/nodefony/nodefony-core").describe("URL de base du dépôt (sans slash final), pour construire le lien « Modifier sur GitHub » d'une page. Surchargeable par l'env `DOCS_REPO_URL`. Aucun secret — URL publique uniquement."),
+	branch: z.string().min(1).optional().describe("Branche utilisée dans le lien d'édition. Si OMISE (défaut), la branche RÉELLE est résolue au runtime via `GitService.branch()` du core (lecture `.git/HEAD`, 0 spawn) → le lien suit toujours la branche courante. Surchargeable par l'env `DOCS_REPO_BRANCH` (utile en CI/prod détaché de git, ex. conteneur sans `.git`)."),
+	editPathPrefix: z.enum([
+		"edit",
+		"blob",
+		"tree"
+	]).default("edit").describe("Segment GitHub du lien source : `edit` (éditeur web), `blob` (lecture du fichier), `tree` (dossier). Défaut `edit`.")
+}).describe("Identité du dépôt pour les liens d'édition des pages.");
+const cacheSchema = z.strictObject({ ttlMs: z.number().int().nonnegative().default(3e4).describe("Durée de vie (ms) du cache de l'index (l'arbre des pages). Le scan FS n'est refait qu'à l'expiration. Défaut 30 s. 0 = pas de cache (chaque requête rescanne — pratique en dev pour voir un nouveau `.md` immédiatement). Le contenu d'une page n'est PAS caché (toujours relu).") }).describe("Politique de cache de l'index (chemin froid admin, lazy).");
+const documentationConfigSchema = z.strictObject({
+	enabled: z.boolean().default(true).describe("Active le data plane de documentation au boot. false = module chargé mais inerte (endpoints inactifs) — utile pour couper la doc en prod si non désirée."),
+	scan: scanSchema.default(() => scanSchema.parse({})),
+	repo: repoSchema.default(() => repoSchema.parse({})),
+	cache: cacheSchema.default(() => cacheSchema.parse({}))
+}).describe("Configuration de @nodefony/documentation.");
+/**
+* Défauts du module, matérialisés depuis le schéma (source unique). Toujours
+* valides par construction ; passés au `super(..., config)` du Module class.
+*/
+const config = documentationConfigSchema.parse({});
+//#endregion
+export { config as default, documentationConfigSchema };

package/dist/nodefony/config/defineModuleConfig.js

@@ -0,0 +1,49 @@
+import { documentationConfigSchema } from "./config.js";
+import { parseModuleConfig } from "nodefony";
+import { z } from "zod";
+//#region nodefony/config/defineModuleConfig.ts
+/**
+* @nodefony/documentation — Builder de configuration validée (Zod) + ENV.
+*
+* ⭐ TL;DR : MACHINERIE DE BOOT — on n'édite (presque) jamais ce fichier. Même
+* pattern que `nodefony.config.ts` ↔ `defineConfig()` du core : `config.ts` PORTE
+* la config (schéma + défauts), `define<X>Config()` la VALIDE au boot (parse +
+* env + freeze) et publie le JSON Schema Studio.
+*
+* Sépare la VALIDATION (schéma pur de `config.ts`) de l'APPLICATION des variables
+* d'environnement : le schéma reste déterministe (sérialisable en JSON Schema
+* pour Studio), et l'env est appliqué APRÈS le parse, ici.
+*
+* @see ./config.ts — source de vérité (types dérivés via z.infer)
+*/
+/** Lit une variable d'env non vide, ou `undefined` si absente/vide. */
+function env(name) {
+	const v = process.env[name];
+	return v && v.trim() !== "" ? v.trim() : void 0;
+}
+/**
+* Valide une config partielle (défauts du schéma) PUIS applique la surcharge par
+* variables d'environnement (précédence max).
+*
+* @param input - config partielle (depuis `module.options.documentation`)
+* @returns config validée, défauts appliqués, env mergé
+* @throws ZodError si l'input viole le schéma
+*/
+function defineDocumentationConfig(input = {}) {
+	const parsed = parseModuleConfig(documentationConfigSchema, input ?? {}, "@nodefony/documentation");
+	const repoUrlEnv = env("DOCS_REPO_URL");
+	if (repoUrlEnv) parsed.repo.url = repoUrlEnv;
+	const branchEnv = env("DOCS_REPO_BRANCH");
+	if (branchEnv) parsed.repo.branch = branchEnv;
+	return parsed;
+}
+/**
+* JSON Schema introspectable de la config documentation — destiné au panneau de
+* config Studio (`/nodefony/config`). N'inclut PAS la surcharge ENV (appliquée
+* hors schéma, dans le builder).
+*/
+function documentationConfigJsonSchema() {
+	return z.toJSONSchema(documentationConfigSchema);
+}
+//#endregion
+export { defineDocumentationConfig, documentationConfigJsonSchema, documentationConfigSchema };

package/dist/nodefony/controller/DocumentationController.js

@@ -0,0 +1,102 @@
+import { DocNotFoundError, DocUnsafeSlugError } from "../src/errors/DocumentationError.js";
+import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import __decorateParam from "../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateParam.js";
+import { Controller, Get, IsGranted, Param, Query, controller } from "@nodefony/framework";
+import { Context } from "@nodefony/http";
+//#region nodefony/controller/DocumentationController.ts
+/**
+* Data plane HTTP de la documentation Nodefony.
+*
+* Expose l'index transverse et le contenu des pages sous
+* `/nodefony/documentation/api/*` (convention figée : un module admin sert
+* toujours `/nodefony/<module>/api/*`, jamais une route mono-segment).
+*
+* **Mince par design** : toute la logique (scan, cache, allowlist, résolution
+* `{{ }}`) vit dans `DocumentationService` (singleton stateful). Le controller
+* est réinstancié par requête → il ne porte aucun état, il délègue.
+*
+* Sécurité (Zero Trust) : un slug invalide/inconnu renvoie un message
+* **générique** au client ; le détail (slug, raison) est loggé côté serveur.
+* La garde anti-traversée est dans le service ({@link isSafeSlug}).
+*/
+let DocumentationController = class DocumentationController extends Controller {
+	constructor(context) {
+		super("DocumentationController", context);
+	}
+	/** Résout le service de documentation depuis le container partagé. */
+	#service() {
+		const svc = this.get("documentation");
+		if (!svc) throw new Error("DocumentationService non enregistré");
+		return svc;
+	}
+	/** Index transverse : sections → pages, taguées par audience. */
+	async tree() {
+		try {
+			return this.renderJson(await this.#service().getTree());
+		} catch (e) {
+			this.log(e, "ERROR");
+			return this.renderJson({ error: "Index de documentation indisponible." }, 500);
+		}
+	}
+	/**
+	* Cherche dans le corpus — titres ET corps — et rend des extraits situés.
+	*
+	* Filtrer l'arbre ne répondait qu'à « quelle page s'appelle ainsi ? » ; la
+	* question posée est « où est-ce expliqué ? ».
+	*/
+	async search(q) {
+		try {
+			return this.renderJson(await this.#service().search(q ?? ""));
+		} catch (e) {
+			this.log(e, "ERROR");
+			return this.renderJson({ error: "Recherche indisponible." }, 500);
+		}
+	}
+	/** Contenu d'une page + variables `{{ }}` résolues côté serveur. */
+	async page(slug) {
+		try {
+			return this.renderJson(await this.#service().getPage(slug));
+		} catch (e) {
+			if (e instanceof DocNotFoundError || e instanceof DocUnsafeSlugError) {
+				this.log(`${e.docCode}: ${e.message}`, "WARNING");
+				return this.renderJson({
+					slug,
+					error: "Document inconnu."
+				}, 404);
+			}
+			this.log(e, "ERROR");
+			return this.renderJson({
+				slug,
+				error: "Lecture de la page impossible."
+			}, 500);
+		}
+	}
+};
+__decorate([
+	IsGranted(["ROLE_DEV", "ROLE_SUPERVISOR"]),
+	Get("/documentation/api/tree"),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", []),
+	__decorateMetadata("design:returntype", Promise)
+], DocumentationController.prototype, "tree", null);
+__decorate([
+	IsGranted(["ROLE_DEV", "ROLE_SUPERVISOR"]),
+	Get("/documentation/api/search"),
+	__decorateParam(0, Query("q")),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", Promise)
+], DocumentationController.prototype, "search", null);
+__decorate([
+	IsGranted(["ROLE_DEV", "ROLE_SUPERVISOR"]),
+	Get("/documentation/api/page/{slug}"),
+	__decorateParam(0, Param("slug")),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", Promise)
+], DocumentationController.prototype, "page", null);
+DocumentationController = __decorate([controller("/nodefony"), __decorateMetadata("design:paramtypes", [typeof Context === "undefined" ? Object : Context])], DocumentationController);
+var DocumentationController_default = DocumentationController;
+//#endregion
+export { DocumentationController_default as default };

package/dist/nodefony/interfaces/IDocumentation.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/index.js

@@ -0,0 +1 @@
+export {};