@ktortu/aaa 0.9.0 → 0.9.2

package/progress-bar/progress-bar.css

@@ -0,0 +1,127 @@
+:host {
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  gap: var(--kt-progress-bar-gap, 8px);
+}
+
+.kt-progress-bar-label {
+  font-family: var(--kt-font-family, sans-serif);
+  font-size: var(--kt-font-size-sm, 0.875rem);
+  color: var(--kt-text-color-secondary, var(--kt-neutral-dark, #555));
+  text-align: var(--kt-progress-bar-label-align, start);
+}
+
+/* Si le label est vide (pas d'input et ng-content vide), on le masque pour éviter le gap */
+.kt-progress-bar-label:empty {
+  display: none;
+}
+
+.kt-progress-bar-track {
+  width: 100%;
+  height: var(--kt-progress-bar-height, 4px);
+  overflow: hidden;
+  background-color: var(--kt-progress-bar-track-color, var(--kt-neutral-light, #e0e0e0));
+  border-radius: var(--kt-progress-bar-border-radius, 2px);
+  position: relative;
+}
+
+.kt-progress-bar-indicator {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  background-color: var(--kt-progress-bar-indicator-color, var(--kt-primary, #0056b3));
+  transform-origin: top left;
+  transition: transform 250ms ease;
+  will-change: transform;
+}
+
+/* Mode indéterminé : triple animation parallèle dissociée */
+:host([data-mode='indeterminate']) .kt-progress-bar-indicator {
+  animation:
+    kt-progress-bar-indeterminate-translate 2.2s infinite cubic-bezier(0.4, 0, 0.2, 1),
+    kt-progress-bar-indeterminate-scale 2.2s infinite ease-in-out,
+    kt-progress-bar-indeterminate-fade 2.2s infinite linear;
+  transform-origin: left;
+}
+
+/* Masquage visuel accessible (sr-only) */
+.kt-sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+
+@keyframes kt-progress-bar-indeterminate-translate {
+  0% {
+    translate: -100% 0;
+  }
+  100% {
+    translate: 100% 0;
+  }
+}
+
+@keyframes kt-progress-bar-indeterminate-scale {
+  0% {
+    scale: 0.15 1;
+  }
+  35% {
+    scale: 0.7 1;
+  }
+  70% {
+    scale: 0.4 1;
+  }
+  100% {
+    scale: 0.15 1;
+  }
+}
+
+@keyframes kt-progress-bar-indeterminate-fade {
+  0% {
+    opacity: 0;
+  }
+  15% {
+    opacity: 1;
+  }
+  85% {
+    opacity: 1;
+  }
+  100% {
+    opacity: 0;
+  }
+}
+
+/* Support pour prefers-reduced-motion ou bypass réduit manuel */
+@media (prefers-reduced-motion: reduce) {
+  :host([data-mode='indeterminate']) .kt-progress-bar-indicator {
+    animation: kt-progress-bar-pulsate 2s infinite ease-in-out;
+    transform: none;
+    transform-origin: center;
+  }
+}
+
+.kt-progress-bar-indicator.kt-reduced-motion {
+  animation: kt-progress-bar-pulsate 2s infinite ease-in-out !important;
+  transform: none !important;
+  transform-origin: center !important;
+}
+
+@keyframes kt-progress-bar-pulsate {
+  0% {
+    opacity: 0.3;
+  }
+  50% {
+    opacity: 0.8;
+  }
+  100% {
+    opacity: 0.3;
+  }
+}

package/snackbar/snackbar-tokens.css

@@ -0,0 +1,53 @@
+/* Design tokens de la snackbar (service KtSnackbar) — contrat public de theming.
+
+   PRINCIPE (identique au reste de la lib) : tout DÉRIVE du socle --kt-*. Surcharger un --kt-*
+   rethématise la snackbar en même temps que les champs, boutons et dialog. Chaque valeur reste
+   surchargeable en redéclarant son token --snackbar-* (sur :root ou un conteneur de spécificité ≥).
+
+   La snackbar est posée sur une « surface inversée » (fond sombre, texte clair) façon Material —
+   d'où des on-* dérivés de --kt-on-surface / --kt-surface, qui suivent automatiquement un thème.
+   Les variantes ne recolorisent PAS la pastille (le texte reste à contraste AAA) : elles ne pilotent
+   que l'accent + l'icône. Un thème qui veut des pastilles pleinement colorées surcharge simplement
+   --snackbar-bg / --snackbar-fg sous [data-variant='…']. */
+@layer kt-aaa.tokens {
+  :root {
+    /* Surface inversée : fond ~ on-surface, texte ~ surface (contraste ≈ 16:1 → AAA 1.4.6). */
+    --snackbar-bg: color-mix(in oklab, var(--kt-on-surface, #1f1f1f) 92%, var(--kt-surface, #ffffff));
+    --snackbar-fg: var(--kt-surface, #ffffff);
+
+    --snackbar-radius: var(--kt-control-radius, 8px);
+    --snackbar-shadow: 0 4px 12px rgb(0 0 0 / 24%);
+
+    /* Géométrie interne */
+    --snackbar-padding-block: 0.625rem;
+    --snackbar-padding-inline: 1rem;
+    --snackbar-gap: 0.75rem;
+    --snackbar-font: var(--kt-control-font, 1rem);
+
+    /* Placement : distance au bord du viewport, avec marge de sécurité mobile (encoches / barres). */
+    --snackbar-offset: 16px;
+    --snackbar-offset-bottom: calc(var(--snackbar-offset) + env(safe-area-inset-bottom, 0px));
+    --snackbar-offset-top: calc(var(--snackbar-offset) + env(safe-area-inset-top, 0px));
+    --snackbar-max-inline-size: 560px;
+
+    /* Bouton de fermeture : cible 44px (AAA 2.5.5). */
+    --snackbar-close-size: var(--kt-control-height, 44px);
+    --snackbar-close-icon-size: 1rem;
+
+    /* Variantes : accent (icône) clair pour contraster sur la pastille sombre (≥ 3:1), et glyphe
+       (ligature de la police d'icônes --kt-icon-font). Couleur + FORME : la forme distincte est
+       l'indice non coloré (WCAG 1.4.1). Surchargez accent/glyphe pour rebrander une variante. */
+    --snackbar-icon-size: 1.25rem;
+    --snackbar-accent-info: #8ab4f8;
+    --snackbar-accent-success: #81c995;
+    --snackbar-accent-warning: #fdd663;
+    --snackbar-accent-error: #f28b82;
+    --snackbar-glyph-info: 'info';
+    --snackbar-glyph-success: 'check_circle';
+    --snackbar-glyph-warning: 'warning';
+    --snackbar-glyph-error: 'error';
+
+    /* Animation d'entrée/sortie. Token de durée surchargeable ; neutralisée en prefers-reduced-motion. */
+    --snackbar-anim-duration: 150ms;
+  }
+}

package/snackbar/snackbar.css

@@ -0,0 +1,175 @@
+@layer kt-aaa.components {
+  /* Styles de la snackbar (conteneur monté dans un overlay CDK).
+     Global : l'élément est ajouté hors de toute vue (overlay top-layer).
+     Tokens (--snackbar-*) définis dans snackbar-tokens.css (chargé avant ce fichier).
+
+     Requiert côté hôte : '@angular/cdk/overlay-prebuilt.css' (positionnement de l'overlay) ET
+     '@angular/cdk/a11y-prebuilt.css' (masque l'élément du LiveAnnouncer qui porte l'annonce). */
+
+  /* Le pane d'overlay ne capte pas les clics hors de la snackbar (feedback NON bloquant). */
+  .kt-snackbar-pane {
+    pointer-events: none;
+    max-inline-size: 100vw;
+  }
+
+  .kt-snackbar {
+    pointer-events: auto; /* la snackbar elle-même reste survolable / cliquable */
+    display: flex;
+    align-items: center;
+    gap: var(--snackbar-gap);
+    box-sizing: border-box;
+
+    margin: var(--snackbar-offset);
+    inline-size: max-content;
+    max-inline-size: min(var(--snackbar-max-inline-size), 100vw - 2 * var(--snackbar-offset));
+
+    padding-block: var(--snackbar-padding-block);
+    padding-inline: var(--snackbar-padding-inline);
+
+    border-radius: var(--snackbar-radius);
+    background: var(--snackbar-bg);
+    color: var(--snackbar-fg);
+    box-shadow: var(--snackbar-shadow);
+
+    font-size: var(--snackbar-font);
+    line-height: 1.4;
+  }
+
+  /* Marge de sécurité mobile (encoches / barres système) selon le bord d'ancrage. */
+  .kt-snackbar-pane--bottom .kt-snackbar {
+    margin-block-end: var(--snackbar-offset-bottom);
+  }
+  .kt-snackbar-pane--top .kt-snackbar {
+    margin-block-start: var(--snackbar-offset-top);
+  }
+
+  .kt-snackbar__message {
+    flex: 1 1 auto;
+    min-inline-size: 0; /* autorise le retour à la ligne d'un message long */
+  }
+
+  /* ============ ICÔNE DE VARIANTE (décorative, aria-hidden) ============ */
+  /* Couleur = accent de la variante ; glyphe = ligature de la police d'icônes (comme [ktButton]).
+     Si la police d'icônes est absente, la ligature dégrade en texte (même comportement que le bouton). */
+  .kt-snackbar__icon {
+    flex: none;
+    display: inline-grid;
+    place-items: center;
+    color: var(--snackbar-accent, currentColor);
+  }
+  .kt-snackbar__icon::before {
+    content: var(--snackbar-glyph, '');
+    font-family: var(--kt-icon-font, 'Material Symbols Outlined');
+    font-weight: var(--kt-icon-font-weight, normal);
+    font-style: normal;
+    font-size: var(--snackbar-icon-size, 1.25rem);
+    line-height: 1;
+    font-feature-settings: 'liga';
+    -webkit-font-smoothing: antialiased;
+  }
+
+  /* Mapping variante → accent + glyphe (un thème surcharge accent/glyphe, ou bg/fg pour recolorer). */
+  .kt-snackbar[data-variant='info'] {
+    --snackbar-accent: var(--snackbar-accent-info);
+    --snackbar-glyph: var(--snackbar-glyph-info);
+  }
+  .kt-snackbar[data-variant='success'] {
+    --snackbar-accent: var(--snackbar-accent-success);
+    --snackbar-glyph: var(--snackbar-glyph-success);
+  }
+  .kt-snackbar[data-variant='warning'] {
+    --snackbar-accent: var(--snackbar-accent-warning);
+    --snackbar-glyph: var(--snackbar-glyph-warning);
+  }
+  .kt-snackbar[data-variant='error'] {
+    --snackbar-accent: var(--snackbar-accent-error);
+    --snackbar-glyph: var(--snackbar-glyph-error);
+  }
+
+  /* ============ BOUTON DE FERMETURE ============ */
+  /* Cible 44px, croix dessinée en CSS (zéro dépendance à une police d'icônes). */
+  .kt-snackbar__close {
+    position: relative;
+    flex: none;
+    inline-size: var(--snackbar-close-size);
+    block-size: var(--snackbar-close-size);
+    /* compense optiquement le padding inline du conteneur, sans réduire la cible de 44px */
+    margin-inline-end: calc(-0.5 * var(--snackbar-padding-inline));
+
+    display: inline-grid;
+    place-items: center;
+    padding: 0;
+    border: 0;
+    border-radius: 50%;
+    background: transparent;
+    color: inherit;
+    cursor: pointer;
+  }
+
+  .kt-snackbar__close::before,
+  .kt-snackbar__close::after {
+    content: '';
+    position: absolute;
+    inline-size: var(--snackbar-close-icon-size);
+    block-size: 2px;
+    border-radius: 2px;
+    background: currentColor;
+    translate: 0 0;
+  }
+  .kt-snackbar__close::before {
+    rotate: 45deg;
+  }
+  .kt-snackbar__close::after {
+    rotate: -45deg;
+  }
+
+  .kt-snackbar__close:hover {
+    background: color-mix(in srgb, currentColor 14%, transparent);
+  }
+  .kt-snackbar__close:focus-visible {
+    outline: var(--kt-focus-ring-width, 2px) solid currentColor;
+    outline-offset: 2px;
+  }
+
+  /* ============ ANIMATION D'ENTRÉE / SORTIE ============ */
+  /* Entrée par keyframe (glissement depuis le bord), sortie par transition (classe --leaving).
+     Toutes deux sont activées UNIQUEMENT hors prefers-reduced-motion → en reduced-motion la durée
+     de transition est nulle, donc playExit() démonte instantanément (WCAG 2.3.3). */
+  @media (prefers-reduced-motion: no-preference) {
+    .kt-snackbar {
+      transition:
+        opacity var(--snackbar-anim-duration) ease,
+        translate var(--snackbar-anim-duration) ease;
+    }
+    .kt-snackbar-pane--bottom .kt-snackbar {
+      animation: kt-snackbar-in-bottom var(--snackbar-anim-duration) ease-out;
+    }
+    .kt-snackbar-pane--top .kt-snackbar {
+      animation: kt-snackbar-in-top var(--snackbar-anim-duration) ease-out;
+    }
+
+    /* Sortie : on fond + on glisse vers le bord d'ancrage. */
+    .kt-snackbar--leaving {
+      opacity: 0;
+    }
+    .kt-snackbar-pane--bottom .kt-snackbar--leaving {
+      translate: 0 100%;
+    }
+    .kt-snackbar-pane--top .kt-snackbar--leaving {
+      translate: 0 -100%;
+    }
+  }
+
+  @keyframes kt-snackbar-in-bottom {
+    from {
+      opacity: 0;
+      translate: 0 100%;
+    }
+  }
+  @keyframes kt-snackbar-in-top {
+    from {
+      opacity: 0;
+      translate: 0 -100%;
+    }
+  }
+}

package/styles/disclosure.css

@@ -0,0 +1,6 @@
+@layer kt-aaa.tokens, kt-aaa.base, kt-aaa.components;
+
+/* Disclosure (ktDisclosure + déclencheur + panneau) : tokens + apparence. Nécessite le socle.
+     @import '@ktortu/aaa/disclosure.css'; */
+@import '../disclosure/disclosure-tokens.css';
+@import '../disclosure/disclosure.css';

package/styles/forms.css

@@ -6,6 +6,7 @@
 @import '../forms/styles/tokens.css';
 @import '../forms/chips/tokens.css';
 @import '../forms/styles/field-box.css';
+@import '../forms/styles/field-pending.css';
 @import '../forms/switch/switch.css';
 @import '../forms/checkbox/checkbox.css';
 @import '../forms/checkbox/checkbox-group.css';

package/styles/progress-bar.css

@@ -0,0 +1,5 @@
+@layer kt-aaa.tokens, kt-aaa.base, kt-aaa.components;
+
+/* Barre de progression (kt-progress-bar) : apparence. Nécessite le socle (@ktortu/aaa/foundation.css).
+     @import '@ktortu/aaa/progress-bar.css'; */
+@import '../progress-bar/progress-bar.css';

package/styles/snackbar.css

@@ -0,0 +1,9 @@
+@layer kt-aaa.tokens, kt-aaa.base, kt-aaa.components;
+
+/* Snackbar (service KtSnackbar, overlay CDK). Nécessite le socle (@ktortu/aaa/foundation.css),
+   ET côté hôte l'overlay CDK + le masquage du LiveAnnouncer :
+     @import '@angular/cdk/overlay-prebuilt.css';
+     @import '@angular/cdk/a11y-prebuilt.css';
+     @import '@ktortu/aaa/snackbar.css'; */
+@import '../snackbar/snackbar-tokens.css';
+@import '../snackbar/snackbar.css';

package/styles/styles.css

@@ -22,3 +22,6 @@
 @import './tooltip.css';
 @import './dialog.css';
 @import './menu.css';
+@import './snackbar.css';
+@import './disclosure.css';
+@import './progress-bar.css';

package/themes/theme-cyberpunk.css

@@ -138,6 +138,10 @@
   --tab-radius: 6px 6px 0 0;
   --tab-border: none;
   --tab-margin: 0 4px 0 0;
+
+  /* ============ Progress Bar ============ */
+  --kt-progress-bar-track-color: #10182a;
+  --kt-progress-bar-indicator-color: transparent;
 }
 
 /* Fills DUOTONE cyan→magenta (ex-Synthwave) : niveau élément pour substituer var(--btn-fill) ;
@@ -158,6 +162,13 @@
   --btn-shadow-focus: 0 0 16px color-mix(in srgb, var(--btn-fg) 75%, transparent);
 }
 
+[data-theme='cyberpunk'] .kt-progress-bar-indicator {
+  background-image: linear-gradient(90deg, #28d6ef, #ff3d8b);
+  box-shadow:
+    0 0 8px rgb(40 214 239 / 60%),
+    0 0 12px rgb(255 61 139 / 40%);
+}
+
 /* LASER en bord HAUT des cartes : ligne néon qui balaie (signature « partout »). Le pseudo
    est libre (le lien étiré utilise ::after du lien, pas de la carte). z-index au-dessus du média. */
 [data-theme='cyberpunk'] [ktCard] {

package/tooltip/tooltip.css

@@ -28,7 +28,7 @@
     white-space: pre-line; /* Interprète les \n et les sauts de ligne dans les chaînes de texte */
     box-shadow: 0 4px 12px color-mix(in srgb, #000 25%, transparent);
     pointer-events: auto; /* requis pour le « hoverable » (WCAG 1.4.13) */
-    user-select: text; /* Corrigé : Permet la sélection et traduction du texte */
+    user-select: text; /* Autorise la sélection et la traduction du texte du tooltip. */
     cursor: default;
   }
 

package/types/ktortu-aaa-button.d.ts

@@ -44,7 +44,9 @@ declare class KtButton implements AfterViewInit {
     private readonly config;
     private readonly host;
     private readonly platformId;
+    private isDestroyed;
     private readonly viewInitialized;
+    private readonly auditEnabled;
     protected readonly isLink: boolean;
     private readonly nativeAriaLabel;
     /** Emphase visuelle du bouton (apparence, ≠ `type`). @default 'filled' (ou KT_BUTTON_CONFIG.mode) */

package/types/ktortu-aaa-card.d.ts

@@ -80,6 +80,7 @@ declare class KtCardActions {
  */
 declare class KtCardLink {
     private readonly host;
+    private readonly auditEnabled;
     /**
      * Carte ancêtre, injectée optionnellement via `inject(Card, { optional: true })` (DI par
      * hiérarchie d'éléments) : `null` si [ktCardLink] est utilisé hors d'une [ktCard]. Sert à relayer
@@ -137,6 +138,7 @@ declare class KtCard {
     private readonly config;
     private readonly host;
     private readonly platformId;
+    private readonly auditEnabled;
     /** Référence réactive sur le lien primaire de la carte */
     readonly cardLink: i0.Signal<KtCardLink | undefined>;
     /** Apparence de la surface : `elevated` | `outlined` | `filled`. @default 'elevated' (ou `KT_CARD_CONFIG.variant`) */
@@ -148,6 +150,7 @@ declare class KtCard {
     readonly interactive: i0.InputSignalWithTransform<boolean, unknown>;
     /** Rend la surface inerte (état `data-disabled`). @default false */
     readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    private isDestroyed;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<KtCard, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<KtCard, "[ktCard]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["cardLink"], never, true, never>;

package/types/ktortu-aaa-cdk.d.ts

@@ -42,6 +42,26 @@ interface KtSheetDragOptions {
  */
 declare function createKtSheetDrag(opts: KtSheetDragOptions): KtSheetDrag;
 
+/**
+ * Verrou de défilement du `<body>` à COMPTEUR DE RÉFÉRENCES, partagé (`providedIn: 'root'`).
+ *
+ * Plusieurs surfaces modales simultanées (sheets, popups) peuvent verrouiller le scroll du fond :
+ * `overflow: hidden` n'est posé qu'au premier `lock()` et restauré (à sa valeur d'origine) qu'au
+ * dernier `unlock()`. Sans ce compteur, deux consommateurs par-instance se désynchronisent — la
+ * fermeture du premier restaure le scroll alors que le second est encore ouvert.
+ */
+declare class KtBodyScrollLock {
+    private readonly doc;
+    private count;
+    private previousOverflow;
+    /** Pose un verrou (premier appelant : mémorise puis force `overflow: hidden`). */
+    lock(): void;
+    /** Relâche un verrou ; restaure l'`overflow` d'origine quand le dernier consommateur relâche. */
+    unlock(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KtBodyScrollLock, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KtBodyScrollLock>;
+}
+
 /**
  * Valeur d'un palier de breakpoint, CONFIGURABLE PAR APPLICATION :
  * - un **nombre** = largeur (px) à partir de laquelle le palier commence ; la lib en dérive une
@@ -144,5 +164,11 @@ declare class KtIdGenerator {
     static ɵprov: i0.ɵɵInjectableDeclaration<KtIdGenerator>;
 }
 
-export { KT_BREAKPOINTS, KT_DEFAULT_BREAKPOINTS, KtIdGenerator, KtViewport, createKtSheetDrag, provideKtBreakpoints, resolveKtBreakpointMedia };
+/**
+ * InjectionToken permettant d'activer ou désactiver les audits d'accessibilité à l'exécution
+ * (gardes-fous console.warn en mode dev). Activé par défaut si `isDevMode()` est vrai.
+ */
+declare const KT_AUDIT_ENABLED: InjectionToken<boolean>;
+
+export { KT_AUDIT_ENABLED, KT_BREAKPOINTS, KT_DEFAULT_BREAKPOINTS, KtBodyScrollLock, KtIdGenerator, KtViewport, createKtSheetDrag, provideKtBreakpoints, resolveKtBreakpointMedia };
 export type { KtBreakpointMedia, KtBreakpointValue, KtBreakpoints, KtSheetDrag, KtSheetDragOptions };

package/types/ktortu-aaa-dialog.d.ts

@@ -249,22 +249,6 @@ type KtDialogPresentation = 'centered' | 'fullscreen' | 'sheet' | 'centered-full
  */
 declare function resolveKtDialogPanelClass(presentation?: KtDialogPresentation, compact?: boolean): string[];
 
-/**
- * Sucre typé pour récupérer les données injectées dans un composant de dialogue (`DIALOG_DATA`).
- * À appeler en contexte d'injection (ex. initialiseur de champ).
- *
- * @example
- * ```ts
- * interface RenameData { currentName: string; }
- *
- * @Component({  …  })
- * export class RenameDialog {
- *   protected readonly data = injectKtDialogData<RenameData>();
- *   // this.data.currentName  →  string
- * }
- * ```
- */
-declare function injectKtDialogData<T>(): T;
 /** Config d'ouverture sans le champ `data` (fourni séparément, typé), enrichie de `presentation`. */
 type KtDialogOpenerConfig<D, R, C> = Omit<DialogConfig<D, DialogRef<R, C>>, 'data'> & {
     /** Présentation du dialog (cf. `KtDialogPresentation`) — choisie par le dev. Résolue à CHAQUE
@@ -273,39 +257,110 @@ type KtDialogOpenerConfig<D, R, C> = Omit<DialogConfig<D, DialogRef<R, C>>, 'dat
     presentation?: KtDialogPresentation;
 };
 /**
- * Crée un ouvreur de dialog **typé et centralisé**, en contexte d'injection.
- * Le contrat (composant + type de `data` + type de résultat + config par défaut) est défini
- * UNE fois ; l'ouvreur renvoyé est une closure appelable ensuite n'importe où dans la classe
- * (handlers compris), 100 % typée, sans nouvel `inject`.
+ * ⚠️ API BAS-NIVEAU — n'utilisez PAS ceci par défaut. Pour implémenter un dialog, passez par
+ * {@link defineKtDialog} puis son `injectOpener(...)` : il fixe données + résultat une seule fois et
+ * les partage avec `injectData()`/`injectRef()`. N'appelez `injectKtDialogOpener` directement que
+ * dans un cas avancé où le contrat groupé de `defineKtDialog` ne convient pas.
+ *
+ * Crée un ouvreur de dialog typé en contexte d'injection : le contrat (composant + type de `data` +
+ * type de résultat + config par défaut) est figé via les génériques `<Composant, Data, Résultat>`
+ * (qu'il faut répéter — d'où la préférence pour `defineKtDialog`). L'ouvreur renvoyé est une closure
+ * appelable n'importe où dans la classe, 100 % typée, sans nouvel `inject`.
  *
  * Conserve le `ViewContainerRef` du contexte appelant (le dialog hérite donc de l'arbre logique
  * d'injection), reste testable (TestBed fournit `Dialog`) et sans état global (SSR-safe).
  *
- * @example
- * // co-localisé avec le composant
- * export const injectRenameDialog = () =>
- *   injectKtDialogOpener<RenameDialog, RenameData, string>(RenameDialog, { autoFocus: '[ktDialogFocusInitial]' });
- *
- * // dans un composant/service consommateur
- * private readonly openRename = injectRenameDialog();
- * rename() { this.openRename({ currentName: 'X' }).closed.subscribe(n => {  n: string | undefined  }); }
- *
  * @param component Composant à monter dans le dialog.
  * @param baseConfig Config d'ouverture par défaut (sans `data`), enrichie de `presentation` ; fusionnée à chaque ouverture.
  * @returns Une closure d'ouverture typée : `() => DialogRef` (sans data) ou `(data, config?) => DialogRef` (avec data).
+ * @see {@link defineKtDialog} — la façon recommandée d'obtenir cet ouvreur.
  */
 declare function injectKtDialogOpener<C, R = unknown>(component: ComponentType<C>, baseConfig?: KtDialogOpenerConfig<void, R, C>): () => DialogRef<R, C>;
 declare function injectKtDialogOpener<C, D, R = unknown>(component: ComponentType<C>, baseConfig?: KtDialogOpenerConfig<D, R, C>): (data: D, config?: KtDialogOpenerConfig<D, R, C>) => DialogRef<R, C>;
+/**
+ * Contrat de dialog typé renvoyé par `defineKtDialog` : les trois accès (données, référence,
+ * ouvreur) dérivent des MÊMES génériques `D`/`R`, déclarés une seule fois — impossible donc que
+ * le type des données ou du résultat diverge entre le composant et l'ouvreur.
+ *
+ * @template D Type des données injectées (`void` si aucune).
+ * @template R Type du résultat renvoyé à la fermeture.
+ */
+interface KtDialogContract<D, R> {
+    /** Données injectées (à appeler en contexte d'injection DANS le composant de dialog). */
+    injectData(): D;
+    /** Référence typée du dialog : `close()` n'accepte QUE le résultat `R` (sûreté de fermeture). */
+    injectRef(): DialogRef<R>;
+    /** Ouvreur typé CO-LOCALISÉ pour ce composant (cf. `injectKtDialogOpener`). */
+    injectOpener<C>(component: ComponentType<C>, baseConfig?: KtDialogOpenerConfig<D, R, C>): (data: D, config?: KtDialogOpenerConfig<D, R, C>) => DialogRef<R, C>;
+}
+/**
+ * ✅ STRATÉGIE PAR DÉFAUT pour implémenter un dialog `@ktortu/aaa`. Toute nouvelle dialog DOIT être
+ * écrite ainsi. N'utilisez `injectKtDialogData` / `injectKtDialogOpener` directement QUE dans un cas
+ * avancé non couvert ici.
+ *
+ * Définit le contrat typé du dialog (données `D` + résultat `R`) en UN SEUL endroit, co-localisé avec
+ * le composant. Renvoie trois accès liés aux mêmes types — `injectData()` (données), `injectRef()`
+ * (référence dont `close()` n'accepte que `R`) et `injectOpener()` (ouvreur) — d'où l'impossibilité
+ * d'une divergence de type entre composant et ouvreur.
+ *
+ * Recette à copier pour CHAQUE dialog :
+ * 1. `interface XxxData { … }` (ou `void` si aucune donnée) ;
+ * 2. `const xxxDialog = defineKtDialog<XxxData, Résultat>();` ;
+ * 3. dans le composant : `injectData()` pour lire la donnée, `injectRef()` pour fermer avec résultat ;
+ * 4. `export const injectXxxDialog = () => xxxDialog.injectOpener(XxxDialog);` (co-localisé) ;
+ * 5. côté consommateur : `private readonly openXxx = injectXxxDialog();` (initialiseur de champ).
+ *
+ * Convention de fermeture : annuler / fermer SANS résultat via la directive `[ktDialogClose]`
+ * (→ `undefined`) ; renvoyer un résultat via `ref.close(résultat)` (typé `R`). Passer un résultat par
+ * `[ktDialogClose]="x"` reste possible mais N'EST PAS typé (la directive ignore `R`).
+ *
+ * @example
+ * ```ts
+ * // ─── rename-dialog.ts : composant + contrat + ouvreur, co-localisés ───
+ * export interface RenameData { currentName: string; }
+ *
+ * const renameDialog = defineKtDialog<RenameData, string>(); // D et R déclarés UNE seule fois
+ *
+ * @Component({
+ *   imports: [KtButton, KtDialogImports],
+ *   template: `
+ *     <h2 ktDialogTitle>Renommer</h2>
+ *     <footer ktDialogActions>
+ *       <button ktButton ktDialogClose>Annuler</button>            // ferme sans résultat (undefined)
+ *       <button ktButton (click)="submit()">Renommer</button>      // ferme avec résultat typé
+ *     </footer>`,
+ * })
+ * export class RenameDialog {
+ *   protected readonly data = renameDialog.injectData();  // RenameData garanti
+ *   private readonly ref = renameDialog.injectRef();      // DialogRef<string>
+ *   protected submit() { this.ref.close('nouveau-nom'); } // close(result?: string) — typé
+ * }
+ *
+ * export const injectRenameDialog = () => renameDialog.injectOpener(RenameDialog);
+ *
+ * // ─── consommateur ───
+ * private readonly openRename = injectRenameDialog();     // initialiseur de champ = contexte d'injection
+ * rename() {
+ *   this.openRename({ currentName: 'X' }).closed.subscribe(name => {
+ *     // name: string | undefined
+ *   });
+ * }
+ * ```
+ */
+declare function defineKtDialog<D = void, R = unknown>(): KtDialogContract<D, R>;
 
-declare class KtDialogContainer extends CdkDialogContainer implements OnInit {
+declare class KtDialogContainer extends CdkDialogContainer {
     private readonly dialogRef;
     private readonly elementRef;
     private readonly host;
     private readonly platformId;
-    private readonly destroyRef;
     protected readonly isClosing: i0.WritableSignal<boolean>;
+    /** Premier id de la file `aria-labelledby` exposée par `CdkDialogContainer`. Le membre
+        `_ariaLabelledByQueue` est interne au CDK (préfixe `_`) : on l'encapsule ICI, gardé, pour que
+        le binding de template ne lise jamais l'interne directement. Si une montée du CDK retire ou
+        renomme ce membre, on dégrade proprement vers `null` au lieu de casser le rendu du conteneur. */
+    protected get ariaLabelledBy(): string | null;
     constructor();
-    ngOnInit(): void;
     protected isSheet(): boolean;
     private animateAndClose;
     static ɵfac: i0.ɵɵFactoryDeclaration<KtDialogContainer, never>;
@@ -318,5 +373,5 @@ declare class KtDialogContainer extends CdkDialogContainer implements OnInit {
  */
 declare const KtDialogImports: readonly [typeof KtDialogHeader, typeof KtDialogTitle, typeof KtDialogDescription, typeof KtDialogContent, typeof KtDialogActions, typeof KtDialogClose, typeof KtDialogFocusInitial, typeof KtDialogSheetHandle];
 
-export { KT_DIALOG_AAA_DEFAULTS, KtDialogActions, KtDialogClose, KtDialogContainer, KtDialogContent, KtDialogDescription, KtDialogFocusInitial, KtDialogHeader, KtDialogImports, KtDialogSheetHandle, KtDialogTitle, injectKtDialogData, injectKtDialogOpener, provideKtDialogDefaults, resolveKtDialogPanelClass };
-export type { KtDialogOpenerConfig, KtDialogPresentation };
+export { KT_DIALOG_AAA_DEFAULTS, KtDialogActions, KtDialogClose, KtDialogContainer, KtDialogContent, KtDialogDescription, KtDialogFocusInitial, KtDialogHeader, KtDialogImports, KtDialogSheetHandle, KtDialogTitle, defineKtDialog, injectKtDialogOpener, provideKtDialogDefaults, resolveKtDialogPanelClass };
+export type { KtDialogContract, KtDialogOpenerConfig, KtDialogPresentation };