@jjlmoya/utils-developer 1.15.0 → 1.17.0

package/src/tool/jwtDecoder/i18n/es.ts

@@ -0,0 +1,248 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { JwtDecoderUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'decodificador-jwt-parser-e-inspector-de-claims';
+const title = 'Decodificador JWT, Parser e Inspector de Claims';
+const description = 'Pega un JSON Web Token, decodifica su cabecera y payload al instante, inspecciona claims registrados, detecta tokens expirados y copia JSON limpio para depurar flujos de autenticación.';
+
+const howTo = [
+  {
+    name: 'Pega el JWT',
+    text: 'Copia un token de una cabecera Authorization, cookie, entrada de log o proveedor de identidad y pégalo en el campo de entrada.',
+  },
+  {
+    name: 'Lee la cabecera y el payload decodificados',
+    text: 'La herramienta divide el token en cabecera, payload y firma, luego muestra los segmentos JSON en paneles separados para una inspección rápida.',
+  },
+  {
+    name: 'Comprueba los claims importantes',
+    text: 'Revisa el algoritmo, emisor, audiencia, sujeto, fecha de emisión, fecha de validez inicial y fecha de expiración sin convertir manualmente timestamps Unix.',
+  },
+  {
+    name: 'Copia los datos que necesitas',
+    text: 'Copia una sección decodificada o la salida decodificada completa cuando necesites compartir una instantánea de depuración saneada con tu equipo.',
+  },
+];
+
+const faq = [
+  {
+    question: '¿Decodificar un JWT demuestra que el token es válido?',
+    answer: 'No. Decodificar solo revela la cabecera y el payload codificados en base64url. Un token es confiable solo después de que la firma, el emisor, la audiencia, la expiración y los claims relacionados sean validados por la aplicación o el proveedor de identidad.',
+  },
+  {
+    question: '¿Puedo usar este decodificador JWT para access tokens e ID tokens?',
+    answer: 'Sí. El decodificador es útil para inspeccionar access tokens OAuth, ID tokens OpenID Connect, tokens de sesión y tokens servicio a servicio, siempre que usen el formato JWT estándar de tres partes.',
+  },
+  {
+    question: '¿Por qué el panel de firma no verifica el token?',
+    answer: 'La verificación JWT requiere el secreto correcto, la clave pública o la configuración JWKS. Esta herramienta se centra intencionadamente en la decodificación e inspección para que los desarrolladores puedan ver el contenido del token sin pretender que una cadena de firma visible es prueba de validez.',
+  },
+  {
+    question: '¿Qué debo comprobar primero al depurar un JWT?',
+    answer: 'Empieza por exp, nbf, iss, aud y alg. La mayoría de los problemas reales en producción provienen de tokens expirados, desfase de reloj, valores de audiencia incorrectos, URLs de emisor inesperadas o suposiciones inseguras sobre el algoritmo.',
+  },
+];
+
+const ui: JwtDecoderUI = {
+  tokenLabel: 'Token JWT',
+  tokenPlaceholder: 'Pega un JWT aquí: cabecera.payload.firma',
+  sampleButton: 'Cargar ejemplo',
+  clearButton: 'Limpiar',
+  statusWaiting: 'Pega un token para decodificar su cabecera JSON, payload y claims.',
+  statusValid: 'JWT decodificado correctamente.',
+  statusInvalid: 'Esto no parece un JWT válido de tres partes.',
+  statusExpired: 'JWT decodificado, pero el claim exp ya está expirado.',
+  statusUnsigned: 'JWT decodificado, pero no está firmado o usa el algoritmo none.',
+  headerTitle: 'Cabecera',
+  payloadTitle: 'Payload',
+  signatureTitle: 'Firma',
+  claimsTitle: 'Claims registrados',
+  copyHeader: 'Copiar cabecera decodificada',
+  copyPayload: 'Copiar payload decodificado',
+  copySignature: 'Copiar firma',
+  copyAll: 'Copiar todo',
+  copiedLabel: 'Copiado',
+  invalidTokenTitle: 'JWT no válido',
+  invalidTokenBody: 'Comprueba que el token tiene tres segmentos base64url separados por puntos.',
+  invalidSegmentError: 'Comprueba que el token tiene tres segmentos base64url separados por puntos.',
+  invalidDecodeError: 'La cabecera o el payload no se pudieron decodificar como JSON válido.',
+  emptyJson: '{}',
+  signaturePresent: 'El segmento de firma está presente; verifícalo en tu capa de autenticación con la clave correcta.',
+  signatureMissing: 'Sin segmento de firma',
+  algorithmLabel: 'Algoritmo',
+  typeLabel: 'Tipo',
+  issuerLabel: 'Emisor',
+  subjectLabel: 'Sujeto',
+  audienceLabel: 'Audiencia',
+  issuedAtLabel: 'Emitido el',
+  notBeforeLabel: 'No antes del',
+  expiresAtLabel: 'Expira el',
+  claimMissing: 'No presente',
+  privacyNote: 'La decodificación se ejecuta en tu navegador. No pegues secretos de producción en ninguna herramienta a menos que tu política de seguridad lo permita.',
+  sampleToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJnYW1lYm9iLXVzZXItNDIiLCJuYW1lIjoiR2FtZUJvYiBEZXZlbG9wZXIiLCJpc3MiOiJodHRwczovL3d3dy5nYW1lYm9iLmRldiIsImF1ZCI6ImRldmVsb3Blci10b29scyIsImlhdCI6MTcxNzIwMDAwMCwibmJmIjoxNzE3MjAwMDAwLCJleHAiOjE4OTM0NTYwMDAsInJvbGUiOiJhZG1pbiJ9.demo-signature',
+};
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faq.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: {
+      '@type': 'Answer',
+      text: item.answer,
+    },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howTo.map((step, index) => ({
+    '@type': 'HowToStep',
+    position: index + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'Any',
+  offers: {
+    '@type': 'Offer',
+    price: '0',
+    priceCurrency: 'EUR',
+  },
+  inLanguage: 'es',
+};
+
+export const content: ToolLocaleContent<JwtDecoderUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Preguntas frecuentes sobre el decodificador JWT',
+  faq,
+  bibliographyTitle: 'Especificaciones JWT y referencias de seguridad',
+  bibliography,
+  howTo,
+  schemas: [appSchema, faqSchema, howToSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Decodifica JWTs sin perder el contexto de seguridad',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Un JSON Web Token parece compacto, pero a menudo contiene el detalle exacto que explica un fallo de autenticación: el algoritmo de firma, emisor, audiencia, sujeto, fecha de emisión, fecha de validez inicial, expiración y claims de autorización específicos de la aplicación. Este <strong>decodificador JWT, parser e inspector de claims</strong> convierte los tres segmentos del token en JSON legible para que puedas depurar flujos de autenticación más rápido.',
+    },
+    {
+      type: 'diagnostic',
+      variant: 'warning',
+      title: 'Decodificado no significa confiable',
+      html: 'Cualquiera puede decodificar un JWT en base64url. La confianza comienza solo después de que tu aplicación verifique la firma con el secreto, clave pública o JWKS correctos y luego valide el emisor, la audiencia, la expiración y cualquier claim específico del dominio. Usa esta herramienta para inspeccionar datos, no para aceptar un token como auténtico.',
+    },
+    {
+      type: 'title',
+      text: 'Lo que te dice cada segmento JWT',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Segmento', 'Contenido típico', 'Valor de depuración'],
+      rows: [
+        ['Cabecera', 'Algoritmo, tipo de token e ID de clave opcional', 'Muestra si el token espera HS256, RS256, ES256 u otra estrategia de verificación.'],
+        ['Payload', 'Claims registrados y claims de aplicación', 'Revela identidad, tenant, scopes, roles, expiración y desajustes de audiencia.'],
+        ['Firma', 'Bytes de firma criptográfica codificados como base64url', 'Confirma que existe un segmento de firma, pero debe verificarse con la clave correcta en otro lugar.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Claims que suelen explicar fallos de autenticación',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>exp:</strong> si el token expiró, la lógica de renovación o la configuración del reloj pueden estar mal.',
+        '<strong>nbf:</strong> si el token aún no está activo, los relojes del servidor y del proveedor de identidad pueden estar desincronizados.',
+        '<strong>iss:</strong> si la URL del emisor difiere de la configuración, el token puede venir del tenant o entorno equivocado.',
+        '<strong>aud:</strong> si la audiencia no coincide con el identificador de la API, el token fue emitido para otro recurso.',
+        '<strong>alg:</strong> si el algoritmo es inesperado, tu verificador puede rechazar el token o exponer un error de configuración peligroso.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Casos de uso de un parser JWT durante el desarrollo',
+      level: 3,
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          title: 'Depuración frontend',
+          description: 'Inspecciona ID tokens y access tokens recibidos tras el inicio de sesión para confirmar scopes, roles y claims de perfil.',
+          icon: 'mdi:monitor-dashboard',
+          points: ['Comprueba claims de perfil', 'Confirma scopes y roles', 'Compara entornos de login'],
+        },
+        {
+          title: 'QA de API backend',
+          description: 'Compara los valores esperados de emisor y audiencia con el token realmente enviado en una cabecera Authorization.',
+          icon: 'mdi:api',
+          highlight: true,
+          points: ['Valida la forma de la audiencia', 'Detecta desajustes de emisor', 'Inspecciona bearer tokens'],
+        },
+        {
+          title: 'Configuración del proveedor de identidad',
+          description: 'Comprueba si los claims de Auth0, Azure AD, Cognito, Keycloak o un proveedor personalizado tienen la forma que tu aplicación espera.',
+          icon: 'mdi:account-key',
+          points: ['Revisa datos del tenant', 'Comprueba claims personalizados', 'Compara mapeos del proveedor'],
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Errores comunes de JWT que este inspector hace evidentes',
+      level: 3,
+    },
+    {
+      type: 'proscons',
+      title: 'Comprobaciones rápidas frente a decisiones de confianza',
+      items: [
+        {
+          pro: 'Ve tokens mal formados inmediatamente.',
+          con: 'No puede conocer tu audiencia o emisor esperados.',
+        },
+        {
+          pro: 'Convierte claims de timestamp Unix en fechas legibles.',
+          con: 'No puede verificar una firma sin el material de clave real.',
+        },
+        {
+          pro: 'Detecta valores faltantes de emisor, audiencia, sujeto o tipo.',
+          con: 'No puede demostrar que los scopes y roles son seguros para tu aplicación.',
+        },
+      ],
+    },
+    {
+      type: 'summary',
+      title: 'Flujo de trabajo recomendado',
+      items: [
+        'Decodifica el token para entender lo que el cliente o la API realmente recibieron.',
+        'Comprueba exp, nbf, iss, aud, sub y alg antes de perseguir la lógica de aplicación.',
+        'Verifica firmas y decisiones de confianza solo en tu capa de autenticación.',
+        'Evita compartir JWTs de producción sensibles en tickets, logs o capturas de pantalla.',
+      ],
+    },
+  ],
+};

package/src/tool/jwtDecoder/i18n/fr.ts

@@ -0,0 +1,248 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { JwtDecoderUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'decodeur-jwt-parser-et-inspecteur-de-claims';
+const title = 'Décodeur JWT, Parser et Inspecteur de Claims';
+const description = 'Collez un JSON Web Token, décodez son en-tête et son payload instantanément, inspectez les claims enregistrés, repérez les tokens expirés et copiez du JSON propre pour déboguer les flux d\'authentification.';
+
+const howTo = [
+  {
+    name: 'Collez le JWT',
+    text: 'Copiez un token depuis un en-tête Authorization, un cookie, une entrée de log ou un fournisseur d\'identité et collez-le dans le champ de saisie.',
+  },
+  {
+    name: 'Lisez l\'en-tête et le payload décodés',
+    text: 'L\'outil divise le token en en-tête, payload et signature, puis affiche les segments JSON dans des panneaux séparés pour une inspection rapide.',
+  },
+  {
+    name: 'Vérifiez les claims importants',
+    text: 'Examinez l\'algorithme, l\'émetteur, l\'audience, le sujet, la date d\'émission, la date de début de validité et la date d\'expiration sans convertir manuellement les timestamps Unix.',
+  },
+  {
+    name: 'Copiez les données dont vous avez besoin',
+    text: 'Copiez une section décodée ou la sortie décodée complète lorsque vous devez partager un instantané de débogage assaini avec votre équipe.',
+  },
+];
+
+const faq = [
+  {
+    question: 'Décoder un JWT prouve-t-il que le token est valide ?',
+    answer: 'Non. Le décodage révèle uniquement l\'en-tête et le payload encodés en base64url. Un token n\'est digne de confiance qu\'après que la signature, l\'émetteur, l\'audience, l\'expiration et les claims associés ont été validés par l\'application ou le fournisseur d\'identité.',
+  },
+  {
+    question: 'Puis-je utiliser ce décodeur JWT pour les access tokens et les ID tokens ?',
+    answer: 'Oui. Le décodeur est utile pour inspecter les access tokens OAuth, les ID tokens OpenID Connect, les tokens de session et les tokens service à service, tant qu\'ils utilisent le format JWT standard en trois parties.',
+  },
+  {
+    question: 'Pourquoi le panneau de signature ne vérifie-t-il pas le token ?',
+    answer: 'La vérification JWT nécessite le secret correct, la clé publique ou la configuration JWKS. Cet outil se concentre intentionnellement sur le décodage et l\'inspection afin que les développeurs puissent voir le contenu du token sans prétendre qu\'une chaîne de signature visible constitue une preuve de validité.',
+  },
+  {
+    question: 'Que dois-je vérifier en premier lors du débogage d\'un JWT ?',
+    answer: 'Commencez par exp, nbf, iss, aud et alg. La plupart des problèmes réels en production proviennent de tokens expirés, de décalage d\'horloge, de valeurs d\'audience incorrectes, d\'URL d\'émetteur inattendues ou d\'hypothèses d\'algorithme non sécurisées.',
+  },
+];
+
+const ui: JwtDecoderUI = {
+  tokenLabel: 'Token JWT',
+  tokenPlaceholder: 'Collez un JWT ici: en-tête.payload.signature',
+  sampleButton: 'Charger l\'exemple',
+  clearButton: 'Effacer',
+  statusWaiting: 'Collez un token pour décoder son en-tête JSON, son payload et ses claims.',
+  statusValid: 'JWT décodé avec succès.',
+  statusInvalid: 'Cela ne ressemble pas à un JWT valide en trois parties.',
+  statusExpired: 'JWT décodé, mais le claim exp est déjà expiré.',
+  statusUnsigned: 'JWT décodé, mais il n\'est pas signé ou utilise l\'algorithme none.',
+  headerTitle: 'En-tête',
+  payloadTitle: 'Payload',
+  signatureTitle: 'Signature',
+  claimsTitle: 'Claims enregistrés',
+  copyHeader: 'Copier l\'en-tête décodé',
+  copyPayload: 'Copier le payload décodé',
+  copySignature: 'Copier la signature',
+  copyAll: 'Tout copier',
+  copiedLabel: 'Copié',
+  invalidTokenTitle: 'JWT invalide',
+  invalidTokenBody: 'Vérifiez que le token comporte trois segments base64url séparés par des points.',
+  invalidSegmentError: 'Vérifiez que le token comporte trois segments base64url séparés par des points.',
+  invalidDecodeError: 'L\'en-tête ou le payload n\'a pas pu être décodé en JSON valide.',
+  emptyJson: '{}',
+  signaturePresent: 'Le segment de signature est présent ; vérifiez-le dans votre couche d\'authentification avec la clé appropriée.',
+  signatureMissing: 'Aucun segment de signature',
+  algorithmLabel: 'Algorithme',
+  typeLabel: 'Type',
+  issuerLabel: 'Émetteur',
+  subjectLabel: 'Sujet',
+  audienceLabel: 'Audience',
+  issuedAtLabel: 'Émis le',
+  notBeforeLabel: 'Valide à partir du',
+  expiresAtLabel: 'Expiré le',
+  claimMissing: 'Non présent',
+  privacyNote: 'Le décodage s\'exécute dans votre navigateur. Ne collez pas de secrets de production dans un outil, sauf si votre politique de sécurité l\'autorise.',
+  sampleToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJnYW1lYm9iLXVzZXItNDIiLCJuYW1lIjoiR2FtZUJvYiBEZXZlbG9wZXIiLCJpc3MiOiJodHRwczovL3d3dy5nYW1lYm9iLmRldiIsImF1ZCI6ImRldmVsb3Blci10b29scyIsImlhdCI6MTcxNzIwMDAwMCwibmJmIjoxNzE3MjAwMDAwLCJleHAiOjE4OTM0NTYwMDAsInJvbGUiOiJhZG1pbiJ9.demo-signature',
+};
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faq.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: {
+      '@type': 'Answer',
+      text: item.answer,
+    },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howTo.map((step, index) => ({
+    '@type': 'HowToStep',
+    position: index + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'Any',
+  offers: {
+    '@type': 'Offer',
+    price: '0',
+    priceCurrency: 'EUR',
+  },
+  inLanguage: 'fr',
+};
+
+export const content: ToolLocaleContent<JwtDecoderUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'FAQ du décodeur JWT',
+  faq,
+  bibliographyTitle: 'Spécifications JWT et références de sécurité',
+  bibliography,
+  howTo,
+  schemas: [appSchema, faqSchema, howToSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Décodez les JWT sans perdre le contexte de sécurité',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Un JSON Web Token semble compact, mais il contient souvent le détail exact qui explique un échec d\'authentification: l\'algorithme de signature, l\'émetteur, l\'audience, le sujet, la date d\'émission, la date de début de validité, l\'expiration et les claims d\'autorisation spécifiques à l\'application. Ce <strong>décodeur JWT, parser et inspecteur de claims</strong> transforme les trois segments du token en JSON lisible pour que vous puissiez déboguer les flux d\'authentification plus rapidement.',
+    },
+    {
+      type: 'diagnostic',
+      variant: 'warning',
+      title: 'Décodé ne signifie pas digne de confiance',
+      html: 'N\'importe qui peut décoder un JWT en base64url. La confiance ne commence qu\'après que votre application a vérifié la signature avec le secret, la clé publique ou le JWKS appropriés, puis validé l\'émetteur, l\'audience, l\'expiration et tout claim spécifique au domaine. Utilisez cet outil pour inspecter les données, pas pour accepter un token comme authentique.',
+    },
+    {
+      type: 'title',
+      text: 'Ce que chaque segment JWT vous dit',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Segment', 'Contenu typique', 'Valeur de débogage'],
+      rows: [
+        ['En-tête', 'Algorithme, type de token et ID de clé optionnel', 'Indique si le token attend HS256, RS256, ES256 ou une autre stratégie de vérification.'],
+        ['Payload', 'Claims enregistrés et claims d\'application', 'Révèle l\'identité, le tenant, les scopes, les rôles, l\'expiration et les décalages d\'audience.'],
+        ['Signature', 'Octets de signature cryptographique encodés en base64url', 'Confirme qu\'un segment de signature existe, mais doit être vérifié avec la bonne clé ailleurs.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Claims qui expliquent généralement les échecs d\'authentification',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>exp:</strong> si le token a expiré, la logique de renouvellement ou les paramètres d\'horloge peuvent être incorrects.',
+        '<strong>nbf:</strong> si le token n\'est pas encore actif, les horloges du serveur et du fournisseur d\'identité peuvent être désynchronisées.',
+        '<strong>iss:</strong> si l\'URL de l\'émetteur diffère de la configuration, le token peut provenir d\'un mauvais tenant ou environnement.',
+        '<strong>aud:</strong> si l\'audience ne correspond pas à l\'identifiant de l\'API, le token a été émis pour une autre ressource.',
+        '<strong>alg:</strong> si l\'algorithme est inattendu, votre vérificateur peut rejeter le token ou exposer une erreur de configuration dangereuse.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Cas d\'utilisation d\'un parser JWT pendant le développement',
+      level: 3,
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          title: 'Débogage frontend',
+          description: 'Inspectez les ID tokens et access tokens reçus après la connexion pour confirmer les scopes, les rôles et les claims de profil.',
+          icon: 'mdi:monitor-dashboard',
+          points: ['Vérifiez les claims de profil', 'Confirmez les scopes et rôles', 'Comparez les environnements de connexion'],
+        },
+        {
+          title: 'QA d\'API backend',
+          description: 'Comparez les valeurs attendues de l\'émetteur et de l\'audience avec le token réellement envoyé dans un en-tête Authorization.',
+          icon: 'mdi:api',
+          highlight: true,
+          points: ['Validez la forme de l\'audience', 'Repérez les décalages d\'émetteur', 'Inspectez les bearer tokens'],
+        },
+        {
+          title: 'Configuration du fournisseur d\'identité',
+          description: 'Vérifiez si les claims d\'Auth0, Azure AD, Cognito, Keycloak ou d\'un fournisseur personnalisé sont structurés comme votre application l\'attend.',
+          icon: 'mdi:account-key',
+          points: ['Examinez les données du tenant', 'Vérifiez les claims personnalisés', 'Comparez les mappings du fournisseur'],
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Erreurs JWT courantes que cet inspecteur rend évidentes',
+      level: 3,
+    },
+    {
+      type: 'proscons',
+      title: 'Vérifications rapides contre décisions de confiance',
+      items: [
+        {
+          pro: 'Voyez les tokens mal formés immédiatement.',
+          con: 'Il ne peut pas connaître votre audience ou émetteur attendu.',
+        },
+        {
+          pro: 'Convertissez les claims de timestamp Unix en dates lisibles.',
+          con: 'Il ne peut pas vérifier une signature sans le matériel de clé réel.',
+        },
+        {
+          pro: 'Repérez les valeurs manquantes d\'émetteur, d\'audience, de sujet ou de type.',
+          con: 'Il ne peut pas prouver que les scopes et les rôles sont sûrs pour votre application.',
+        },
+      ],
+    },
+    {
+      type: 'summary',
+      title: 'Flux de travail recommandé',
+      items: [
+        'Décodez le token pour comprendre ce que le client ou l\'API a réellement reçu.',
+        'Vérifiez exp, nbf, iss, aud, sub et alg avant de poursuivre la logique applicative.',
+        'Vérifiez les signatures et les décisions de confiance uniquement dans votre couche d\'authentification.',
+        'Évitez de partager des JWT de production sensibles dans les tickets, les logs ou les captures d\'écran.',
+      ],
+    },
+  ],
+};