@cadriciel/ui 0.9.0 → 0.9.2

package/types/cadriciel-ui.d.ts

@@ -694,21 +694,56 @@ declare class CadCheckboxComponent extends CadValueAccessor<boolean> {
  *   <cad-radio value="session" label="Session" [disabled]="true" />
  * </cad-radio-group>
  * CVA<T> sur le GROUPE. Clavier : ←/→/↑/↓ déplacent la sélection (pattern WAI-ARIA radiogroup).
- * @atelier icone=circle-dot largeur=2
+ * @atelier icone=circle-dot largeur=2 conteneur=direct hauteur=4
  */
 declare class CadRadioGroupComponent<T = unknown> extends CadValueAccessor<T> {
     readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
     readonly ariaLabel: _angular_core.InputSignal<string>;
     readonly name: _angular_core.InputSignal<string>;
     readonly changed: _angular_core.OutputEmitterRef<T>;
-    readonly radios: _angular_core.Signal<readonly any[]>;
+    private readonly radiosProjetes;
+    /** Radios POSÉS hors gabarit, annoncés par `enregistrerEnfants`. */
+    private readonly radiosPoses;
+    readonly radios: _angular_core.Signal<any[]>;
+    /** Reçoit la LISTE COMPLÈTE des radios posés, et se RATTACHE à chacun. */
+    enregistrerEnfants(instances: unknown[]): void;
     select(v: T): void;
     protected onKey(e: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CadRadioGroupComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadRadioGroupComponent<any>, "cad-radio-group", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, ["radios"], ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadRadioGroupComponent<any>, "cad-radio-group", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, ["radiosProjetes"], ["*"], true, never>;
 }
+/**
+ * Un choix du groupe : `<cad-radio [value]="'a'" label="Option A">`.
+ * @atelier icone=circle-dot conteneur=flux dans=cad-radio-group pose-label=Option
+ */
 declare class CadRadioComponent<T = unknown> {
-    readonly group: CadRadioGroupComponent<T>;
+    /**
+     * Le groupe d'accueil — INJECTÉ dans un gabarit, POUSSÉ par l'hôte à la pose.
+     *
+     * ⚠️ OPTIONNEL depuis le 27/08, même correctif que `cad-accordion-panel` : l'injection
+     * obligatoire levait `NG0201` dès qu'on créait le bouton à la main, et `gen-catalog`
+     * classait `cad-radio` « contextuel » — il n'était pas posable. `cad-tab`, la pièce
+     * jumelle des onglets, n'injecte rien : elle est PASSIVE et son hôte la pilote. La
+     * divergence était d'écriture, pas de nature (SZU 27/08).
+     */
+    private readonly groupInjecte;
+    private readonly groupPose;
+    readonly group: _angular_core.Signal<CadRadioGroupComponent<T> | null>;
+    /** Le groupe s'annonce au bouton qu'il accueille. Cf. `atelier/atelier.pieces.ts`. */
+    rattacher(g: CadRadioGroupComponent<T>): void;
+    /** Sélectionne, si un groupe existe. Un radio solitaire ne prétend pas gérer un choix. */
+    protected choisir(): void;
+    /**
+     * La valeur que ce choix représente.
+     *
+     * DÉFAUT UNIQUE plutôt que `input.required` (27/08) — même précédent que
+     * `cad-accordion-panel`, qui se donne `cadId('cad-panel')`. Une entrée requise LÈVE
+     * dès qu'on instancie le composant sans la fournir : posé dans l'atelier, le radio
+     * mourait à la construction et le poseur l'écartait EN SILENCE (groupe vide, aucune
+     * erreur visible). Un défaut unique par instance rend un radio posé immédiatement
+     * cohérent — deux radios ne se retrouvent jamais cochés ensemble — et n'enlève rien à
+     * l'usage écrit, où l'on passe toujours une valeur.
+     */
     readonly value: _angular_core.InputSignal<T>;
     readonly label: _angular_core.InputSignal<string>;
     readonly hint: _angular_core.InputSignal<string>;
@@ -719,7 +754,7 @@ declare class CadRadioComponent<T = unknown> {
     protected readonly tabIndex: _angular_core.Signal<0 | -1>;
     focus(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CadRadioComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadRadioComponent<any>, "cad-radio", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadRadioComponent<any>, "cad-radio", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 type CadSegmentOption = {
@@ -1866,6 +1901,7 @@ declare class CadTabContentDirective {
  *   contenu (ou <ng-template cadTabContent> pour un rendu vraiment paresseux)
  *   <ng-template cadTabLabel>label custom</ng-template>
  * </cad-tab>
+ * @atelier icone=panel-top conteneur=flux dans=cad-tabs pose-label=Onglet
  */
 declare class CadTabComponent {
     readonly value: _angular_core.InputSignal<unknown>;
@@ -1887,7 +1923,7 @@ declare class CadTabComponent {
 /**
  * <cad-tabs [(value)]="tab" [(activeIndex)]="i" variant="line|pill|enclosed" size="sm|md" [stretch] [scrollable] [lazy]="true" [keepAlive]="true" (changed) (tabChange)>
  * `value` prime sur `activeIndex` (les deux sont two-way et synchronisés). Clavier ←/→/Home/End sur la liste.
- * @atelier icone=folder
+ * @atelier icone=folder conteneur=direct largeur=12 hauteur=6
  */
 declare class CadTabsComponent {
     readonly value: _angular_core.ModelSignal<unknown>;
@@ -1911,7 +1947,37 @@ declare class CadTabsComponent {
         value: unknown;
         tab: CadTabComponent;
     }>;
-    readonly tabs: _angular_core.Signal<readonly CadTabComponent[]>;
+    /** Onglets déclarés dans un GABARIT — la voie normale, celle de tous les usages écrits. */
+    private readonly tabsProjetes;
+    /**
+     * Onglets POSÉS : créés hors gabarit par `createComponent`, et annoncés par
+     * `enregistrerEnfants` — le contrat d'accueil décrit dans `atelier/atelier.pieces.ts`.
+     *
+     * ⚠️ CE N'EST PAS UN DOUBLON DE LA REQUÊTE, C'EST LA SEULE VOIE POSSIBLE POUR EUX.
+     * Mesuré le 27/08 : un `cad-tab` créé impérativement et passé en `projectableNodes`
+     * arrive bien dans le DOM, mais `contentChildren` NE LE VOIT PAS — une requête de
+     * contenu se résout sur la structure déclarée d'un gabarit, et un composant instancié
+     * à la main vit dans une autre vue. Résultat avant correction : `onglets=0`, une barre
+     * vide et aucun panneau, sans la moindre erreur. C'est ce qui rendait `cad-tabs`
+     * inutilisable dans l'atelier et dans les pages visuelles de frontless.
+     *
+     * Même trappe que `cad-button-group`, qui la porte depuis le 24/08 pour la même
+     * raison (il était SOURD aux clics de ses boutons posés) : les deux sources
+     * FUSIONNENT, la projection reste prioritaire dans l'ordre, et rien ne change pour
+     * qui écrit du gabarit.
+     */
+    private readonly tabsPoses;
+    /** Tous les onglets : projetés d'abord, posés ensuite. L'ordre fait la barre. */
+    readonly tabs: _angular_core.Signal<CadTabComponent[]>;
+    /**
+     * Reçoit les instances des onglets posés — la LISTE COMPLÈTE, pas un ajout.
+     *
+     * Le poseur reconstruit ses enfants d'un bloc à chaque changement de structure : lui
+     * faire tenir un différentiel inviterait le fantôme (un onglet détruit qui reste dans
+     * la barre). L'hôte filtre lui-même ce qui n'est pas un onglet, pour qu'un appelant
+     * n'ait pas à connaître nos types.
+     */
+    enregistrerEnfants(instances: unknown[]): void;
     private readonly list;
     private readonly btns;
     protected readonly overflow: _angular_core.WritableSignal<boolean>;
@@ -1924,7 +1990,7 @@ declare class CadTabsComponent {
     protected scroll(dir: number): void;
     protected checkOverflow(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CadTabsComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadTabsComponent, "cad-tabs", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "stretch": { "alias": "stretch"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; "keepAlive": { "alias": "keepAlive"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "activeIndex": "activeIndexChange"; "changed": "changed"; "tabChange": "tabChange"; }, ["tabs"], ["[cadTabsEnd]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadTabsComponent, "cad-tabs", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "stretch": { "alias": "stretch"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; "keepAlive": { "alias": "keepAlive"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "activeIndex": "activeIndexChange"; "changed": "changed"; "tabChange": "tabChange"; }, ["tabsProjetes"], ["[cadTabsEnd]"], true, never>;
 }
 
 type CadStepState = 'done' | 'current' | 'error' | 'todo';
@@ -1998,9 +2064,29 @@ declare class CadPanelContentDirective {
  *   </cad-accordion-panel>
  * </cad-accordion>
  * `value` = valeur ouverte (string) ou tableau si `multiple`. Clavier : Entrée/Espace, ↑/↓/Home/End entre en-têtes.
+ * @atelier icone=panel-top conteneur=flux dans=cad-accordion pose-header=Section
  */
 declare class CadAccordionPanelComponent {
-    readonly acc: CadAccordionComponent;
+    /**
+     * L'accordéon d'accueil — INJECTÉ dans un gabarit, POUSSÉ par l'hôte quand la pièce
+     * est posée hors gabarit.
+     *
+     * ⚠️ L'INJECTION EST OPTIONNELLE, ET C'EST LE CŒUR DU CORRECTIF (SZU 27/08 : « pourquoi
+     * cad-accordion serait différent d'un cad-tabs ? »). Elle était obligatoire, donc :
+     * `NG0201` dès qu'on créait le panneau à la main, et `gen-catalog` le classait
+     * « contextuel » — il n'était même pas POSABLE. Or `cad-tab`, lui, n'injecte rien :
+     * c'est une pièce PASSIVE que son hôte pilote. La différence n'était pas une contrainte
+     * du composant, c'était une divergence d'écriture entre deux familles jumelles.
+     *
+     * Renversement : la pièce ne va plus CHERCHER son hôte, c'est l'hôte qui s'annonce en
+     * l'accueillant (`rattacher`). Un panneau posé seul reste sensé — il gère alors son
+     * propre `expanded` au lieu de lever.
+     */
+    private readonly accInjecte;
+    private readonly accPose;
+    readonly acc: _angular_core.Signal<CadAccordionComponent | null>;
+    /** L'accordéon s'annonce à la pièce qu'il accueille. Cf. `atelier/atelier.pieces.ts`. */
+    rattacher(acc: CadAccordionComponent): void;
     readonly value: _angular_core.InputSignal<string>;
     readonly header: _angular_core.InputSignal<string>;
     readonly icon: _angular_core.InputSignal<string>;
@@ -2013,6 +2099,7 @@ declare class CadAccordionPanelComponent {
     readonly contentTpl: _angular_core.Signal<CadPanelContentDirective | undefined>;
     readonly id: string;
     readonly rendered: _angular_core.WritableSignal<boolean>;
+    /** Sans hôte, le panneau fait autorité sur lui-même : posé seul, il reste utilisable. */
     readonly isOpen: _angular_core.Signal<boolean>;
     constructor();
     toggle(): void;
@@ -2020,7 +2107,7 @@ declare class CadAccordionPanelComponent {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CadAccordionPanelComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadAccordionPanelComponent, "cad-accordion-panel", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; "opened": "opened"; "closed": "closed"; }, ["headerTpl", "contentTpl"], ["[cadPanelExtra]", "*"], true, never>;
 }
-/** @atelier icone=chevron-down */
+/** @atelier icone=chevron-down conteneur=direct largeur=12 hauteur=8 */
 declare class CadAccordionComponent {
     readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Ouvert(s) : string (single) ou string[] (multiple). */
@@ -2029,13 +2116,21 @@ declare class CadAccordionComponent {
     /** Sans bordure extérieure. */
     readonly flush: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly changed: _angular_core.OutputEmitterRef<string | string[] | null>;
-    readonly panels: _angular_core.Signal<readonly CadAccordionPanelComponent[]>;
+    private readonly panelsProjetes;
+    /** Panneaux POSÉS hors gabarit, annoncés par `enregistrerEnfants`. */
+    private readonly panelsPoses;
+    readonly panels: _angular_core.Signal<CadAccordionPanelComponent[]>;
+    /**
+     * Reçoit la LISTE COMPLÈTE des panneaux posés, et se RATTACHE à chacun : la pièce
+     * n'ayant plus d'injection obligatoire, c'est ce geste qui rétablit le lien.
+     */
+    enregistrerEnfants(instances: unknown[]): void;
     private readonly openSet;
     isOpen(v: string): boolean;
     setOpen(v: string, open: boolean, panel?: CadAccordionPanelComponent): void;
     onKey(e: KeyboardEvent, from: CadAccordionPanelComponent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CadAccordionComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadAccordionComponent, "cad-accordion", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "expandIcon": { "alias": "expandIcon"; "required": false; "isSignal": true; }; "flush": { "alias": "flush"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; }, ["panels"], ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadAccordionComponent, "cad-accordion", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "expandIcon": { "alias": "expandIcon"; "required": false; "isSignal": true; }; "flush": { "alias": "flush"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; }, ["panelsProjetes"], ["*"], true, never>;
 }
 
 interface CadBreadcrumbItem {
@@ -4318,6 +4413,12 @@ declare class CadMessageComponent {
  * @atelier ajustement=naturel icone=user-round largeur=1 hauteur=1 pose-text=AB
  */
 declare class CadAvatarComponent {
+    /**
+     * Son élément, exposé comme `cad-button` le fait déjà : le groupe marque le
+     * débordement (`.is-overflow`) sur les éléments, et une requête de contenu ne les
+     * rapporte pas pour un avatar POSÉ hors gabarit.
+     */
+    readonly el: ElementRef<HTMLElement>;
     readonly src: _angular_core.InputSignal<string | null | undefined>;
     readonly text: _angular_core.InputSignal<string>;
     readonly icon: _angular_core.InputSignal<string>;
@@ -4563,19 +4664,30 @@ declare class CadPanelComponent {
 /**
  * <cad-avatar-group [max]="3" size="md"><cad-avatar text="SZ"/><cad-avatar text="PA"/>…</cad-avatar-group>
  * Avatars empilés (chevauchement, bordure surface) ; au-delà de `max` un avatar « +N » (title = noms masqués).
- * @atelier ajustement=naturel icone=users largeur=2 hauteur=1
+ * @atelier ajustement=naturel icone=users largeur=2 hauteur=1 conteneur=direct accepte=cad-avatar
  */
 declare class CadAvatarGroupComponent {
     readonly max: _angular_core.InputSignalWithTransform<number | null, unknown>;
     readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
     readonly moreColor: _angular_core.InputSignal<string | null>;
+    private readonly avatarsProjetes;
+    /**
+     * Avatars POSÉS hors gabarit, annoncés par `enregistrerEnfants`
+     * (cf. `atelier/atelier.pieces.ts`).
+     *
+     * Le groupe RENDAIT correctement sans eux — le chevauchement et les bordures sont du
+     * CSS sur les enfants directs. Seul `max` était inerte : le « +N » ne comptait rien et
+     * rien ne passait en débordement. Une panne discrète, donc pire qu'une panne franche.
+     */
+    private readonly avatarsPoses;
     private readonly avatars;
-    private readonly avatarEls;
+    /** Reçoit la LISTE COMPLÈTE des avatars posés. Le groupe filtre ce qui n'en est pas un. */
+    enregistrerEnfants(instances: unknown[]): void;
     readonly hidden: _angular_core.Signal<number>;
     readonly hiddenTitle: _angular_core.Signal<string>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CadAvatarGroupComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadAvatarGroupComponent, "cad-avatar-group", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "moreColor": { "alias": "moreColor"; "required": false; "isSignal": true; }; }, {}, ["avatars", "avatarEls"], ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadAvatarGroupComponent, "cad-avatar-group", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "moreColor": { "alias": "moreColor"; "required": false; "isSignal": true; }; }, {}, ["avatarsProjetes"], ["*"], true, never>;
 }
 
 interface CadMeterValue {
@@ -4867,7 +4979,15 @@ declare class CadClusterComponent {
  * Grille responsive : `<cad-grid cols="1 sm:2 lg:4" gap="md">` (breakpoints FENÊTRE, mobile-first)
  * ou `<cad-grid min="220px">` (auto-fit : autant de colonnes que le CONTENEUR en accepte — préférer pour les composants).
  * Enfant : `<div cadCol="2">` / `cadCol="1 md:2"` = span, `cadCol="full"` = toute la largeur.
- * @atelier icone=grid
+ *
+ * CONTENEUR D'ATELIER en régime `direct`, et non `flux` (27/08) : en flux, l'atelier
+ * envelopperait les enfants dans SA propre grille 12 colonnes, la grille posée n'aurait
+ * plus qu'un seul enfant et son `cols` ne servirait plus à rien — un conteneur qui a
+ * l'air de marcher et ne fait rien. En direct, les enfants sont projetés nus et c'est
+ * bien `cols` / `min` qui les place, ce qu'on vient chercher en posant une grille.
+ * Aucune trappe d'accueil n'est nécessaire ici : `cad-grid` ne fait ni requête de
+ * contenu ni injection depuis ses enfants, il ne les REGARDE pas, il les dispose.
+ * @atelier icone=grid conteneur=direct largeur=12 hauteur=4
  */
 declare class CadGridComponent {
     readonly cols: _angular_core.InputSignal<string | number>;
@@ -4958,7 +5078,12 @@ declare class CadContainerComponent {
 }
 /**
  * Espace flexible (pousse ce qui suit) ou fixe : `<cad-spacer/>` · `<cad-spacer size="lg"/>`
- * @atelier icone=move-horizontal
+ *
+ * `surface=aucune` : il occupe sa place et ne dessine RIEN. Posé dans une maquette, il
+ * fait donc exactement son travail en restant invisible — indistinguable d'un composant
+ * qui n'aurait pas été posé (SZU 27/08). L'atelier s'en sert pour le MATÉRIALISER le
+ * temps de la conception ; le rendu, lui, n'en sait rien.
+ * @atelier icone=move-horizontal surface=aucune
  */
 declare class CadSpacerComponent {
     readonly size: _angular_core.InputSignal<"" | CadGap>;
@@ -4967,7 +5092,10 @@ declare class CadSpacerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadSpacerComponent, "cad-spacer", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-/** Panneau d'un splitter : `<cad-splitter-panel [size]="30" [minSize]="10">…</cad-splitter-panel>` (size en %). */
+/**
+ * Panneau d'un splitter : `<cad-splitter-panel [size]="30" [minSize]="10">…</cad-splitter-panel>` (size en %).
+ * @atelier icone=square conteneur=flux dans=cad-splitter
+ */
 declare class CadSplitterPanelComponent {
     readonly size: _angular_core.InputSignalWithTransform<number | null, unknown>;
     readonly minSize: _angular_core.InputSignalWithTransform<number, unknown>;
@@ -4979,7 +5107,7 @@ declare class CadSplitterPanelComponent {
  *   <cad-splitter-panel>…</cad-splitter-panel><cad-splitter-panel>…</cad-splitter-panel>
  * </cad-splitter>
  * Gouttière glissable (pointer), double-clic = tailles initiales, clavier ←→/↑↓ (±2 %), `role=separator`, persistance localStorage via `stateKey`, imbriquable.
- * @atelier icone=columns
+ * @atelier icone=columns conteneur=direct largeur=12 hauteur=8
  */
 declare class CadSplitterComponent {
     private readonly host;
@@ -4990,7 +5118,22 @@ declare class CadSplitterComponent {
     readonly stateKey: _angular_core.InputSignal<string>;
     readonly resizeStart: _angular_core.OutputEmitterRef<number[]>;
     readonly resizeEnd: _angular_core.OutputEmitterRef<number[]>;
-    readonly panels: _angular_core.Signal<readonly CadSplitterPanelComponent[]>;
+    /** Panneaux déclarés dans un GABARIT — la voie normale. */
+    private readonly panelsProjetes;
+    /**
+     * Panneaux POSÉS, créés hors gabarit et annoncés par `enregistrerEnfants`
+     * (cf. `atelier/atelier.pieces.ts`).
+     *
+     * Sans eux, `panels()` reste vide pour un splitter posé : aucune gouttière, aucune
+     * taille calculée, `grid-template-columns` vide — mesuré à `gouttieres=0` le 27/08.
+     * Les panneaux s'affichaient quand même (ils sont projetés), ce qui donnait un
+     * splitter d'apparence correcte mais sans mise en page ni poignée.
+     */
+    private readonly panelsPoses;
+    /** Tous les panneaux : projetés d'abord, posés ensuite — l'ordre fait les colonnes. */
+    readonly panels: _angular_core.Signal<CadSplitterPanelComponent[]>;
+    /** Reçoit la LISTE COMPLÈTE des panneaux posés. L'hôte filtre ce qui n'en est pas un. */
+    enregistrerEnfants(instances: unknown[]): void;
     readonly sizes: _angular_core.WritableSignal<number[]>;
     readonly gutters: _angular_core.Signal<number[]>;
     readonly mins: _angular_core.Signal<number[]>;
@@ -5007,7 +5150,7 @@ declare class CadSplitterComponent {
     protected onDown(e: PointerEvent, g: number): void;
     protected onKey(e: KeyboardEvent, g: number): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CadSplitterComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadSplitterComponent, "cad-splitter", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "panelSizes": { "alias": "panelSizes"; "required": false; "isSignal": true; }; "minSizes": { "alias": "minSizes"; "required": false; "isSignal": true; }; "gutterSize": { "alias": "gutterSize"; "required": false; "isSignal": true; }; "stateKey": { "alias": "stateKey"; "required": false; "isSignal": true; }; }, { "resizeStart": "resizeStart"; "resizeEnd": "resizeEnd"; }, ["panels"], ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CadSplitterComponent, "cad-splitter", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "panelSizes": { "alias": "panelSizes"; "required": false; "isSignal": true; }; "minSizes": { "alias": "minSizes"; "required": false; "isSignal": true; }; "gutterSize": { "alias": "gutterSize"; "required": false; "isSignal": true; }; "stateKey": { "alias": "stateKey"; "required": false; "isSignal": true; }; }, { "resizeStart": "resizeStart"; "resizeEnd": "resizeEnd"; }, ["panelsProjetes"], ["*"], true, never>;
 }
 
 /**
@@ -5431,6 +5574,20 @@ declare class CadMapComponent {
     readonly allChildren: _angular_core.Signal<readonly CadMapChild[]>;
     registerChild(k: CadMapChild): void;
     unregisterChild(k: CadMapChild): void;
+    /**
+     * Contrat d'accueil des pièces POSÉES (cf. `atelier/atelier.pieces.ts`).
+     *
+     * ⚠️ CORRIGE UN MENSONGE LIVRÉ LE 24/08. `cad-map` était annoté conteneur et ses onze
+     * pièces déclaraient `dans=cad-map`, mais AUCUNE couche posée ne s'est jamais
+     * enregistrée : la carte n'exposait que `registerChild`, que les poseurs n'appellent
+     * pas, et `cad-map-layer` s'injecte la carte en `optional` — donc `null` sans chaîne
+     * d'injecteurs, donc pas d'auto-enregistrement, et pas la moindre erreur pour le dire.
+     * Deux vocabulaires pour un besoin : c'est la divergence qu'on paie ici.
+     *
+     * Liste COMPLÈTE à chaque appel : le poseur reconstruit ses enfants d'un bloc, et un
+     * contrat incrémental laisserait des couches fantômes sur la carte.
+     */
+    enregistrerEnfants(instances: unknown[]): void;
     /** Événements du chrome intégré (dessin, import). */
     readonly drawChange: _angular_core.OutputEmitterRef<object>;
     readonly layerImport: _angular_core.OutputEmitterRef<{
@@ -8413,6 +8570,22 @@ declare const ATELIER_BORNES: {
     readonly propsMax: 30;
     /** Enfants directs d'un conteneur. Le plafond GLOBAL reste `itemsMax`, enfants compris. */
     readonly enfantsMax: 30;
+    /**
+     * Profondeur d'imbrication, en niveaux SOUS le plan.
+     *
+     * Un item du plan est à la profondeur 0, son enfant à 1, et ainsi de suite jusqu'à
+     * `profondeurMax` INCLUS — soit cinq étages en tout. Ce n'est pas une préférence
+     * d'ergonomie : `atelierNormaliser` et l'assainisseur backend descendent une
+     * structure VENUE DE L'EXTÉRIEUR (lien partagé, fichier collé), et une récursion
+     * non bornée sur du JSON hostile fait sauter la pile. Le plafond de COMPTE
+     * (`itemsMax`) ne borne pas la profondeur : deux cents items peuvent former une
+     * chaîne de deux cents étages.
+     *
+     * Cinq étages couvrent le besoin réel mesuré le 27/08 — le pire cas de la
+     * bibliothèque est `cad-splitter > cad-splitter-panel > cad-tabs > cad-tab >
+     * contenu`, soit une profondeur de 4 pour le contenu.
+     */
+    readonly profondeurMax: 4;
 };
 /** Un composant posé sur le plan. */
 interface AtelierItem {
@@ -8446,10 +8619,16 @@ interface AtelierItem {
      *   conteneur) — quatre tags à `w=3` tiennent côte à côte. `x`, `y` et `h` restent
      *   normalisés (0/0/1) : pas de placement absolu à l'intérieur, c'est ce qui évite le
      *   glisser inter-grilles, là où les outils de maquette meurent.
-     * · UN SEUL niveau en v1 : un enfant n'a jamais d'enfants (l'assainisseur écarte le
-     *   surplus, la pose le refuse). Élargir = décision, pas dérive.
-     * · ⚠️ Frontless ne REND pas encore ce champ (grid.ts à enseigner — noté au Task
-     *   Board) : une maquette imbriquée exportée y montre le conteneur sans ses enfants.
+     * · IMBRICATION LIBRE jusqu'à `profondeurMax` (27/08, arbitrage SZU) : un enfant est
+     *   un item comme un autre, donc un conteneur peut en contenir un. Le plafond d'un
+     *   SEUL niveau, tenu du 24/08 au 27/08, rendait indéfendables les familles à pièce
+     *   typée — `cad-tabs > cad-tab > contenu` réclame deux niveaux, et un onglet qu'on
+     *   ne peut pas remplir est pire qu'un onglet absent. Au-delà du plafond, la pose
+     *   refuse VISIBLEMENT et l'assainisseur écarte le surplus : jamais de troncature
+     *   muette.
+     * · Le régime (`flux` ou `direct`) est celui du PARENT DIRECT, lu de son annotation
+     *   `@atelier conteneur=` — pas celui de la racine. Un `cad-tab` en flux dans un
+     *   `cad-tabs` en direct est la forme normale, pas un cas limite.
      */
     children?: AtelierItem[];
 }
@@ -8460,10 +8639,81 @@ interface AtelierLayout {
 /** Un plan vide, jamais `null` : un canevas absent et un canevas vide se traitent pareil. */
 declare const atelierLayoutVide: () => AtelierLayout;
 
+/**
+ * Le contrat d'accueil entre un HÔTE de la bibliothèque et les pièces qu'on lui POSE.
+ *
+ * ── POURQUOI CE FICHIER EXISTE ──────────────────────────────────────────────────
+ *
+ * L'atelier du studio et le rendu frontless du shell instancient les composants
+ * IMPÉRATIVEMENT (`createComponent` + `projectableNodes`) : c'est ce qui permet de poser
+ * le VRAI composant, vivant, plutôt qu'une image de lui. Mais deux mécanismes d'Angular
+ * ne traversent PAS cette frontière, et c'est mesuré, pas supposé (27/08) :
+ *
+ *   ① `contentChildren()` — une requête de contenu se résout sur la structure DÉCLARÉE
+ *      d'un gabarit. Un composant instancié à la main vit dans une autre vue : il arrive
+ *      bien dans le DOM, la requête ne le voit jamais. `cad-tabs` rendait `onglets=0`,
+ *      `cad-splitter` `gouttieres=0` — une barre vide, aucune erreur.
+ *   ② `inject(Hôte)` depuis la pièce — sans chaîne d'injecteurs de nœud, la recherche
+ *      remonte à l'injecteur d'environnement et échoue : `NG0201` pour
+ *      `cad-accordion-panel` et `cad-radio` (que `gen-catalog` classe d'ailleurs en
+ *      « contextuels », donc non posables), ou `null` silencieux quand l'injection est
+ *      `optional`.
+ *
+ * `<ng-content>` est donc NÉCESSAIRE mais PAS SUFFISANT pour qu'une famille soit un
+ * conteneur d'atelier. Le raccourci « ça projette, donc ça marche » a coûté une matinée :
+ * il faut aussi que l'hôte sache ACCUEILLIR une pièce qu'aucune requête ne lui rapportera.
+ *
+ * ── LE CONTRAT ──────────────────────────────────────────────────────────────────
+ *
+ * Il n'est pas neuf : `cad-button-group` le porte depuis le 24/08, posé le jour où l'on
+ * a constaté qu'un groupe était SOURD aux clics de ses boutons posés. Ce fichier ne
+ * l'invente pas, il l'ÉCRIT — jusqu'ici il vivait duck-typé dans le seul poseur du
+ * studio, invisible depuis la bibliothèque, ce qui a permis à `cad-map` de partir avec
+ * un nom à lui (`registerChild`) que personne n'appelle. Deux vocabulaires pour un
+ * besoin, c'est une famille cassée en silence.
+ */
+/**
+ * Un hôte capable d'accueillir des pièces créées hors gabarit.
+ *
+ * Le passage est la LISTE COMPLÈTE, jamais un ajout : le poseur reconstruit ses enfants
+ * d'un bloc à chaque changement de structure, et un contrat incrémental l'obligerait à
+ * tenir un différentiel — c'est ainsi qu'on garde un fantôme après une suppression.
+ */
+interface CadHoteAPieces {
+    /** Reçoit toutes les instances posées. L'hôte filtre lui-même ce qui le concerne. */
+    enregistrerEnfants(instances: unknown[]): void;
+}
+/**
+ * L'hôte sait-il accueillir des pièces posées ?
+ *
+ * Reconnaissance par CAPACITÉ et non par liste de types : un poseur qui énumérerait les
+ * familles concernées serait à mettre à jour à chaque nouvelle — et c'est toujours la
+ * mise à jour qu'on oublie. Une famille qui gagne la trappe devient utilisable dans
+ * l'atelier sans qu'aucun poseur ne bouge.
+ */
+declare function estHoteAPieces(hote: unknown): hote is CadHoteAPieces;
+
 /** Identifiant conforme à l'assainisseur backend : `/^[A-Za-z0-9_-]{1,24}$/`. */
 declare function atelierNouvelId(): string;
 /** Remet le compteur à zéro. Réservé aux tests, pour qu'ils ne dépendent pas de leur ordre. */
 declare function atelierReinitialiserIds(): void;
+/**
+ * Empêche les prochains ids de VOLER l'identité d'items déjà présents.
+ *
+ * ⚠️ À APPELER À CHAQUE CHARGEMENT d'un plan venu d'ailleurs (base, fichier collé). Le
+ * compteur est propre à la SESSION et repart de zéro : une maquette rechargée porte déjà
+ * `i1`, `i2`… et la première pose redonnait `i1`. Deux items partagent alors une clé, et
+ * tout ce qui vise par id se trompe de cible — `atelierTrouver` rend le premier homonyme,
+ * `transformerArbre` édite les deux, et le `@for … track` d'Angular en FUSIONNE deux à
+ * l'écran : un bloc disparaît du canevas sans qu'aucune erreur ne soit levée (NG0955 en
+ * avertissement, c'est tout).
+ *
+ * C'EST LE MÊME DÉFAUT QUE `eb87d3f7` (26/08), qui l'avait corrigé dans le builder
+ * frontless — « le compteur valait items.length et non le plus grand id existant ». Le
+ * format a DEUX producteurs ; le correctif n'en avait couvert qu'un. Il vit désormais
+ * dans la bibliothèque, là où les deux le partagent.
+ */
+declare function atelierAdopterIds(layout: AtelierLayout): void;
 /**
  * La première position libre pour un bloc de `w × h`, en balayant de haut en bas puis de
  * gauche à droite.
@@ -8476,22 +8726,27 @@ declare function atelierPremierePlaceLibre(items: readonly AtelierItem[], w: num
     x: number;
     y: number;
 };
-/** Nombre TOTAL de composants, enfants compris — c'est lui que borne `itemsMax`. */
+/** Nombre TOTAL de composants, à toutes les profondeurs — c'est lui que borne `itemsMax`. */
 declare function atelierCompter(layout: AtelierLayout): number;
 /**
- * Retrouve un composant OÙ QU'IL VIVE — au premier niveau ou dans un conteneur.
- * `parentId` dit d'où il vient : c'est ce qui permet à l'inspecteur de remonter.
+ * Retrouve un composant OÙ QU'IL VIVE, à n'importe quelle profondeur.
+ *
+ * `parentId` dit d'où il vient — c'est ce qui permet à l'inspecteur de remonter, d'un
+ * cran à la fois. `profondeur` dit à quel étage il se trouve (0 = sur le plan) : la
+ * pose s'en sert pour refuser AVANT d'agir, plutôt que de tronquer après.
  */
 declare function atelierTrouver(layout: AtelierLayout, id: string): {
     item: AtelierItem;
     parentId: string | null;
+    profondeur: number;
 } | null;
 /**
- * Pose un composant — sur le plan, ou DANS un conteneur (`dansId`).
+ * Pose un composant — sur le plan, ou DANS un conteneur (`dansId`), à n'importe quelle
+ * profondeur jusqu'à `profondeurMax`.
  *
  * Dans un conteneur, l'enfant vit en FLUX : ajouté en fin, x/y/w/h normalisés (0/0/12/1),
- * l'ordre fait loi. Refus VISIBLE (id vide) si le conteneur n'existe pas, est lui-même un
- * enfant (un seul niveau en v1), ou si un plafond est atteint — jamais de troncature
+ * l'ordre fait loi. Refus VISIBLE (id vide) si le conteneur n'existe pas, s'il est déjà
+ * au dernier étage autorisé, ou si un plafond est atteint — jamais de troncature
  * silencieuse, même doctrine que le plafond global.
  */
 declare function atelierAjouter(layout: AtelierLayout, type: string, gabarit?: {
@@ -8502,7 +8757,10 @@ declare function atelierAjouter(layout: AtelierLayout, type: string, gabarit?: {
     layout: AtelierLayout;
     id: string;
 };
-/** Retire un composant, où qu'il vive. Retirer un conteneur emporte ses enfants. */
+/**
+ * Retire un composant, où qu'il vive et à quelque profondeur que ce soit.
+ * Retirer un conteneur emporte toute sa descendance — jamais d'orphelin invisible.
+ */
 declare function atelierRetirer(layout: AtelierLayout, id: string): AtelierLayout;
 /** Change une propriété — où que vive le composant. `undefined` la supprime. */
 declare function atelierDefinirProp(layout: AtelierLayout, id: string, nom: string, valeur: string | number | boolean | string[] | undefined): AtelierLayout;
@@ -8608,6 +8866,20 @@ interface AtelierComposant {
      * métadonnée voyage avec lui, l'atelier n'a aucune liste.
      */
     ajustement: 'remplir' | 'naturel';
+    /**
+     * Ce composant DESSINE-T-IL quelque chose ? `aucune` = il occupe sa place sans rien
+     * rendre (`cad-spacer`).
+     *
+     * Sert aux OUTILS DE CONCEPTION à le matérialiser : un composant qui n'affiche rien
+     * est indistinguable d'un composant absent, on ne peut ni le voir ni le saisir. La
+     * métadonnée voyage avec le composant — l'atelier n'a aucune liste à tenir à jour, et
+     * c'est ce qui évite qu'un futur composant sans surface soit oublié.
+     *
+     * ⚠️ N'A AUCUN EFFET AU RENDU. Seule la feuille de style de l'ÉDITEUR agit dessus ;
+     * le visualiseur et le shell frontless n'ont pas la règle, donc ils ne peuvent pas
+     * l'afficher, même par erreur. La garantie est structurelle, pas conditionnelle.
+     */
+    surface: 'propre' | 'aucune';
     /**
      * Icône de palette (`@atelier icone=…`), VALIDÉE contre le jeu d'icônes réel : un nom
      * inconnu retombe sur `null` plutôt que d'afficher un carré cassé — mieux vaut vide
@@ -8638,6 +8910,16 @@ interface AtelierComposant {
      * apparaissent dans leur groupe quand on est « dans » le bon conteneur.
      */
     dans: string | null;
+    /**
+     * Les seules clés que cet hôte accueille (`@atelier accepte=cad-avatar`), ou `null`
+     * si rien n'est déclaré. Plusieurs clés se séparent par `|`.
+     *
+     * COMPLÈTE `dans=` sans le doubler. `dans=` dit « cette pièce ne va QUE là », ce qui
+     * rend son hôte strict par ricochet — c'est le cas de `cad-tabs` et de `cad-map`.
+     * Mais un `cad-avatar` se pose aussi très bien seul sur une carte : il ne peut donc
+     * pas porter `dans=`, et c'est alors à l'HÔTE de dire ce qu'il prend.
+     */
+    accepte: string[] | null;
     /**
      * Valeurs de départ des ENTRÉES à la pose (`@atelier pose-value=Étiquette`) — le
      * pendant de `contenu` pour les composants dont le visible passe par une entrée et
@@ -8699,18 +8981,111 @@ declare function atelierPalette(): readonly AtelierComposant[];
 /** Le composant derrière une clé de `layout.json`, ou `null` s'il n'existe plus. */
 declare function atelierComposant(cle: string): AtelierComposant | null;
 /**
- * Recherche par nom, clé ou sélecteur. Sans terme, rend tout — SAUF les composants
- * `dans=`, réservés à leur hôte : ils n'apparaissent que quand `hote` est le leur
- * (la cible de pose courante). `cad-map-panel` posé seul ne montre rien de sensé —
- * signalé par SZU le 24/08.
+ * Cet hôte accepte-t-il ce composant ? `hote = null` désigne le PLAN.
+ *
+ * ⚠️ `dans=` SE LIT DANS LES DEUX SENS, et c'est toute la règle (arbitrage SZU 27/08) :
+ *
+ *   · SENS DIRECT — une pièce ne se pose QUE chez son hôte. `cad-map-panel` posé seul
+ *     ne montre rien de sensé (signalé le 24/08), `cad-tab` hors d'un `cad-tabs` non plus.
+ *   · SENS INVERSE — un hôte QUI A des pièces n'accepte QUE ses pièces. `cad-tabs`
+ *     n'accueille que des `cad-tab`, `cad-map` que ses onze pièces de carte.
+ *
+ * La troisième règle en découle sans être écrite : un conteneur SANS pièce déclarée
+ * (`cad-tab`, `cad-panel`, `cad-grid`…) accepte tout, sauf ce qui appartient à un autre
+ * hôte. Rien à annoter : la relation existe déjà, on la lisait à moitié.
+ */
+declare function atelierAccepte(hote: string | null, cle: string): boolean;
+/**
+ * Les clés des pièces d'un hôte, dans l'ordre de la palette. Vide si l'hôte n'est pas
+ * strict — c'est le test « ce conteneur a-t-il des pièces à lui ? ».
+ */
+declare function atelierPiecesDe(hote: string | null): string[];
+/**
+ * Recherche par nom, clé ou sélecteur. Rend TOUT ce qui correspond au terme.
+ *
+ * ⚠️ NE FILTRE PLUS SUR LA CIBLE, et c'est délibéré (SZU 27/08, règle déjà posée le
+ * 26/08 pour le builder) : ce qu'un conteneur refuse doit apparaître VERROUILLÉ, pas
+ * disparaître. Masquer fait deux dégâts — ça dérobe l'information (l'utilisateur ne sait
+ * pas que le composant existe, ni pourquoi il n'est pas là) et ça fait SAUTER la palette
+ * à chaque changement de sélection, si bien qu'on ne retrouve plus rien où on l'avait vu.
+ *
+ * L'appelant interroge `atelierAccepte` pour savoir quoi désactiver, et dit pourquoi.
+ */
+declare function atelierChercher(terme: string): AtelierComposant[];
+/**
+ * Les composants groupés, dans l'ordre d'affichage de la palette.
+ *
+ * Les groupes ne dépendent PAS de la cible : la palette garde la même forme quoi qu'on
+ * sélectionne, ce qui est la moitié de l'intérêt du verrouillage-expliqué.
  */
-declare function atelierChercher(terme: string, hote?: string | null): AtelierComposant[];
-/** Les composants groupés, dans l'ordre d'affichage de la palette. */
-declare function atelierGroupes(terme?: string, hote?: string | null): {
+declare function atelierGroupes(terme?: string): {
     groupe: string;
     composants: AtelierComposant[];
 }[];
 
+/**
+ * OÙ un clic de palette pose réellement le composant.
+ *
+ * ── POURQUOI CE FICHIER EXISTE ──────────────────────────────────────────────────
+ *
+ * Depuis que les hôtes à pièces typées sont stricts, `cad-tabs` ne prend que des
+ * `cad-tab`. Conséquence immédiate, signalée par SZU le 27/08 : « je fais comment pour
+ * placer un composant sur cad-tab, puisque quand je sélectionne quelque chose c'est
+ * cad-tabs qui est sélectionné ? » — le canevas ne sélectionne que les blocs du PLAN, et
+ * la seule façon de viser un onglet était la liste de l'inspecteur. Ça marche, mais il
+ * faut le savoir : une affordance qu'on doit enseigner n'en est pas une.
+ *
+ * La règle, telle qu'elle a été demandée dès le premier message (« cad-spacer devrait
+ * aller dans cad-tab ») : quand l'hôte visé est STRICT et que le composant n'est pas une
+ * de ses pièces, on DESCEND dans sa pièce courante. Poser un onglet ajoute un onglet ;
+ * poser un bouton le met dans l'onglet affiché.
+ *
+ * Le routage ne s'applique QUE si l'hôte a exactement UN type de pièce et que cette
+ * pièce est elle-même un conteneur. `cad-map` a onze pièces, dont aucune n'accueille
+ * quoi que ce soit : il n'y a rien à router, et un `cad-button` y reste refusé — ce qui
+ * est la vérité, pas une limite d'outil.
+ *
+ * Rien ici ne mute : on rend une DESTINATION, l'appelant décide.
+ */
+
+/** La destination d'un clic de palette, résolue et explicable. */
+interface AtelierCible {
+    /** Le conteneur qui recevra le composant. `null` = le plan. */
+    dansId: string | null;
+    /**
+     * Pièce d'hôte à créer AVANT de poser, parce que l'hôte est strict et n'en a aucune.
+     * L'appelant pose d'abord celle-ci dans `dansId`, puis le composant dans la pièce
+     * obtenue. Elle apparaît à l'écran : rien de caché.
+     */
+    pieceACreer: string | null;
+    /**
+     * Le chemin lisible de la destination — `['cad-tabs', 'Onglet']` — pour l'ANNONCER
+     * avant le clic. Un routage qu'on ne voit pas est une surprise ; annoncé, c'est un
+     * service.
+     */
+    chemin: string[];
+    /** Faux si ce composant ne peut se poser nulle part dans cette cible. */
+    possible: boolean;
+}
+/**
+ * Résout la destination d'un clic de palette.
+ *
+ * `selectionId` est le composant actuellement sélectionné — un conteneur accueille, un
+ * composant simple fait poser à côté de lui, chez son parent.
+ */
+declare function atelierCibleDePose(layout: AtelierLayout, selectionId: string | null, cle: string): AtelierCible;
+/**
+ * Les valeurs de DÉPART d'un composant qu'on pose : le texte projeté (`contenu=`) et
+ * les entrées (`pose-*`) du catalogue.
+ *
+ * Extrait ici parce que DEUX poseurs doivent l'appliquer, et à DEUX endroits chacun :
+ * au composant cliqué, et à la pièce d'hôte que le routage crée au passage. Cette
+ * seconde application manquait — un onglet né du routage arrivait sans libellé, donc
+ * invisible dans la barre (mesuré au clic dans le builder le 27/08). Un composant posé
+ * sans ses valeurs de départ est une coquille, c'était déjà la leçon du 24/08.
+ */
+declare function atelierProposDePose(cle: string): AtelierItem['props'];
+
 /** `Relevé d'ouvrage` → `ReleveOuvrage`. */
 declare function atelierNomDeClasse(titre: string): string;
 /** `ReleveOuvrage` → `app-releve-ouvrage`. */
@@ -8763,10 +9138,10 @@ interface EntreeRegistre {
     /** La balise à créer pour l'héberger. */
     readonly hote: string;
 }
-/** Symbole -> de quoi le construire. 104 composants posables. */
+/** Symbole -> de quoi le construire. 106 composants posables. */
 declare const REGISTRE: Readonly<Record<string, EntreeRegistre>>;
 /** La classe d'un symbole, ou `null` s'il n'est pas posable (directive, ou hôte indéterminable). */
 declare function classeDe(symbole: string): Type<unknown> | null;
 
-export { ATELIER_BORNES, ATELIER_COLONNES, ATELIER_STYLES_PLAN, BanGeocoder, CAD_BREAKPOINTS, CAD_CHART_PALETTE, CAD_COLOR_PRESETS, CAD_DEFAULT_BASEMAPS, CAD_DEFAULT_PRIORITY_BREAKPOINTS, CAD_DIALOG_DATA, CAD_FILTER_OPERATORS, CAD_GEOCODER, CAD_ICONS, CAD_ICONS_CEREMA, CAD_ICONS_CORE, CAD_ICONS_DATA, CAD_ICONS_FILES, CAD_ICONS_GEO, CAD_ICONS_SUBSET, CAD_ICONS_TOKEN, CAD_ICONS_UI, CAD_ICON_ALIASES, CAD_ICON_CATEGORIES, CAD_MAPLIBRE_CSS_URL, CAD_MAP_CHILD, CAD_MAP_DEFAULTS, CAD_MAP_GLOBAL_STYLES, CAD_MAP_GLYPHS, CAD_MAP_PALETTE, CAD_MASK_PRESETS, CAD_MOBILE_BREAKPOINT, CAD_RECURRENCE_INTERNE, CAD_SELECT_POSITIONS, CAD_SELECT_TRIGGER_STYLES, CAD_SHEET_DATA, CAD_SHELL, CAD_TOUCH_DENSITY, CadAccordionComponent, CadAccordionPanelComponent, CadAppShellComponent, CadAvatarComponent, CadAvatarGroupComponent, CadBadgeComponent, CadBadgeDirective, CadBlockDirective, CadBlockOverlayComponent, CadBlockUiComponent, CadBottomNavComponent, CadBreadcrumbComponent, CadBreadcrumbItemDirective, CadBreakpointService, CadButtonComponent, CadButtonGroupComponent, CadCalendarComponent, CadCaptionDirective, CadCardComponent, CadCardDirective, CadCardHeaderDirective, CadCarouselComponent, CadCarouselItemDirective, CadCascadeSelectComponent, CadCellTemplateDirective, CadCenterComponent, CadChartComponent, CadCheckboxComponent, CadChipComponent, CadClusterComponent, CadColDirective, CadColorpickerComponent, CadColumnComponent, CadComboComponent, CadConfirmContentComponent, CadConfirmDialogComponent, CadConfirmService, CadContainerComponent, CadDataviewComponent, CadDataviewGridDirective, CadDataviewListDirective, CadDatepickerComponent, CadDialogComponent, CadDialogContainerComponent, CadDialogFooterDirective, CadDialogHeaderDirective, CadDialogRef, CadDialogService, CadDividerComponent, CadDrawerComponent, CadEditFocusDirective, CadEditorTemplateDirective, CadEmptyDirective, CadFieldComponent, CadFieldsetComponent, CadFieldsetLegendDirective, CadFilterChipComponent, CadFilterTemplateDirective, CadGanttComponent, CadGeocodingService, CadGridComponent, CadGroupFooterDirective, CadGroupHeaderDirective, CadHeaderTemplateDirective, CadIconComponent, CadIconRegistry, CadIfDirective, CadImageComponent, CadInplaceComponent, CadInplaceContentDirective, CadInplaceDisplayDirective, CadInputDirective, CadJsonEditorComponent, CadKeyFilterDirective, CadListEmptyDirective, CadListFooterDirective, CadListHeaderDirective, CadListItemDirective, CadListboxComponent, CadMapBasemapRegistry, CadMapBasemapsComponent, CadMapCardComponent, CadMapChromeComponent, CadMapComponent, CadMapDrawEngine, CadMapLayerComponent, CadMapLayerGroupComponent, CadMapLayerToggleComponent, CadMapLegendComponent, CadMapMenuComponent, CadMapPanelComponent, CadMapPanels, CadMapRailComponent, CadMapRailItemComponent, CadMapSearchComponent, CadMapSectionComponent, CadMaskDirective, CadMenuComponent, CadMenubarComponent, CadMessageComponent, CadMeterComponent, CadMeterLabelDirective, CadMultiselectComponent, CadNavDrawerComponent, CadNavDrawerFooterDirective, CadNavDrawerHeaderDirective, CadNumberComponent, CadOptionListComponent, CadOrderlistComponent, CadOrgNodeDirective, CadOrgchartComponent, CadOverlayBase, CadPaginatorComponent, CadPanelComponent, CadPanelContentDirective, CadPanelHeaderDirective, CadPanelHeadingDirective, CadPasswordComponent, CadPicklistComponent, CadPopoverComponent, CadProgressComponent, CadRadioComponent, CadRadioGroupComponent, CadRatingComponent, CadRowActionsDirective, CadRowCountDirective, CadRowExpansionDirective, CadSchedulerComponent, CadScrollTopComponent, CadSegmentedComponent, CadSelectBase, CadSelectComponent, CadSelectEmptyDirective, CadSelectFooterDirective, CadSelectHeaderDirective, CadSelectItemDirective, CadSelectSelectedDirective, CadSheetContainerComponent, CadSheetRef, CadSheetService, CadSidebarComponent, CadSidebarPanelDirective, CadSkeletonComponent, CadSliderComponent, CadSpacerComponent, CadSpeedDialComponent, CadSpinnerComponent, CadSplitButtonComponent, CadSplitComponent, CadSplitterComponent, CadSplitterPanelComponent, CadStackComponent, CadStepComponent, CadStepperComponent, CadSwitchComponent, CadTabComponent, CadTabContentDirective, CadTabLabelDirective, CadTableBase, CadTableComponent, CadTableEdit, CadTableEditUi, CadTableFooterDirective, CadTablePanelComponent, CadTableResponsive, CadTableSelection, CadTableSticky, CadTableVirtual, CadTabsComponent, CadTagComponent, CadTaskCardDirective, CadTaskRowDirective, CadTaskboardComponent, CadTimeAxis, CadTimelineComponent, CadTimelineContentDirective, CadTimelineMarkerDirective, CadTimelineOppositeDirective, CadToastComponent, CadToastItemDirective, CadToastService, CadToggleButtonComponent, CadTooltipComponent, CadTooltipDirective, CadTreeAdapter, CadTreeComponent, CadTreeNodeDirective, CadTreeselectComponent, CadUploadComponent, CadUploadContentDirective, CadUploadEmptyDirective, CadUploadItemDirective, CadValueAccessor, CadWorkCalendar, MAPLIBRE_MIN_CSS, REGISTRE, addDays, addMonths, addYears, atelierAjouter, atelierBalise, atelierChercher, atelierCleDeSymbole, atelierCode, atelierComposant, atelierCompter, atelierControle, atelierDefinirProp, atelierDeplacer, atelierGabarit, atelierGroupes, atelierImports, atelierLayoutVide, atelierManques, atelierNomDeClasse, atelierNormaliser, atelierNouvelId, atelierPalette, atelierPoser, atelierPremierePlaceLibre, atelierRecompacter, atelierRedimensionner, atelierReinitialiserIds, atelierReordonnerEnfant, atelierRetirer, atelierSelecteurDeClasse, atelierTrouver, cadAggregate, cadApplyColumnOrder, cadApplyMask, cadArea, cadAutosizeWidth, cadBasemapThumbnail, cadBoundsOf, cadCategories, cadCentroid, cadClipFenetre, cadColorExpr, cadCompare, cadCompareRank, cadCurrentOperator, cadDebutSemaine, cadDefaultMatchMode, cadDistance, cadDownloadCsv, cadDurationToMinutes, cadEstBandeau, cadExpandOccurrences, cadFilterData, cadFilterKindOf, cadFilterOperators, cadFilterRows, cadFindLinkCycle, cadFmtArea, cadFmtLength, cadFormatCell, cadFormatColor, cadFormatDuration, cadFormatSize, cadFrenchHolidays, cadGanttRows, cadGap, cadGeoJSONStats, cadGeometryKinds, cadHeaderMenuItems, cadHighlightJson, cadHslToRgb, cadHsvToRgb, cadId, cadIsGroupKey, cadIsRank, cadJsonErrorPos, cadLegendFromStyle, cadLength, cadMapEstVivante, cadMapLayerOf, cadMapLayersOf, cadMatch, cadMinuit, cadMonthGrid, cadMoveColumn, cadMoveItems, cadNormalize, cadNormalizeOptions, cadNormalizePlan, cadNumberExpr, cadNumeroJour, cadPackDay, cadPackLanes, cadPadBounds, cadParseColor, cadParseDuration, cadParseRRule, cadParseResponsive, cadPlanHeader, cadPlanTicks, cadPointeFleche, cadProjeterClavier, cadProjeterCreation, cadProjeterEdition, cadProjeterMois, cadPropsTable, cadRankBetween, cadRankFirst, cadRankLast, cadRankSequence, cadResolve, cadResolveResponsive, cadResponsive, cadRgbToHsl, cadRgbToHsv, cadRingArea, cadRouterLien, cadRowKey, cadRowPredicate, cadSameValue, cadScaleNext, cadScaleStart, cadSchedulerPartition, cadSortData, cadStartResize, cadStyleToExpressions, cadUnmask, cadUnscheduled, cadValidateGeoJSON, cadValueForOperator, cadWeekBands, cadWriteField, classeDe, compareDay, daysInMonth, endOfMonth, ensureMaplibreCss, formatDate, isBetweenDay, isSameDay, isSameMonth, isValidDate, isoOf, isoWeek, loadChartJs, loadMaplibre, monthNames, pad2, parseIso, parseWithFormat, provideCadIcons, startOfDay, startOfMonth, toDate, weekdayNames };
-export type { AtelierComposant, AtelierItem, AtelierLayout, AtelierProp, CadAggregate, CadAggregateFn, CadAggregates, CadBadgeSeverity, CadBand, CadBandRow, CadBasemap, CadBasemapKind, CadBottomNavItem, CadBounds, CadBreadcrumbItem, CadBreakpoint, CadCalendarChangeEvent, CadCalendarCreateEvent, CadCalendarDateEvent, CadCalendarEventEvent, CadCalendarSource, CadCalendarView, CadCarouselResponsive, CadCellContext, CadCellEditState, CadChartClickEvent, CadChartType, CadColonneDef, CadColorFormat, CadColorSpec, CadColumnAlign, CadColumnDataType, CadColumnEditor, CadColumnFilterOption, CadColumnFilterType, CadColumnMenuActionEvent, CadColumnPinEvent, CadColumnReorderEvent, CadColumnResizeEvent, CadColumnToggleEvent, CadComboSource, CadConfirmOptions, CadDataviewLayout, CadDateMode, CadDateSelection, CadDateValue, CadDialogConfig, CadDialogPosition, CadDialogSize, CadDisplayRow, CadDrawMode, CadDrawOptions, CadDrawerPosition, CadDuration, CadDurationUnit, CadEditBase, CadEditCompleteEvent, CadEditEvent, CadEditGeometry, CadEditKind, CadEditMode, CadEditorContext, CadExpandResult, CadFeatureEvent, CadFenetreSpan, CadFilterChangeEvent, CadFilterKind, CadFilterMatchMode, CadFilterMeta, CadFilterOperator, CadFilters, CadGanttRow, CadGanttScale, CadGanttTaskEvent, CadGap, CadGeoJSON, CadGeocodeOptions, CadGeocodeResult, CadGeocoder, CadGeometryKind, CadGroupBy, CadGroupContext, CadGroupInfo, CadGroupItem, CadHeaderMenuHost, CadHsva, CadLaneSpan, CadLayerStyle, CadLazyLoadEvent, CadLegendItem, CadLienAncre, CadLienTrace, CadListGroup, CadListItem, CadListNormalizeOpts, CadListOption, CadListRow, CadLngLat, CadMapChild, CadMapChrome, CadMapClick, CadMapControl, CadMapLayerType, CadMapMenuConfig, CadMapMenuItem, CadMapMenuPanel, CadMapMenuRailItem, CadMapMenuSection, CadMapPosition, CadMapSide, CadMapView, CadMeasure, CadMenuItem, CadMenubarItem, CadMeterValue, CadMonthGrid, CadNavDrawerItem, CadNavDrawerMode, CadNavDrawerRow, CadNodeEvent, CadNormalizePlanOptions, CadNormalizedPlan, CadNumberSpec, CadOccurrence, CadOptionItem, CadOrgNode, CadOverlayHandle, CadPageEvent, CadPaintSet, CadPinnedColumns, CadPlacement, CadPlan, CadPlanAssignment, CadPlanBucket, CadPlanCalendar, CadPlanCalendarException, CadPlanDateInput, CadPlanHeader, CadPlanHours, CadPlanIssue, CadPlanLink, CadPlanLinkType, CadPlanMarker, CadPlanResource, CadPlanScale, CadPlanTask, CadPlanTick, CadPlanTicksOptions, CadPlannedLink, CadPlannedTask, CadPriorityBreakpoints, CadProgressSeverity, CadRRule, CadRRuleFreq, CadRecurrenceIssue, CadRgba, CadRowEditEvent, CadRowEditState, CadRowEvent, CadRowReorderEvent, CadSchedulerAssignEvent, CadSchedulerChangeEvent, CadSchedulerCreateEvent, CadSchedulerEventEvent, CadSchedulerMode, CadSchedulerScale, CadSchedulerScheduleEvent, CadSegmentOption, CadSelectItemContext, CadSelectionMode, CadSelectionPropagation, CadSeverity, CadSheetConfig, CadSheetHeight, CadShellApi, CadSize, CadSliderMark, CadSliderSeverity, CadSliderValue, CadSlot, CadSortEvent, CadSortMeta, CadSortOrder, CadStepState, CadTableEditContext, CadTableEditUiContext, CadTablePanelTab, CadTableResponsiveMode, CadTableSelectionContext, CadTagSeverity, CadTaskAssignEvent, CadTaskMoveEvent, CadTaskOpenEvent, CadTaskboardGroupBy, CadTaskboardMode, CadTimelineAlign, CadToastAction, CadToastMessage, CadToastPosition, CadToastSeverity, CadTreeAdapterOptions, CadTreeNode, CadTreeNodeEvent, CadUploadFile, CadUploadHandlerEvent, CadUploadStatus, CadVariant, CadVirtualRange, CadWipEvent, EntreeRegistre, MLExpression, MaplibreModule };
+export { ATELIER_BORNES, ATELIER_COLONNES, ATELIER_STYLES_PLAN, BanGeocoder, CAD_BREAKPOINTS, CAD_CHART_PALETTE, CAD_COLOR_PRESETS, CAD_DEFAULT_BASEMAPS, CAD_DEFAULT_PRIORITY_BREAKPOINTS, CAD_DIALOG_DATA, CAD_FILTER_OPERATORS, CAD_GEOCODER, CAD_ICONS, CAD_ICONS_CEREMA, CAD_ICONS_CORE, CAD_ICONS_DATA, CAD_ICONS_FILES, CAD_ICONS_GEO, CAD_ICONS_SUBSET, CAD_ICONS_TOKEN, CAD_ICONS_UI, CAD_ICON_ALIASES, CAD_ICON_CATEGORIES, CAD_MAPLIBRE_CSS_URL, CAD_MAP_CHILD, CAD_MAP_DEFAULTS, CAD_MAP_GLOBAL_STYLES, CAD_MAP_GLYPHS, CAD_MAP_PALETTE, CAD_MASK_PRESETS, CAD_MOBILE_BREAKPOINT, CAD_RECURRENCE_INTERNE, CAD_SELECT_POSITIONS, CAD_SELECT_TRIGGER_STYLES, CAD_SHEET_DATA, CAD_SHELL, CAD_TOUCH_DENSITY, CadAccordionComponent, CadAccordionPanelComponent, CadAppShellComponent, CadAvatarComponent, CadAvatarGroupComponent, CadBadgeComponent, CadBadgeDirective, CadBlockDirective, CadBlockOverlayComponent, CadBlockUiComponent, CadBottomNavComponent, CadBreadcrumbComponent, CadBreadcrumbItemDirective, CadBreakpointService, CadButtonComponent, CadButtonGroupComponent, CadCalendarComponent, CadCaptionDirective, CadCardComponent, CadCardDirective, CadCardHeaderDirective, CadCarouselComponent, CadCarouselItemDirective, CadCascadeSelectComponent, CadCellTemplateDirective, CadCenterComponent, CadChartComponent, CadCheckboxComponent, CadChipComponent, CadClusterComponent, CadColDirective, CadColorpickerComponent, CadColumnComponent, CadComboComponent, CadConfirmContentComponent, CadConfirmDialogComponent, CadConfirmService, CadContainerComponent, CadDataviewComponent, CadDataviewGridDirective, CadDataviewListDirective, CadDatepickerComponent, CadDialogComponent, CadDialogContainerComponent, CadDialogFooterDirective, CadDialogHeaderDirective, CadDialogRef, CadDialogService, CadDividerComponent, CadDrawerComponent, CadEditFocusDirective, CadEditorTemplateDirective, CadEmptyDirective, CadFieldComponent, CadFieldsetComponent, CadFieldsetLegendDirective, CadFilterChipComponent, CadFilterTemplateDirective, CadGanttComponent, CadGeocodingService, CadGridComponent, CadGroupFooterDirective, CadGroupHeaderDirective, CadHeaderTemplateDirective, CadIconComponent, CadIconRegistry, CadIfDirective, CadImageComponent, CadInplaceComponent, CadInplaceContentDirective, CadInplaceDisplayDirective, CadInputDirective, CadJsonEditorComponent, CadKeyFilterDirective, CadListEmptyDirective, CadListFooterDirective, CadListHeaderDirective, CadListItemDirective, CadListboxComponent, CadMapBasemapRegistry, CadMapBasemapsComponent, CadMapCardComponent, CadMapChromeComponent, CadMapComponent, CadMapDrawEngine, CadMapLayerComponent, CadMapLayerGroupComponent, CadMapLayerToggleComponent, CadMapLegendComponent, CadMapMenuComponent, CadMapPanelComponent, CadMapPanels, CadMapRailComponent, CadMapRailItemComponent, CadMapSearchComponent, CadMapSectionComponent, CadMaskDirective, CadMenuComponent, CadMenubarComponent, CadMessageComponent, CadMeterComponent, CadMeterLabelDirective, CadMultiselectComponent, CadNavDrawerComponent, CadNavDrawerFooterDirective, CadNavDrawerHeaderDirective, CadNumberComponent, CadOptionListComponent, CadOrderlistComponent, CadOrgNodeDirective, CadOrgchartComponent, CadOverlayBase, CadPaginatorComponent, CadPanelComponent, CadPanelContentDirective, CadPanelHeaderDirective, CadPanelHeadingDirective, CadPasswordComponent, CadPicklistComponent, CadPopoverComponent, CadProgressComponent, CadRadioComponent, CadRadioGroupComponent, CadRatingComponent, CadRowActionsDirective, CadRowCountDirective, CadRowExpansionDirective, CadSchedulerComponent, CadScrollTopComponent, CadSegmentedComponent, CadSelectBase, CadSelectComponent, CadSelectEmptyDirective, CadSelectFooterDirective, CadSelectHeaderDirective, CadSelectItemDirective, CadSelectSelectedDirective, CadSheetContainerComponent, CadSheetRef, CadSheetService, CadSidebarComponent, CadSidebarPanelDirective, CadSkeletonComponent, CadSliderComponent, CadSpacerComponent, CadSpeedDialComponent, CadSpinnerComponent, CadSplitButtonComponent, CadSplitComponent, CadSplitterComponent, CadSplitterPanelComponent, CadStackComponent, CadStepComponent, CadStepperComponent, CadSwitchComponent, CadTabComponent, CadTabContentDirective, CadTabLabelDirective, CadTableBase, CadTableComponent, CadTableEdit, CadTableEditUi, CadTableFooterDirective, CadTablePanelComponent, CadTableResponsive, CadTableSelection, CadTableSticky, CadTableVirtual, CadTabsComponent, CadTagComponent, CadTaskCardDirective, CadTaskRowDirective, CadTaskboardComponent, CadTimeAxis, CadTimelineComponent, CadTimelineContentDirective, CadTimelineMarkerDirective, CadTimelineOppositeDirective, CadToastComponent, CadToastItemDirective, CadToastService, CadToggleButtonComponent, CadTooltipComponent, CadTooltipDirective, CadTreeAdapter, CadTreeComponent, CadTreeNodeDirective, CadTreeselectComponent, CadUploadComponent, CadUploadContentDirective, CadUploadEmptyDirective, CadUploadItemDirective, CadValueAccessor, CadWorkCalendar, MAPLIBRE_MIN_CSS, REGISTRE, addDays, addMonths, addYears, atelierAccepte, atelierAdopterIds, atelierAjouter, atelierBalise, atelierChercher, atelierCibleDePose, atelierCleDeSymbole, atelierCode, atelierComposant, atelierCompter, atelierControle, atelierDefinirProp, atelierDeplacer, atelierGabarit, atelierGroupes, atelierImports, atelierLayoutVide, atelierManques, atelierNomDeClasse, atelierNormaliser, atelierNouvelId, atelierPalette, atelierPiecesDe, atelierPoser, atelierPremierePlaceLibre, atelierProposDePose, atelierRecompacter, atelierRedimensionner, atelierReinitialiserIds, atelierReordonnerEnfant, atelierRetirer, atelierSelecteurDeClasse, atelierTrouver, cadAggregate, cadApplyColumnOrder, cadApplyMask, cadArea, cadAutosizeWidth, cadBasemapThumbnail, cadBoundsOf, cadCategories, cadCentroid, cadClipFenetre, cadColorExpr, cadCompare, cadCompareRank, cadCurrentOperator, cadDebutSemaine, cadDefaultMatchMode, cadDistance, cadDownloadCsv, cadDurationToMinutes, cadEstBandeau, cadExpandOccurrences, cadFilterData, cadFilterKindOf, cadFilterOperators, cadFilterRows, cadFindLinkCycle, cadFmtArea, cadFmtLength, cadFormatCell, cadFormatColor, cadFormatDuration, cadFormatSize, cadFrenchHolidays, cadGanttRows, cadGap, cadGeoJSONStats, cadGeometryKinds, cadHeaderMenuItems, cadHighlightJson, cadHslToRgb, cadHsvToRgb, cadId, cadIsGroupKey, cadIsRank, cadJsonErrorPos, cadLegendFromStyle, cadLength, cadMapEstVivante, cadMapLayerOf, cadMapLayersOf, cadMatch, cadMinuit, cadMonthGrid, cadMoveColumn, cadMoveItems, cadNormalize, cadNormalizeOptions, cadNormalizePlan, cadNumberExpr, cadNumeroJour, cadPackDay, cadPackLanes, cadPadBounds, cadParseColor, cadParseDuration, cadParseRRule, cadParseResponsive, cadPlanHeader, cadPlanTicks, cadPointeFleche, cadProjeterClavier, cadProjeterCreation, cadProjeterEdition, cadProjeterMois, cadPropsTable, cadRankBetween, cadRankFirst, cadRankLast, cadRankSequence, cadResolve, cadResolveResponsive, cadResponsive, cadRgbToHsl, cadRgbToHsv, cadRingArea, cadRouterLien, cadRowKey, cadRowPredicate, cadSameValue, cadScaleNext, cadScaleStart, cadSchedulerPartition, cadSortData, cadStartResize, cadStyleToExpressions, cadUnmask, cadUnscheduled, cadValidateGeoJSON, cadValueForOperator, cadWeekBands, cadWriteField, classeDe, compareDay, daysInMonth, endOfMonth, ensureMaplibreCss, estHoteAPieces, formatDate, isBetweenDay, isSameDay, isSameMonth, isValidDate, isoOf, isoWeek, loadChartJs, loadMaplibre, monthNames, pad2, parseIso, parseWithFormat, provideCadIcons, startOfDay, startOfMonth, toDate, weekdayNames };
+export type { AtelierCible, AtelierComposant, AtelierItem, AtelierLayout, AtelierProp, CadAggregate, CadAggregateFn, CadAggregates, CadBadgeSeverity, CadBand, CadBandRow, CadBasemap, CadBasemapKind, CadBottomNavItem, CadBounds, CadBreadcrumbItem, CadBreakpoint, CadCalendarChangeEvent, CadCalendarCreateEvent, CadCalendarDateEvent, CadCalendarEventEvent, CadCalendarSource, CadCalendarView, CadCarouselResponsive, CadCellContext, CadCellEditState, CadChartClickEvent, CadChartType, CadColonneDef, CadColorFormat, CadColorSpec, CadColumnAlign, CadColumnDataType, CadColumnEditor, CadColumnFilterOption, CadColumnFilterType, CadColumnMenuActionEvent, CadColumnPinEvent, CadColumnReorderEvent, CadColumnResizeEvent, CadColumnToggleEvent, CadComboSource, CadConfirmOptions, CadDataviewLayout, CadDateMode, CadDateSelection, CadDateValue, CadDialogConfig, CadDialogPosition, CadDialogSize, CadDisplayRow, CadDrawMode, CadDrawOptions, CadDrawerPosition, CadDuration, CadDurationUnit, CadEditBase, CadEditCompleteEvent, CadEditEvent, CadEditGeometry, CadEditKind, CadEditMode, CadEditorContext, CadExpandResult, CadFeatureEvent, CadFenetreSpan, CadFilterChangeEvent, CadFilterKind, CadFilterMatchMode, CadFilterMeta, CadFilterOperator, CadFilters, CadGanttRow, CadGanttScale, CadGanttTaskEvent, CadGap, CadGeoJSON, CadGeocodeOptions, CadGeocodeResult, CadGeocoder, CadGeometryKind, CadGroupBy, CadGroupContext, CadGroupInfo, CadGroupItem, CadHeaderMenuHost, CadHoteAPieces, CadHsva, CadLaneSpan, CadLayerStyle, CadLazyLoadEvent, CadLegendItem, CadLienAncre, CadLienTrace, CadListGroup, CadListItem, CadListNormalizeOpts, CadListOption, CadListRow, CadLngLat, CadMapChild, CadMapChrome, CadMapClick, CadMapControl, CadMapLayerType, CadMapMenuConfig, CadMapMenuItem, CadMapMenuPanel, CadMapMenuRailItem, CadMapMenuSection, CadMapPosition, CadMapSide, CadMapView, CadMeasure, CadMenuItem, CadMenubarItem, CadMeterValue, CadMonthGrid, CadNavDrawerItem, CadNavDrawerMode, CadNavDrawerRow, CadNodeEvent, CadNormalizePlanOptions, CadNormalizedPlan, CadNumberSpec, CadOccurrence, CadOptionItem, CadOrgNode, CadOverlayHandle, CadPageEvent, CadPaintSet, CadPinnedColumns, CadPlacement, CadPlan, CadPlanAssignment, CadPlanBucket, CadPlanCalendar, CadPlanCalendarException, CadPlanDateInput, CadPlanHeader, CadPlanHours, CadPlanIssue, CadPlanLink, CadPlanLinkType, CadPlanMarker, CadPlanResource, CadPlanScale, CadPlanTask, CadPlanTick, CadPlanTicksOptions, CadPlannedLink, CadPlannedTask, CadPriorityBreakpoints, CadProgressSeverity, CadRRule, CadRRuleFreq, CadRecurrenceIssue, CadRgba, CadRowEditEvent, CadRowEditState, CadRowEvent, CadRowReorderEvent, CadSchedulerAssignEvent, CadSchedulerChangeEvent, CadSchedulerCreateEvent, CadSchedulerEventEvent, CadSchedulerMode, CadSchedulerScale, CadSchedulerScheduleEvent, CadSegmentOption, CadSelectItemContext, CadSelectionMode, CadSelectionPropagation, CadSeverity, CadSheetConfig, CadSheetHeight, CadShellApi, CadSize, CadSliderMark, CadSliderSeverity, CadSliderValue, CadSlot, CadSortEvent, CadSortMeta, CadSortOrder, CadStepState, CadTableEditContext, CadTableEditUiContext, CadTablePanelTab, CadTableResponsiveMode, CadTableSelectionContext, CadTagSeverity, CadTaskAssignEvent, CadTaskMoveEvent, CadTaskOpenEvent, CadTaskboardGroupBy, CadTaskboardMode, CadTimelineAlign, CadToastAction, CadToastMessage, CadToastPosition, CadToastSeverity, CadTreeAdapterOptions, CadTreeNode, CadTreeNodeEvent, CadUploadFile, CadUploadHandlerEvent, CadUploadStatus, CadVariant, CadVirtualRange, CadWipEvent, EntreeRegistre, MLExpression, MaplibreModule };