diff --git a/CHANGELOG.md b/CHANGELOG.md
index dedef88e..f6f96499 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,41 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le pr
 
 ## [Unreleased]
 
+### Added
+
+- **`ui-autocomplete` expose `nativeInputElement()` et `close()`** (FSHSP-258). `close()`
+  ferme le panneau sans déplacer le focus, `close(true)` le rend au champ.
+- **Directive `UiBrowserFill` et mixin `utils.browser-fill`** (FSHSP-258), pour un champ
+  maison bâti sur `@4sh/ui-kit/forms`. La directive signale les événements par lesquels le
+  navigateur peut écrire une valeur sans `input` (animation `:-webkit-autofill`, `change`), à
+  comparer avec la valeur affichée ; le mixin, inclus à la racine de la feuille du composant,
+  déclare cette animation. `hasFocus(element)` distingue une frappe d'un `input` reçu par un
+  champ sans focus. Une case personnalisée de `ui-input-otp` (template `#input`) s'y branche
+  par `events.browserFill`.
+
+### Fixed
+
+- **Une valeur préremplie par le navigateur met à jour le modèle sans clic dans le champ**
+  (FSHSP-258). `ui-input`, `ui-textarea`, `ui-input-number`, `ui-input-mask`,
+  `ui-input-otp`, `ui-autocomplete` et la saisie de `ui-datepicker` n'écoutaient que
+  l'`input` de leur champ natif ; selon le navigateur, la saisie automatique n'en émet aucun
+  ou seulement un `change`. Ils suivent aussi l'animation `:-webkit-autofill` et le `change`
+  dès que la valeur native diffère de celle affichée, et `valueChange` comme le `onChange` du
+  CVA partent une seule fois. Une valeur écrite sans focus est traitée comme telle :
+  `ui-input-number` la formate aussitôt, `ui-datepicker` la valide sans attendre la sortie du
+  champ (et revient à la valeur précédente si ce n'est pas une date), `ui-input-otp` la
+  répartit sans prendre le focus, `ui-input-mask` ne place pas de curseur, `ui-autocomplete`
+  lance la recherche sans ouvrir son panneau et, avec `forceSelection`, retient la suggestion
+  qui porte ce libellé dès qu'elle arrive. Dans les tests d'une application, un `input` envoyé sans focus à ces deux
+  derniers composants vaut désormais remplissage : focaliser le champ pour simuler une
+  frappe. Hors de portée : une valeur que Chrome préremplit au chargement de la page reste
+  illisible par JavaScript jusqu'à une interaction.
+- **Les événements que Chrome envoie avec sa saisie automatique n'ouvrent plus de panneau**
+  (FSHSP-258). Chaque champ rempli reçoit un `focus` qui ne lui donne pas le focus, puis un
+  `keydown` sans touche. `ui-datepicker` en `showOnFocus` ouvrait son calendrier,
+  `ui-autocomplete` en `completeOnFocus` lançait sa recherche, `ui-input-otp` prenait le focus
+  et levait une erreur : tous trois ignorent désormais ces événements.
+
 ## [0.15.0] - 2026-10-23
 
 ### Added
diff --git a/projects/ui-kit/README.fr.md b/projects/ui-kit/README.fr.md
index 1344bec3..010a4a25 100644
--- a/projects/ui-kit/README.fr.md
+++ b/projects/ui-kit/README.fr.md
@@ -351,6 +351,7 @@ construisez **votre propre champ** en réutilisant les conventions du kit.
 | `maskEngine`                                                      | Moteur de masque de saisie partagé (`ui-input-mask`, `ui-datepicker`).                                                                                                                                                                                                                                       |
 | `date-utils`                                                      | Helpers `Date` ↔ chaîne ISO, sérialisés depuis les composantes LOCALES et jamais via `toISOString()` (`ui-datepicker`, `ui-input-date`).                                                                                                                                                                     |
 | `option-resolver`, `format-label`, `warn-missing-accessible-name` | Utilitaires de résolution d'options, de formatage de libellé et garde-fou d'accessibilité.                                                                                                                                                                                                                   |
+| `UiBrowserFill`, `hasFocus()`                                     | Suivi de la saisie automatique du navigateur dans un champ maison (voir ci-dessous).                                                                                                                                                                                                                         |
 
 ### Créer son propre champ
 
@@ -370,6 +371,13 @@ export class MyField extends BaseFormField<string> {
 }
 ```
 
+Pour suivre la **saisie automatique du navigateur**, qui n'émet pas toujours d'`input` :
+posez la directive `uiBrowserFill` sur l'élément natif, incluez `@include utils.browser-fill;`
+à la racine de la feuille du composant, et sur `(browserFill)` synchronisez le modèle quand la
+valeur native diffère de celle affichée. `hasFocus(element)` distingue une frappe d'une valeur
+écrite sans focus. Détail et exemple : section « Saisie automatique du navigateur » de la page
+`ui-input` dans Storybook.
+
 ---
 
 ## Accessibilité
diff --git a/projects/ui-kit/README.md b/projects/ui-kit/README.md
index 83f08686..fc35c498 100644
--- a/projects/ui-kit/README.md
+++ b/projects/ui-kit/README.md
@@ -348,6 +348,7 @@ build **your own field** while reusing the kit's conventions.
 | `maskEngine`                                                      | Shared input mask engine (`ui-input-mask`, `ui-datepicker`).                                                                                                                                                                                                                                              |
 | `date-utils`                                                      | Pure `Date` ↔ ISO-string helpers, serialized from LOCAL components and never through `toISOString()` (`ui-datepicker`, `ui-input-date`).                                                                                                                                                                  |
 | `option-resolver`, `format-label`, `warn-missing-accessible-name` | Option resolution, label formatting and accessibility guardrail helpers.                                                                                                                                                                                                                                  |
+| `UiBrowserFill`, `hasFocus()`                                     | Tracks the browser's autofill in a custom field (see below).                                                                                                                                                                                                                                              |
 
 ### Building your own field
 
@@ -367,6 +368,13 @@ export class MyField extends BaseFormField<string> {
 }
 ```
 
+To follow the **browser's autofill**, which does not always fire `input`: put the
+`uiBrowserFill` directive on the native element, add `@include utils.browser-fill;` at the
+root of the component stylesheet, and on `(browserFill)` sync the model when the native value
+differs from the one rendered. `hasFocus(element)` tells a keystroke apart from a value written
+without focus. Details and example: the "Saisie automatique du navigateur" section of the
+`ui-input` page in Storybook.
+
 ---
 
 ## Accessibility
diff --git a/projects/ui-kit/forms/src/lib/browser-fill.spec.ts b/projects/ui-kit/forms/src/lib/browser-fill.spec.ts
new file mode 100644
index 00000000..b68eb1eb
--- /dev/null
+++ b/projects/ui-kit/forms/src/lib/browser-fill.spec.ts
@@ -0,0 +1,73 @@
+/**
+ * Spec for `UiBrowserFill`: which native events it reports as a possible
+ * browser fill. Deduplication against what the host renders is the host's
+ * job, covered by each field's own browser-fill spec.
+ */
+import { Component } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { describe, expect, it } from 'vitest';
+import { hasFocus, UiBrowserFill } from './browser-fill';
+
+@Component({
+  imports: [UiBrowserFill],
+  template: `<input uiBrowserFill (browserFill)="fills.push($event)" />`,
+})
+class FillHost {
+  readonly fills: Event[] = [];
+}
+
+async function setup() {
+  await TestBed.configureTestingModule({ imports: [FillHost] }).compileComponents();
+  const fixture: ComponentFixture<FillHost> = TestBed.createComponent(FillHost);
+  fixture.detectChanges();
+  const input = fixture.nativeElement.querySelector('input') as HTMLInputElement;
+  return { fills: fixture.componentInstance.fills, input };
+}
+
+function animationStart(el: HTMLElement, animationName: string): Event {
+  const event = new Event('animationstart', { bubbles: true });
+  Object.defineProperty(event, 'animationName', { value: animationName });
+  el.dispatchEvent(event);
+  return event;
+}
+
+describe('UiBrowserFill', () => {
+  it('marks its host for the browser-fill stylesheet rule', async () => {
+    const { input } = await setup();
+    expect(input.classList).toContain('ui-browser-fill');
+  });
+
+  it('reports the autofill animation, under its encapsulated name too', async () => {
+    const { fills, input } = await setup();
+    const event = animationStart(input, '_ngcontent-ng-c1_ui-browser-fill');
+    expect(fills).toEqual([event]);
+  });
+
+  it('ignores any other animation', async () => {
+    const { fills, input } = await setup();
+    animationStart(input, 'ui-ripple-wave');
+    expect(fills).toEqual([]);
+  });
+
+  it('reports a change', async () => {
+    const { fills, input } = await setup();
+    const event = new Event('change', { bubbles: true });
+    input.dispatchEvent(event);
+    expect(fills).toEqual([event]);
+  });
+
+  it('leaves input to the host', async () => {
+    const { fills, input } = await setup();
+    input.dispatchEvent(new Event('input', { bubbles: true }));
+    expect(fills).toEqual([]);
+  });
+});
+
+describe('hasFocus', () => {
+  it('tells the focused element apart', async () => {
+    const { input } = await setup();
+    expect(hasFocus(input)).toBe(false);
+    input.focus();
+    expect(hasFocus(input)).toBe(true);
+  });
+});
diff --git a/projects/ui-kit/forms/src/lib/browser-fill.ts b/projects/ui-kit/forms/src/lib/browser-fill.ts
new file mode 100644
index 00000000..38ad2d9c
--- /dev/null
+++ b/projects/ui-kit/forms/src/lib/browser-fill.ts
@@ -0,0 +1,40 @@
+import { Directive, output } from '@angular/core';
+
+/** Keyframes run by the `browser-fill` SCSS mixin while the browser autofills the field. */
+const AUTOFILL_ANIMATION = 'ui-browser-fill';
+
+/**
+ * Reports the events through which the browser may write a value into a native
+ * `<input>`/`<textarea>` without an `input` event:
+ *
+ * - its autofill: the `:-webkit-autofill` animation declared by the
+ *   `utils.browser-fill` mixin, which the host stylesheet must include;
+ * - a `change`.
+ *
+ * Either may follow an edit the host already handled through `input`: the
+ * host syncs only when the native value differs from the one it renders, so
+ * nothing is emitted twice. An `input` sent by the browser to a field without
+ * focus already reaches the host's own `(input)` handler: `hasFocus()` tells
+ * it apart from a keystroke.
+ */
+@Directive({
+  selector: '[uiBrowserFill]',
+  host: {
+    class: 'ui-browser-fill',
+    '(change)': 'browserFill.emit($event)',
+    '(animationstart)': 'onAnimationStart($event)',
+  },
+})
+export class UiBrowserFill {
+  /** Emitted with the change/animation event that may reveal a fill. */
+  readonly browserFill = output<Event>();
+
+  protected onAnimationStart(event: AnimationEvent): void {
+    if (event.animationName.endsWith(AUTOFILL_ANIMATION)) this.browserFill.emit(event);
+  }
+}
+
+/** Whether `element` holds the focus (works inside a shadow root). */
+export function hasFocus(element: Element): boolean {
+  return (element.getRootNode() as Document | ShadowRoot).activeElement === element;
+}
diff --git a/projects/ui-kit/forms/src/public-api.ts b/projects/ui-kit/forms/src/public-api.ts
index eb347488..120bf5b8 100644
--- a/projects/ui-kit/forms/src/public-api.ts
+++ b/projects/ui-kit/forms/src/public-api.ts
@@ -16,3 +16,4 @@ export * from './lib/date-utils';
 export * from './lib/option-resolver';
 export * from './lib/format-label';
 export * from './lib/warn-missing-accessible-name';
+export * from './lib/browser-fill';
diff --git a/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.browser-fill.spec.ts b/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.browser-fill.spec.ts
new file mode 100644
index 00000000..ffa586dd
--- /dev/null
+++ b/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.browser-fill.spec.ts
@@ -0,0 +1,192 @@
+/**
+ * TestBed spec for a value the browser writes into `ui-autocomplete` without a
+ * keystroke: the model follows, the query runs, but no panel opens under a
+ * field the user is not in. With `forceSelection`, the suggestion carrying
+ * that label is picked once it arrives.
+ */
+import { Component, signal, viewChild } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { describe, expect, it } from 'vitest';
+import { AutocompleteCompleteEvent, UiAutocomplete } from './ui-autocomplete';
+
+if (!Element.prototype.scrollIntoView) {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function -- jsdom stub, intentionally a no-op
+  Element.prototype.scrollIntoView = () => {};
+}
+
+const CITIES = ['Paris', 'Lyon', 'Marseille'];
+
+@Component({
+  imports: [ReactiveFormsModule, UiAutocomplete],
+  template: `
+    <ui-autocomplete
+      label="Ville"
+      [delay]="0"
+      [completeOnFocus]="completeOnFocus()"
+      [forceSelection]="forceSelection()"
+      [suggestions]="suggestions()"
+      [formControl]="control"
+      (completeMethod)="onComplete($event)"
+      (valueChange)="emitted.push($event)"
+      (optionSelect)="selected.push($event)"
+    />
+  `,
+})
+class FillHost {
+  readonly autocomplete = viewChild.required(UiAutocomplete);
+  readonly control = new FormControl<string | null>(null);
+  readonly forceSelection = signal(false);
+  readonly completeOnFocus = signal(false);
+  readonly suggestions = signal<string[]>([]);
+  /** Answers each query at once, unless the test answers it later. */
+  answerAtOnce = true;
+  readonly queries: string[] = [];
+  readonly emitted: unknown[] = [];
+  readonly selected: unknown[] = [];
+
+  onComplete(event: AutocompleteCompleteEvent): void {
+    this.queries.push(event.query);
+    if (this.answerAtOnce) this.answer(event.query);
+  }
+
+  answer(query: string): void {
+    const needle = query.trim().toLowerCase();
+    this.suggestions.set(CITIES.filter((c) => c.toLowerCase().includes(needle)));
+  }
+}
+
+async function setup(forceSelection = false) {
+  await TestBed.configureTestingModule({ imports: [FillHost] }).compileComponents();
+  const fixture: ComponentFixture<FillHost> = TestBed.createComponent(FillHost);
+  fixture.componentInstance.forceSelection.set(forceSelection);
+  fixture.detectChanges();
+  await fixture.whenStable();
+  const input = fixture.nativeElement.querySelector('.ui-autocomplete-input') as HTMLInputElement;
+  const settle = async () => {
+    fixture.detectChanges();
+    await fixture.whenStable();
+  };
+  const fire = async (type: string, animationName?: string) => {
+    const event = new Event(type, { bubbles: true });
+    if (animationName) Object.defineProperty(event, 'animationName', { value: animationName });
+    input.dispatchEvent(event);
+    await settle();
+  };
+  return { host: fixture.componentInstance, input, settle, fire };
+}
+
+const panel = () => document.querySelector('.ui-autocomplete-panel');
+const tick = () => new Promise((resolve) => setTimeout(resolve));
+
+describe('UiAutocomplete — browser fill', () => {
+  it('takes a value written without focus, queries at once, opens nothing', async () => {
+    const { host, input, fire } = await setup();
+    input.value = 'Paris';
+    await fire('input');
+    await tick();
+    expect(host.control.value).toBe('Paris');
+    expect(host.emitted).toEqual(['Paris']);
+    expect(host.queries).toEqual(['Paris']);
+    expect(panel()).toBeNull();
+    expect(document.activeElement).not.toBe(input);
+  });
+
+  it('takes a value revealed by a change alone, once', async () => {
+    const { host, input, fire } = await setup();
+    input.value = 'Lyon';
+    await fire('change');
+    await fire('animationstart', 'ui-browser-fill');
+    await tick();
+    expect(host.control.value).toBe('Lyon');
+    expect(host.emitted).toEqual(['Lyon']);
+    expect(host.queries).toEqual(['Lyon']);
+    expect(panel()).toBeNull();
+  });
+
+  it('still opens the panel for a typed query', async () => {
+    const { host, input, settle, fire } = await setup();
+    input.focus();
+    input.value = 'Par';
+    await fire('input');
+    await tick();
+    await settle();
+    expect(host.queries).toEqual(['Par']);
+    expect(panel()).not.toBeNull();
+  });
+
+  describe('with forceSelection', () => {
+    it('picks the suggestion carrying the filled label', async () => {
+      const { host, input, fire } = await setup(true);
+      input.value = 'paris';
+      await fire('input');
+      expect(host.control.value).toBe('Paris');
+      expect(host.selected).toEqual(['Paris']);
+      expect(input.value).toBe('Paris');
+      expect(panel()).toBeNull();
+    });
+
+    it('waits for the suggestions answering the query', async () => {
+      const { host, input, settle, fire } = await setup(true);
+      host.answerAtOnce = false;
+      input.value = 'Marseille';
+      await fire('change');
+      expect(host.control.value).toBeNull();
+      host.answer('Marseille');
+      await settle();
+      expect(host.control.value).toBe('Marseille');
+      expect(host.selected).toEqual(['Marseille']);
+    });
+
+    it('keeps the model empty when no suggestion carries the label', async () => {
+      const { host, input, fire } = await setup(true);
+      input.value = 'Pa';
+      await fire('input');
+      expect(host.control.value).toBeNull();
+      expect(host.selected).toEqual([]);
+    });
+
+    it('drops the pending fill once the user types', async () => {
+      const { host, input, settle, fire } = await setup(true);
+      host.answerAtOnce = false;
+      input.value = 'Lyon';
+      await fire('input');
+      input.focus();
+      input.value = 'Lyo';
+      await fire('input');
+      host.answer('Lyon');
+      await settle();
+      expect(host.control.value).toBeNull();
+      expect(host.selected).toEqual([]);
+    });
+  });
+
+  it('ignores the focus event Chrome sends to a field its autofill fills', async () => {
+    const { host, input, settle } = await setup();
+    host.completeOnFocus.set(true);
+    await settle();
+    input.dispatchEvent(new FocusEvent('focus'));
+    await settle();
+    expect(host.queries).toEqual([]);
+    expect(panel()).toBeNull();
+    input.focus();
+    await settle();
+    expect(host.queries).toEqual(['']);
+  });
+
+  it('exposes its native input and closes without taking the focus', async () => {
+    const { host, input, settle, fire } = await setup();
+    expect(host.autocomplete().nativeInputElement()).toBe(input);
+    input.focus();
+    input.value = 'Par';
+    await fire('input');
+    await tick();
+    await settle();
+    expect(panel()).not.toBeNull();
+    input.blur();
+    host.autocomplete().close();
+    await settle();
+    expect(panel()).toBeNull();
+    expect(document.activeElement).not.toBe(input);
+  });
+});
diff --git a/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.html b/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.html
index 33b49789..989c953b 100644
--- a/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.html
+++ b/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.html
@@ -209,6 +209,7 @@
 
       <input
         #inputEl
+        uiBrowserFill
         type="text"
         class="ui-autocomplete-input"
         [class._small]="size() === 'small'"
@@ -233,6 +234,7 @@
         [attr.aria-required]="required() ? 'true' : null"
         [attr.aria-invalid]="effectiveLevel() === 'error' ? 'true' : null"
         (input)="onInput($event)"
+        (browserFill)="onBrowserFill($event)"
         (keydown)="onInputKeydown($event)"
         (focus)="onInputFocus($event)"
         (blur)="onInputBlur($event)"
@@ -286,9 +288,9 @@
   [cdkConnectedOverlayPositions]="overlayPositions()"
   [cdkConnectedOverlayHasBackdrop]="true"
   cdkConnectedOverlayBackdropClass="cdk-overlay-transparent-backdrop"
-  (backdropClick)="close(false)"
-  (overlayOutsideClick)="close(false)"
-  (detach)="close(false)"
+  (backdropClick)="close()"
+  (overlayOutsideClick)="close()"
+  (detach)="close()"
 >
   <ng-container [ngTemplateOutlet]="panelTpl" />
 </ng-template>
diff --git a/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.scss b/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.scss
index 27e0bb2b..0c0550d2 100644
--- a/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.scss
+++ b/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.scss
@@ -47,6 +47,8 @@ $clear-size: var(--ui-autocomplete-clear-size, var(--size-components-2xs));
 $clear-radius: var(--ui-autocomplete-clear-radius, var(--radius-full));                      /// Rayon du bouton d'effacement.
 $focus-ring-width: var(--ui-autocomplete-focus-ring-width, #{utils.$form-focus-ring-width}); /// Épaisseur de l'anneau de focus (valeur sélectionnée, bouton d'effacement).
 
+@include utils.browser-fill;
+
 .ui-autocomplete {
   display: block;
   --ui-field-box-cursor: text;
diff --git a/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.ts b/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.ts
index f0bf55c0..eb94d0ad 100644
--- a/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.ts
+++ b/projects/ui-kit/forms/ui-autocomplete/src/lib/ui-autocomplete.ts
@@ -20,7 +20,7 @@ import { NgTemplateOutlet } from '@angular/common';
 import { NG_VALUE_ACCESSOR } from '@angular/forms';
 import { OverlayModule } from '@angular/cdk/overlay';
 import { CdkVirtualScrollViewport, ScrollingModule } from '@angular/cdk/scrolling';
-import { BaseFormField } from '@4sh/ui-kit/forms';
+import { BaseFormField, hasFocus, UiBrowserFill } from '@4sh/ui-kit/forms';
 import { createOptionResolver } from '@4sh/ui-kit/forms';
 import { dropdownOverlayPositions } from '@4sh/ui-kit/forms';
 import { formatLabel } from '@4sh/ui-kit/forms';
@@ -124,6 +124,10 @@ type AcRow =
  * (`role="combobox"` + `aria-activedescendant`: focus never leaves the input,
  * suggestions are only visually focused).
  *
+ * A value the browser writes into the input without focus (autofill) updates
+ * the model and emits `completeMethod` without opening the panel; with
+ * `forceSelection`, the suggestion carrying that exact label is then selected.
+ *
  * Customisation: the `#item`, `#selectedItem`, `#group`, `#header`, `#footer`
  * and `#empty` templates, `panelStyleClass`, and the local SCSS variables.
  *
@@ -145,6 +149,7 @@ type AcRow =
     UiSpinner,
     UiChip,
     UiMotion,
+    UiBrowserFill,
   ],
   templateUrl: './ui-autocomplete.html',
   styleUrl: './ui-autocomplete.scss',
@@ -285,7 +290,7 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
   /** @ignore Component root (overlay origin + outside-focus detection). */
   private readonly containerEl = viewChild.required<ElementRef<HTMLElement>>('container');
   /** @ignore Focusable input (combobox). */
-  private readonly inputEl = viewChild<ElementRef<HTMLInputElement>>('inputEl');
+  private readonly inputEl = viewChild.required<ElementRef<HTMLInputElement>>('inputEl');
   /** @ignore Panel root element (for scrolling the focused option into view). */
   private readonly panelEl = viewChild<ElementRef<HTMLElement>>('panel');
   /** @ignore Virtual-scroll viewport (lazy range + scrollToIndex). */
@@ -313,13 +318,15 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
   private searchTimeout: ReturnType<typeof setTimeout> | undefined;
   /** @ignore A written value whose label could not be resolved yet (see `writeValue`). */
   private readonly pendingLabelSync = signal(false);
+  /** @ignore `forceSelection`: a text written by the browser, awaiting the suggestion it names. */
+  private readonly pendingFill = signal<{ text: string; event: Event } | null>(null);
 
   constructor() {
     super();
 
     // Never carry an open panel over to the next page (the field can live in
     // an app shell that survives the navigation).
-    closeOnNavigation(() => this.close(false));
+    closeOnNavigation(() => this.close());
 
     // Late label resolution: a value written before suggestions exist (e.g. a
     // pre-filled form using `optionValue`) displays the raw value; swap in the
@@ -335,6 +342,18 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
       });
     });
 
+    // `forceSelection` applies the blur rule to a browser fill as soon as a
+    // suggestion carries its label: no blur will follow to apply it.
+    effect(() => {
+      const fill = this.pendingFill();
+      const match = fill ? this.entryLabelled(fill.text) : undefined;
+      if (!fill || !match) return;
+      untracked(() => {
+        this.pendingFill.set(null);
+        this.selectEntry(match, fill.event, false);
+      });
+    });
+
     // Forward the rendered range of the virtual viewport (lazy loading).
     effect((onCleanup) => {
       const vp = this.viewport();
@@ -538,6 +557,7 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
   // --- CVA -----------------------------------------------------------------
 
   override writeValue(value: AutocompleteValue<T>): void {
+    this.pendingFill.set(null);
     if (this.multiple()) {
       const values = Array.isArray(value) ? value : [];
       this.modelValue.set(values as T[]);
@@ -567,7 +587,12 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
 
   /** Moves focus to the input. */
   focus(options?: FocusOptions): void {
-    this.inputEl()?.nativeElement.focus(options);
+    this.inputEl().nativeElement.focus(options);
+  }
+
+  /** Native `<input>` element (the combobox). */
+  nativeInputElement(): HTMLInputElement {
+    return this.inputEl().nativeElement;
   }
 
   // --- Panel open/close ----------------------------------------------------
@@ -588,8 +613,8 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
     setTimeout(() => this.scrollFocusedIntoView());
   }
 
-  /** @ignore */
-  protected close(focusInput = true): void {
+  /** Closes the suggestions panel; `focusInput` moves the focus back to the input. */
+  close(focusInput = false): void {
     if (!this.panelOpen()) return;
     this.panelOpen.set(false);
     this.focusedIndex.set(-1);
@@ -606,12 +631,16 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
 
   // --- Input interactions --------------------------------------------------
 
-  /** @ignore Typing: view → form (free text unless `forceSelection`) + debounced query. */
+  /** @ignore Typing: view → form (free text unless `forceSelection`) + debounced query.
+   *  A value written by the browser without focus queries at once, panel closed. */
   protected onInput(event: Event): void {
-    const query = (event.target as HTMLInputElement).value;
+    const input = event.target as HTMLInputElement;
+    const query = input.value;
+    const typed = hasFocus(input);
     this.inputText.set(query);
     // The user took over the text: stop any pending label re-resolution.
     this.pendingLabelSync.set(false);
+    this.pendingFill.set(!typed && this.forceSelection() && query ? { text: query, event } : null);
 
     // Free-text value while typing; `forceSelection` waits for a real suggestion,
     // `multiple` never lets the query mutate the selection, and an emptied input
@@ -623,19 +652,28 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
 
     if (query.length === 0) {
       if (!this.multiple()) this.cleared.emit();
-      this.close(false);
+      this.close();
       return;
     }
 
     if (query.length < this.minLength()) {
-      this.close(false);
+      this.close();
       return;
     }
 
     this.focusedIndex.set(-1);
+    if (!typed) {
+      this.completeMethod.emit({ originalEvent: event, query });
+      return;
+    }
     this.searchTimeout = setTimeout(() => this.runSearch(event, query), this.delay());
   }
 
+  /** @ignore Value written by the browser without an `input` event. */
+  protected onBrowserFill(event: Event): void {
+    if (this.inputEl().nativeElement.value !== this.inputText()) this.onInput(event);
+  }
+
   /** @ignore Emit a query and open the panel. */
   private runSearch(event: Event, query: string): void {
     this.queryDirty = true;
@@ -647,7 +685,7 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
   protected onDropdownClick(event: MouseEvent): void {
     if (this.isDisabled() || this.readonly()) return;
     if (this.panelOpen()) {
-      this.close();
+      this.close(true);
       return;
     }
     // Mark the query as already handled *before* focusing: `focus()` fires a
@@ -664,7 +702,10 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
   /** @ignore */
   protected onInputFocus(event: FocusEvent): void {
     if (this.isDisabled()) return;
-    if (!this.queryDirty && this.completeOnFocus()) this.runSearch(event, this.inputText());
+    // Chrome's autofill sends a focus event to a field it fills without focusing it.
+    const focused = hasFocus(event.target as HTMLInputElement);
+    if (focused && !this.queryDirty && this.completeOnFocus())
+      this.runSearch(event, this.inputText());
     this.inputFocus.emit(event);
   }
 
@@ -686,11 +727,10 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
    * on no match the field is reset so the model never holds free text.
    */
   private validateForceSelection(event: Event): void {
+    this.pendingFill.set(null);
     const text = this.inputText().trim();
     if (!text) return;
-    const match = this.flatEntries().find(
-      (e) => !e.disabled && this.normalize(e.label) === this.normalize(text),
-    );
+    const match = this.entryLabelled(text);
     if (match) {
       this.selectEntry(match, event, false);
     } else if (this.multiple()) {
@@ -711,6 +751,7 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
 
   /** Clears the value. */
   clear(): void {
+    this.pendingFill.set(null);
     if (this.multiple()) {
       this.commit([]);
       this.selectionCache.set([]);
@@ -719,7 +760,7 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
     }
     this.inputText.set('');
     this.cleared.emit();
-    this.close(false);
+    this.close();
     this.focus();
   }
 
@@ -752,7 +793,7 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
         return;
       case 'ArrowUp':
         event.preventDefault();
-        if (event.altKey) this.close();
+        if (event.altKey) this.close(true);
         else if (this.panelOpen()) this.moveFocus(-1);
         else this.reopen();
         return;
@@ -775,10 +816,10 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
         if (!this.panelOpen()) return;
         event.preventDefault();
         event.stopPropagation();
-        this.close();
+        this.close(true);
         return;
       case 'Tab':
-        if (this.panelOpen()) this.close(false);
+        if (this.panelOpen()) this.close();
         return; // let the focus move on
       default:
         return;
@@ -823,20 +864,20 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
       // The query was just consumed: an open panel would show results for a
       // text the input no longer displays.
       this.inputText.set('');
-      if (closePanel) this.close();
+      if (closePanel) this.close(true);
       return;
     }
     this.commit(entry.value as AutocompleteValue<T>);
     this.inputText.set(entry.label);
     this.optionSelect.emit(entry.original as T);
-    if (closePanel) this.close();
+    if (closePanel) this.close(true);
   }
 
   /** @ignore */
   private selectFocused(event: Event): void {
     const row = this.visibleOptions()[this.focusedIndex()];
     if (row) this.selectEntry(row.entry, event);
-    else this.close();
+    else this.close(true);
   }
 
   /** @ignore Propagate a user-driven value change (view → form). */
@@ -1046,6 +1087,12 @@ export class UiAutocomplete<T = unknown> extends BaseFormField<AutocompleteValue
     return this.resolver.equals(a, b);
   }
 
+  /** @ignore Enabled suggestion whose label matches `text` (case/diacritics-insensitive). */
+  private entryLabelled(text: string): AcEntry | undefined {
+    const wanted = this.normalize(text.trim());
+    return this.flatEntries().find((e) => !e.disabled && this.normalize(e.label) === wanted);
+  }
+
   /** @ignore Case- and diacritics-insensitive comparison text. */
   private normalize(text: string): string {
     return text.toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
diff --git a/projects/ui-kit/forms/ui-autocomplete/ui-autocomplete.mdx b/projects/ui-kit/forms/ui-autocomplete/ui-autocomplete.mdx
index de08cb9e..dbec0e72 100644
--- a/projects/ui-kit/forms/ui-autocomplete/ui-autocomplete.mdx
+++ b/projects/ui-kit/forms/ui-autocomplete/ui-autocomplete.mdx
@@ -107,6 +107,11 @@ replié derrière la chip informative de repli.
 suggestion, l'input est effacé — la valeur portée dans le modèle est **toujours** l'une des
 suggestions.
 
+Une valeur que le navigateur écrit dans le champ sans que l'utilisateur y soit (saisie
+automatique) n'attend pas de blur : la suggestion qui porte ce libellé est retenue dès que
+`suggestions` la contient. Sans correspondance, le texte reste affiché et le modèle vide ; la
+sortie du champ appliquera la règle habituelle.
+
 <Canvas of={AutocompleteStories.ForceSelection} />
 
 ## Clear Icon
@@ -214,6 +219,15 @@ suggestion ou champ `optionValue`) ; le flux `completeMethod` → `suggestions`
 L'exemple [Invalid](#invalid) ci-dessus illustre le branchement `[formControl]` (réactif) avec
 validation `required`.
 
+Une valeur préremplie par le navigateur met à jour le modèle et émet `completeMethod` aussitôt,
+sans ouvrir le panneau sous un champ où l'utilisateur n'est pas ; `completeOnFocus` ignore de
+même l'évènement `focus` que Chrome envoie au champ qu'il remplit. Comportement commun aux
+champs : section « Saisie automatique du navigateur » de
+[`ui-input`](?path=/docs/components-ui-forms-ui-input--docs).
+
+`nativeInputElement()` donne accès à l'`<input>` natif, `close()` ferme le panneau sans
+déplacer le focus (`close(true)` le rend au champ).
+
 ```html
 <!-- Signal Forms -->
 <ui-autocomplete [formField]="country" [suggestions]="results()" (completeMethod)="search($event)" />
diff --git a/projects/ui-kit/forms/ui-datepicker/src/lib/ui-datepicker.spec.ts b/projects/ui-kit/forms/ui-datepicker/src/lib/ui-datepicker.spec.ts
index dce24c33..6bbd2461 100644
--- a/projects/ui-kit/forms/ui-datepicker/src/lib/ui-datepicker.spec.ts
+++ b/projects/ui-kit/forms/ui-datepicker/src/lib/ui-datepicker.spec.ts
@@ -211,13 +211,15 @@ async function keydown(
   return event;
 }
 
-/** Mirrors a single native keystroke: sets the raw value + caret, dispatches `input`, flushes CD. */
+/** Mirrors a single native keystroke: sets the raw value + caret, dispatches `input`, flushes CD.
+ *  A keystroke needs the focus: an `input` on a field without it is a browser fill. */
 async function typeInto(
   input: HTMLInputElement,
   value: string,
   caret: number,
   fixture: ComponentFixture<unknown>,
 ) {
+  if (document.activeElement !== input) input.focus();
   input.value = value;
   input.setSelectionRange(caret, caret);
   input.dispatchEvent(new Event('input', { bubbles: true }));
@@ -569,6 +571,18 @@ describe('UiDatepicker — keyboard entry masking (FSHSP-118)', () => {
       expect(panel()).toBeNull();
     });
 
+    it('ignores the focus event Chrome sends to a field its autofill fills', async () => {
+      const { fixture, input } = await setupHost(DatepickerShowOnFocusHost);
+      // Chrome's sequence: a keydown on the field it filled before, then a focus event on this
+      // one, which never takes the focus.
+      document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'a', bubbles: true }));
+      input.dispatchEvent(new FocusEvent('focus'));
+      fixture.detectChanges();
+      await fixture.whenStable();
+      expect(document.activeElement).not.toBe(input);
+      expect(panel()).toBeNull();
+    });
+
     it('does not re-open when closing hands the focus back to the field', async () => {
       const { fixture, input } = await setupHost(DatepickerShowOnFocusHost);
       await focusVia(input, 'keyboard', fixture);
@@ -631,3 +645,45 @@ describe('UiDatepicker — keyboard entry masking (FSHSP-118)', () => {
     });
   });
 });
+
+describe('UiDatepicker — browser fill', () => {
+  /** Writes `value` the way the browser autofills a field the user is not in. */
+  async function fill(input: HTMLInputElement, value: string, fixture: ComponentFixture<unknown>) {
+    input.value = value;
+    input.dispatchEvent(new Event('input', { bubbles: true }));
+    fixture.detectChanges();
+    await fixture.whenStable();
+  }
+
+  it('commits a date written without focus, no blur needed', async () => {
+    const { input, fixture, host } = await setup();
+    await fill(input, '08/07/2026', fixture);
+    expect(host.control.value).toEqual(new Date(2026, 6, 8));
+    expect(input.value).toBe('08/07/2026');
+    expect(panel()).toBeNull();
+    expect(document.activeElement).not.toBe(input);
+  });
+
+  it('commits a date revealed by a change alone', async () => {
+    const { input, fixture, host } = await setup();
+    input.value = '08/07/2026';
+    input.dispatchEvent(new Event('change', { bubbles: true }));
+    fixture.detectChanges();
+    await fixture.whenStable();
+    expect(host.control.value).toEqual(new Date(2026, 6, 8));
+  });
+
+  it('reverts a fill that is not a date, the text included', async () => {
+    const { input, fixture, host } = await setup(new Date(2026, 6, 8));
+    await fill(input, 'demain', fixture);
+    expect(host.control.value).toEqual(new Date(2026, 6, 8));
+    expect(input.value).toBe('08/07/2026');
+  });
+
+  it('reverts a fill over an empty field to an empty text', async () => {
+    const { input, fixture, host } = await setup();
+    await fill(input, 'demain', fixture);
+    expect(host.control.value).toBeNull();
+    expect(input.value).toBe('');
+  });
+});
diff --git a/projects/ui-kit/forms/ui-datepicker/src/lib/ui-datepicker.ts b/projects/ui-kit/forms/ui-datepicker/src/lib/ui-datepicker.ts
index fdbf3996..20dcfa5f 100644
--- a/projects/ui-kit/forms/ui-datepicker/src/lib/ui-datepicker.ts
+++ b/projects/ui-kit/forms/ui-datepicker/src/lib/ui-datepicker.ts
@@ -23,7 +23,7 @@ import { NG_VALUE_ACCESSOR } from '@angular/forms';
 import { OverlayModule } from '@angular/cdk/overlay';
 import { dropdownOverlayPositions } from '@4sh/ui-kit/forms';
 import { CdkTrapFocus, FocusMonitor } from '@angular/cdk/a11y';
-import { BaseFormField } from '@4sh/ui-kit/forms';
+import { BaseFormField, hasFocus } from '@4sh/ui-kit/forms';
 import {
   autoFormatSegments,
   buildMaskSlots,
@@ -943,8 +943,9 @@ export class UiDatepicker extends BaseFormField<DatepickerValue> {
       const sub = this.focusMonitor.monitor(el).subscribe((origin) => {
         // `null` = blur. `'program'` = not a user gesture. And `suppressFocusOpen` covers the
         // focus WE give back on close, which the monitor still attributes to whatever gesture
-        // triggered that close ('keyboard' for Escape, 'mouse' for a day click).
-        if (!origin || origin === 'program' || this.suppressFocusOpen) return;
+        // triggered that close ('keyboard' for Escape, 'mouse' for a day click). A focus event on
+        // a field without focus is the one Chrome sends along with its autofill.
+        if (!origin || origin === 'program' || this.suppressFocusOpen || !hasFocus(el)) return;
         if (this.showOnFocus()) this.openFrom('focus');
       });
       onCleanup(() => {
@@ -1165,6 +1166,15 @@ export class UiDatepicker extends BaseFormField<DatepickerValue> {
    */
   protected onTriggerInput(value: string): void {
     if (this.triggerReadonly()) return;
+    const el = this.triggerInput()?.nativeInputElement();
+    // Written by the browser without focus: no blur/Enter will follow to commit it.
+    if (el && !hasFocus(el)) {
+      this.typedValue.set(value);
+      this.commitTyped();
+      // A reverted fill renders the same text as before it, which the binding would skip.
+      el.value = this.displayValue();
+      return;
+    }
     const slots = this.typingSlots();
     if (!slots) {
       this.typedValue.set(value);
@@ -1181,7 +1191,6 @@ export class UiDatepicker extends BaseFormField<DatepickerValue> {
       if (this.panelOpen()) this.previewTyped();
       return;
     }
-    const el = this.triggerInput()?.nativeInputElement();
     const caret = el?.selectionStart ?? value.length;
     // Number of data characters located BEFORE the caret (stable anchor, same trick as ui-input-mask).
     const dataBeforeCaret = extractMaskData(value.slice(0, caret)).length;
diff --git a/projects/ui-kit/forms/ui-datepicker/ui-datepicker.mdx b/projects/ui-kit/forms/ui-datepicker/ui-datepicker.mdx
index 95d69157..77ec73c8 100644
--- a/projects/ui-kit/forms/ui-datepicker/ui-datepicker.mdx
+++ b/projects/ui-kit/forms/ui-datepicker/ui-datepicker.mdx
@@ -281,11 +281,17 @@ grille gère ce cas-là pour l'instant.
 <Canvas of={DatepickerStories.RangeTypedInput} />
 <Canvas of={DatepickerStories.MultipleTypedInput} />
 
+Une date préremplie par le navigateur (`autocomplete="bday"`) dans le champ sans focus est
+**validée aussitôt**, sans attendre de blur ni d'Entrée : le modèle est mis à jour et `dateSelect`
+émis. Un texte qui n'est pas une date fait revenir le champ à la valeur précédente. Comportement
+commun aux champs : section « Saisie automatique du navigateur » de [`ui-input`](?path=/docs/components-ui-forms-ui-input--docs).
+
 ## Ouverture au focus (`showOnFocus`)
 
 `showOnFocus` ouvre le panneau **dès que le champ prend le focus**, au pointeur comme au clavier,
 jamais sur un focus programmatique (`autofocus`, un `focus()` appelé par l'application : le
-calendrier ne surgit pas sans geste de l'utilisateur). C'est l'affordance attendue là où le champ
+calendrier ne surgit pas sans geste de l'utilisateur), ni sur l'évènement `focus` que Chrome
+envoie à chaque champ rempli par sa saisie automatique sans lui donner le focus. C'est l'affordance attendue là où le champ
 sert surtout à choisir une date plutôt qu'à la taper.
 
 <Canvas of={DatepickerStories.ShowOnFocus} />
diff --git a/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.browser-fill.spec.ts b/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.browser-fill.spec.ts
new file mode 100644
index 00000000..a1da5789
--- /dev/null
+++ b/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.browser-fill.spec.ts
@@ -0,0 +1,74 @@
+/**
+ * TestBed spec for a value the browser writes into `ui-input-mask` without a
+ * keystroke: masked into the model, without pulling the focus in.
+ */
+import { Component } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { describe, expect, it, vi } from 'vitest';
+import { UiInputMask } from './ui-input-mask';
+
+@Component({
+  imports: [ReactiveFormsModule, UiInputMask],
+  template: `<ui-input-mask
+    label="Téléphone"
+    mask="99 99 99 99 99"
+    [formControl]="control"
+    (valueChange)="emitted.push($event)"
+  />`,
+})
+class FillHost {
+  readonly control = new FormControl('');
+  readonly emitted: string[] = [];
+}
+
+async function setup() {
+  await TestBed.configureTestingModule({ imports: [FillHost] }).compileComponents();
+  const fixture: ComponentFixture<FillHost> = TestBed.createComponent(FillHost);
+  fixture.detectChanges();
+  await fixture.whenStable();
+  const input = fixture.nativeElement.querySelector('input') as HTMLInputElement;
+  const fire = async (type: string, animationName?: string) => {
+    const event = new Event(type, { bubbles: true });
+    if (animationName) Object.defineProperty(event, 'animationName', { value: animationName });
+    input.dispatchEvent(event);
+    fixture.detectChanges();
+    await fixture.whenStable();
+  };
+  return { host: fixture.componentInstance, input, fire };
+}
+
+describe('ui-input-mask — browser fill', () => {
+  it('masks a value written without focus, leaving the caret alone', async () => {
+    const { host, input, fire } = await setup();
+    const select = vi.spyOn(input, 'setSelectionRange');
+    input.value = '0612345678';
+    await fire('input');
+    expect(host.control.value).toBe('06 12 34 56 78');
+    expect(input.value).toBe('06 12 34 56 78');
+    expect(select).not.toHaveBeenCalled();
+    expect(document.activeElement).not.toBe(input);
+  });
+
+  it('syncs a value revealed by a change alone, once', async () => {
+    const { host, input, fire } = await setup();
+    input.value = '0612345678';
+    await fire('change');
+    await fire('animationstart', 'ui-browser-fill');
+    expect(host.emitted).toEqual(['06 12 34 56 78']);
+  });
+
+  it('still places the caret while typing', async () => {
+    const { host, input, fire } = await setup();
+    input.focus();
+    const select = vi.spyOn(input, 'setSelectionRange');
+    input.value = '061';
+    input.setSelectionRange(3, 3);
+    await fire('input');
+    expect(input.value).toBe('06 1_ __ __ __');
+    expect(select).toHaveBeenLastCalledWith(4, 4);
+    await fire('change');
+    input.blur();
+    expect(host.emitted).toEqual(['06 1']);
+  });
+});
diff --git a/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.html b/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.html
index c80e7dc8..4c82bbef 100644
--- a/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.html
+++ b/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.html
@@ -26,6 +26,7 @@
 
   <input
     #inputEl
+    uiBrowserFill
     class="ui-input-mask-native"
     [class._small]="size() === 'small'"
     type="text"
@@ -42,6 +43,7 @@
     [attr.aria-describedby]="displayMessage() ? messageId() : null"
     [attr.aria-invalid]="effectiveLevel() === 'error' ? 'true' : null"
     (input)="onInput()"
+    (browserFill)="onBrowserFill()"
     (blur)="onBlur($event)"
   />
 </ui-field>
diff --git a/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.scss b/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.scss
index b7f593bf..1115eec3 100644
--- a/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.scss
+++ b/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.scss
@@ -7,6 +7,8 @@
 
 $font-size-small: var(--ui-input-mask-font-size-small, var(--size-typography-text-md)); /// Taille de police du contrôle, variante `small`.
 
+@include utils.browser-fill;
+
 .ui-input-mask {
   &-native {
     @include utils.field-native-input;
diff --git a/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.ts b/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.ts
index 679807ee..53478d7d 100644
--- a/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.ts
+++ b/projects/ui-kit/forms/ui-input-mask/src/lib/ui-input-mask.ts
@@ -10,7 +10,7 @@ import {
   viewChild,
 } from '@angular/core';
 import { NG_VALUE_ACCESSOR } from '@angular/forms';
-import { BaseFormField } from '@4sh/ui-kit/forms';
+import { BaseFormField, hasFocus, UiBrowserFill } from '@4sh/ui-kit/forms';
 import { UiField } from '@4sh/ui-kit/forms/ui-field';
 import { UiIcon, UiIconSize } from '@4sh/ui-kit/base/ui-icon';
 import {
@@ -35,7 +35,7 @@ import {
  */
 @Component({
   selector: 'ui-input-mask',
-  imports: [UiField, UiIcon],
+  imports: [UiField, UiIcon, UiBrowserFill],
   templateUrl: './ui-input-mask.html',
   styleUrl: './ui-input-mask.scss',
   providers: [
@@ -124,10 +124,17 @@ export class UiInputMask extends BaseFormField<string> {
     // Apply synchronously + restore the caret after the Nth typed character
     // (auto-inserted literals skipped). The [value] binding becomes a no-op.
     el.value = display;
+    // A fill without focus has no caret to restore.
+    if (!hasFocus(el)) return;
     const pos = caretForMask(built.tokenIndices, dataBeforeCaret, display.length);
     el.setSelectionRange(pos, pos);
   }
 
+  /** @ignore Value written by the browser without an `input` event. */
+  protected onBrowserFill(): void {
+    if (this.inputEl().nativeElement.value !== this.text()) this.onInput();
+  }
+
   /** @ignore */
   protected onBlur(event: FocusEvent): void {
     this.emitTouch();
diff --git a/projects/ui-kit/forms/ui-input-mask/ui-input-mask.mdx b/projects/ui-kit/forms/ui-input-mask/ui-input-mask.mdx
index 549047ea..5cdf9520 100644
--- a/projects/ui-kit/forms/ui-input-mask/ui-input-mask.mdx
+++ b/projects/ui-kit/forms/ui-input-mask/ui-input-mask.mdx
@@ -117,6 +117,10 @@ via l'interop CVA native, ainsi qu'aux formulaires template-driven (`[(ngModel)]
 
 <Canvas of={MaskStories.SignalForms} />
 
+Une valeur préremplie par le navigateur (téléphone, code postal) passe par le masque et met à
+jour le modèle sans clic dans le champ ; écrite sans focus, elle ne place pas de curseur.
+Comportement commun aux champs : section « Saisie automatique du navigateur » de [`ui-input`](?path=/docs/components-ui-forms-ui-input--docs).
+
 ## Accessibilité & notes
 
 <table className="doc-table">
diff --git a/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.browser-fill.spec.ts b/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.browser-fill.spec.ts
new file mode 100644
index 00000000..09128155
--- /dev/null
+++ b/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.browser-fill.spec.ts
@@ -0,0 +1,84 @@
+/**
+ * TestBed spec for a value the browser writes into `ui-input-number` without a
+ * keystroke: parsed into the model and formatted at once, since no blur follows.
+ */
+import { Component } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { describe, expect, it } from 'vitest';
+import { UiInputNumber } from './ui-input-number';
+
+@Component({
+  imports: [ReactiveFormsModule, UiInputNumber],
+  template: `<ui-input-number
+    label="Surface"
+    locale="en-US"
+    [formControl]="control"
+    (valueChange)="emitted.push($event)"
+  />`,
+})
+class FillHost {
+  readonly control = new FormControl<number | null>(null);
+  readonly emitted: (number | null)[] = [];
+}
+
+async function setup() {
+  await TestBed.configureTestingModule({ imports: [FillHost] }).compileComponents();
+  const fixture: ComponentFixture<FillHost> = TestBed.createComponent(FillHost);
+  fixture.detectChanges();
+  await fixture.whenStable();
+  const input = fixture.nativeElement.querySelector('input') as HTMLInputElement;
+  const settle = async () => {
+    fixture.detectChanges();
+    await fixture.whenStable();
+  };
+  const fire = async (type: string, animationName?: string) => {
+    const event = new Event(type, { bubbles: true });
+    if (animationName) Object.defineProperty(event, 'animationName', { value: animationName });
+    input.dispatchEvent(event);
+    await settle();
+  };
+  return { host: fixture.componentInstance, input, settle, fire };
+}
+
+describe('ui-input-number — browser fill', () => {
+  it('parses and formats a value written without focus', async () => {
+    const { host, input, fire } = await setup();
+    input.value = '1234.5';
+    await fire('input');
+    expect(host.control.value).toBe(1234.5);
+    expect(input.value).toBe('1,234.5');
+    expect(host.emitted).toEqual([1234.5]);
+  });
+
+  it('syncs a value revealed by the autofill animation alone, once', async () => {
+    const { host, input, fire } = await setup();
+    input.value = '42';
+    await fire('animationstart', 'ui-browser-fill');
+    await fire('change');
+    expect(host.control.value).toBe(42);
+    expect(host.emitted).toEqual([42]);
+  });
+
+  it('clears the text of a fill that is not a number', async () => {
+    const { host, input, fire } = await setup();
+    input.value = 'abc';
+    await fire('change');
+    expect(host.control.value).toBeNull();
+    expect(input.value).toBe('');
+  });
+
+  it('leaves the typed text unformatted until blur', async () => {
+    const { host, input, settle, fire } = await setup();
+    input.focus();
+    input.value = '1234';
+    await fire('input');
+    expect(input.value).toBe('1234');
+    expect(host.control.value).toBe(1234);
+    await fire('change');
+    input.blur();
+    await settle();
+    expect(input.value).toBe('1,234');
+    expect(host.emitted).toEqual([1234, 1234]);
+  });
+});
diff --git a/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.html b/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.html
index 60cf7030..8140f937 100644
--- a/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.html
+++ b/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.html
@@ -15,6 +15,7 @@
 >
   <input
     #inputEl
+    uiBrowserFill
     class="ui-input-number-native"
     [class._small]="size() === 'small'"
     type="text"
@@ -36,6 +37,7 @@
     [attr.aria-valuemin]="ariaValueMin()"
     [attr.aria-valuemax]="ariaValueMax()"
     (input)="onInput()"
+    (browserFill)="onBrowserFill()"
     (keydown)="onKeydown($event)"
     (focus)="onFocus($event)"
     (blur)="onBlur($event)"
diff --git a/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.scss b/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.scss
index 99d1ae58..00dcf65d 100644
--- a/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.scss
+++ b/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.scss
@@ -9,6 +9,8 @@ $spinner-width: var(--ui-input-number-spinner-width, #{utils.rem-calc(30)});
 $unit-font-size: var(--ui-input-number-unit-font-size, var(--size-typography-text-default)); /// Taille du texte de l'unité.
 $font-size-small: var(--ui-input-number-font-size-small, var(--size-typography-text-md));    /// Taille du texte (saisie et unité) en variante `small`.
 
+@include utils.browser-fill;
+
 .ui-input-number {
   &-native {
     @include utils.field-native-input;
diff --git a/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.ts b/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.ts
index b4b8e3ee..c0ed9738 100644
--- a/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.ts
+++ b/projects/ui-kit/forms/ui-input-number/src/lib/ui-input-number.ts
@@ -11,7 +11,7 @@ import {
   viewChild,
 } from '@angular/core';
 import { NG_VALUE_ACCESSOR } from '@angular/forms';
-import { BaseFormField } from '@4sh/ui-kit/forms';
+import { BaseFormField, hasFocus, UiBrowserFill } from '@4sh/ui-kit/forms';
 import { UiField } from '@4sh/ui-kit/forms/ui-field';
 import { UiIcon } from '@4sh/ui-kit/base/ui-icon';
 
@@ -29,7 +29,7 @@ import { UiIcon } from '@4sh/ui-kit/base/ui-icon';
  */
 @Component({
   selector: 'ui-input-number',
-  imports: [UiField, UiIcon],
+  imports: [UiField, UiIcon, UiBrowserFill],
   templateUrl: './ui-input-number.html',
   styleUrl: './ui-input-number.scss',
   providers: [
@@ -134,11 +134,21 @@ export class UiInputNumber extends BaseFormField<number | null> {
     this.inputFocus.emit(event);
   }
 
-  /** @ignore Input: parse without reformatting the text (caret preserved). */
+  /** @ignore Input: parse without reformatting the text (caret preserved). A value written by
+   *  the browser without focus is reformatted at once: no blur will follow to do it. */
   protected onInput(): void {
-    const raw = this.inputEl().nativeElement.value;
+    const el = this.inputEl().nativeElement;
+    const raw = el.value;
+    const filled = !hasFocus(el);
     this.text.set(raw);
-    this.commit(this.parse(raw), { reformat: false });
+    this.commit(this.parse(raw), { reformat: filled });
+    // The binding skips a reformatted text equal to the one rendered before the fill.
+    if (filled) el.value = this.text();
+  }
+
+  /** @ignore Value written by the browser without an `input` event. */
+  protected onBrowserFill(): void {
+    if (this.inputEl().nativeElement.value !== this.text()) this.onInput();
   }
 
   /** @ignore Blur: clamp + rich reformatting. */
@@ -171,9 +181,7 @@ export class UiInputNumber extends BaseFormField<number | null> {
 
   /** @ignore Does the input currently have focus? */
   private isFocused(): boolean {
-    return (
-      typeof document !== 'undefined' && document.activeElement === this.inputEl().nativeElement
-    );
+    return hasFocus(this.inputEl().nativeElement);
   }
 
   /** @ignore Update model + emit; reformat the text when requested. */
diff --git a/projects/ui-kit/forms/ui-input-number/ui-input-number.mdx b/projects/ui-kit/forms/ui-input-number/ui-input-number.mdx
index 5bfdc8e5..fa6c9539 100644
--- a/projects/ui-kit/forms/ui-input-number/ui-input-number.mdx
+++ b/projects/ui-kit/forms/ui-input-number/ui-input-number.mdx
@@ -73,6 +73,11 @@ Angular 22) via l'interop CVA native, ainsi qu'aux formulaires template-driven
 <ui-input-number [formControl]="ageCtrl" label="Âge" [min]="0" [max]="120" [allowDecimals]="false" />
 ```
 
+Une valeur préremplie par le navigateur dans le champ sans focus est lue et **formatée
+aussitôt**, puisqu'aucune sortie du champ ne viendra le faire ; elle n'est pas ramenée dans
+`[min, max]`, ce que seule la sortie du champ fait. Comportement commun aux champs : section
+« Saisie automatique du navigateur » de [`ui-input`](?path=/docs/components-ui-forms-ui-input--docs).
+
 ## Accessibilité
 
 <table className="doc-table">
diff --git a/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.browser-fill.spec.ts b/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.browser-fill.spec.ts
new file mode 100644
index 00000000..f8468cc5
--- /dev/null
+++ b/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.browser-fill.spec.ts
@@ -0,0 +1,137 @@
+/**
+ * TestBed spec for a code the browser or the system writes into `ui-input-otp`
+ * (`autocomplete="one-time-code"`): spread over the cells into the model,
+ * moving the focus only when the user is in the group.
+ */
+import { Component, ErrorHandler } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { describe, expect, it, vi } from 'vitest';
+import { UiBrowserFill } from '@4sh/ui-kit/forms';
+import { UiInputOtp } from './ui-input-otp';
+
+@Component({
+  imports: [ReactiveFormsModule, UiInputOtp],
+  template: `<ui-input-otp
+    ariaLabel="Code"
+    [length]="4"
+    integerOnly
+    [formControl]="control"
+    (valueChange)="emitted.push($event)"
+    (completed)="completed.push($event)"
+  />`,
+})
+class FillHost {
+  readonly control = new FormControl('');
+  readonly emitted: string[] = [];
+  readonly completed: string[] = [];
+}
+
+@Component({
+  imports: [ReactiveFormsModule, UiInputOtp, UiBrowserFill],
+  template: `<ui-input-otp ariaLabel="Code" [length]="4" [formControl]="control">
+    <ng-template #input let-value let-events="events" let-tabindex="tabindex">
+      <input
+        uiBrowserFill
+        class="custom-cell"
+        [value]="value"
+        [attr.tabindex]="tabindex"
+        (input)="events.input($event)"
+        (browserFill)="events.browserFill($event)"
+      />
+    </ng-template>
+  </ui-input-otp>`,
+})
+class CustomCellHost {
+  readonly control = new FormControl('');
+}
+
+async function setup() {
+  const errors: unknown[] = [];
+  await TestBed.configureTestingModule({
+    imports: [FillHost],
+    providers: [
+      { provide: ErrorHandler, useValue: { handleError: (e: unknown) => errors.push(e) } },
+    ],
+  }).compileComponents();
+  const fixture: ComponentFixture<FillHost> = TestBed.createComponent(FillHost);
+  fixture.detectChanges();
+  await fixture.whenStable();
+  const cells = Array.from(fixture.nativeElement.querySelectorAll('input')) as HTMLInputElement[];
+  const fire = async (cell: HTMLInputElement, type: string, animationName?: string) => {
+    const event = new Event(type, { bubbles: true });
+    if (animationName) Object.defineProperty(event, 'animationName', { value: animationName });
+    cell.dispatchEvent(event);
+    fixture.detectChanges();
+    await fixture.whenStable();
+  };
+  return { host: fixture.componentInstance, cells, errors, fire };
+}
+
+describe('ui-input-otp — browser fill', () => {
+  it('spreads a code written without focus, leaving the focus where it is', async () => {
+    const { host, cells, fire } = await setup();
+    cells[0].value = '1234';
+    await fire(cells[0], 'input');
+    expect(host.control.value).toBe('1234');
+    expect(host.completed).toEqual(['1234']);
+    expect(cells.map((c) => c.value)).toEqual(['1', '2', '3', '4']);
+    expect(cells).not.toContain(document.activeElement);
+  });
+
+  it('syncs a code revealed by a change alone, once', async () => {
+    const { host, cells, fire } = await setup();
+    cells[0].value = '1234';
+    await fire(cells[0], 'change');
+    await fire(cells[0], 'animationstart', 'ui-browser-fill');
+    expect(host.emitted).toEqual(['1234']);
+  });
+
+  it('spreads a code filled into the focused cell and moves to the last one', async () => {
+    const { host, cells, fire } = await setup();
+    cells[0].focus();
+    cells[0].value = '1234';
+    await fire(cells[0], 'input');
+    expect(host.control.value).toBe('1234');
+    expect(document.activeElement).toBe(cells[3]);
+  });
+
+  it('stays out of the way of the events Chrome sends with its autofill', async () => {
+    const { host, cells, errors, fire } = await setup();
+    const select = vi.spyOn(cells[0], 'select');
+    // A focus event without the focus, then a keydown that is a bare `Event`.
+    cells[0].dispatchEvent(new FocusEvent('focus'));
+    await fire(cells[0], 'keydown');
+    cells[0].value = '1';
+    await fire(cells[0], 'input');
+    expect(host.control.value).toBe('1');
+    expect(select).not.toHaveBeenCalled();
+    expect(errors).toEqual([]);
+    expect(cells).not.toContain(document.activeElement);
+  });
+
+  it('still moves to the next cell on a keystroke', async () => {
+    const { host, cells, fire } = await setup();
+    cells[0].focus();
+    cells[0].value = '7';
+    await fire(cells[0], 'input');
+    expect(document.activeElement).toBe(cells[1]);
+    await fire(cells[0], 'change');
+    expect(host.emitted).toEqual(['7']);
+  });
+});
+
+describe('ui-input-otp — browser fill in a custom cell', () => {
+  it('syncs a code written into a cell wired to events.browserFill', async () => {
+    await TestBed.configureTestingModule({ imports: [CustomCellHost] }).compileComponents();
+    const fixture = TestBed.createComponent(CustomCellHost);
+    fixture.detectChanges();
+    await fixture.whenStable();
+    const cell = fixture.nativeElement.querySelector('.custom-cell') as HTMLInputElement;
+    cell.value = '1234';
+    cell.dispatchEvent(new Event('change', { bubbles: true }));
+    fixture.detectChanges();
+    await fixture.whenStable();
+    expect(fixture.componentInstance.control.value).toBe('1234');
+  });
+});
diff --git a/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.html b/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.html
index b11f7b89..f08c246f 100644
--- a/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.html
+++ b/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.html
@@ -12,6 +12,7 @@
     />
   } @else {
     <input
+      uiBrowserFill
       class="ui-input-otp-cell"
       [id]="cell.id"
       [type]="inputType()"
@@ -26,6 +27,7 @@
       [attr.aria-label]="(ariaLabel() || charAriaLabel()) + ' ' + (cell.index + 1)"
       [attr.aria-invalid]="isInvalid() ? 'true' : null"
       (input)="onInput($event, cell.index)"
+      (browserFill)="onBrowserFill($event, cell.index)"
       (keydown)="onKeydown($event, cell.index)"
       (focus)="onFocus($event, cell.index)"
       (paste)="onPaste($event, cell.index)"
diff --git a/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.scss b/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.scss
index 6224f59e..4a78a755 100644
--- a/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.scss
+++ b/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.scss
@@ -57,6 +57,8 @@ $gap: var(--ui-input-otp-gap, var(--units-sm));
   }
 }
 
+@include utils.browser-fill;
+
 // --- Cell -------------------------------------------------------------
 .ui-input-otp-cell {
   --_stroke: var(--ui-input-otp-cell-stroke, var(--form-high-stroke-default));            /// Couleur de bordure d'une case.
diff --git a/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.ts b/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.ts
index 8e283c07..13b753cd 100644
--- a/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.ts
+++ b/projects/ui-kit/forms/ui-input-otp/src/lib/ui-input-otp.ts
@@ -17,7 +17,7 @@ import {
 } from '@angular/core';
 import { NgTemplateOutlet } from '@angular/common';
 import { NG_VALUE_ACCESSOR } from '@angular/forms';
-import { BaseFieldControl } from '@4sh/ui-kit/forms';
+import { BaseFieldControl, hasFocus, UiBrowserFill } from '@4sh/ui-kit/forms';
 import { warnMissingAccessibleName } from '@4sh/ui-kit/forms';
 
 /** Size of the OTP cells. `default` is the base. */
@@ -35,6 +35,8 @@ export interface InputOtpCellEvents {
   blur: (event: FocusEvent) => void;
   /** Wire on `(paste)`. */
   paste: (event: ClipboardEvent) => void;
+  /** Wire on `(browserFill)` of a cell marked `uiBrowserFill`. */
+  browserFill: (event: Event) => void;
 }
 
 /** Context handed to the `#input` template (one per cell). */
@@ -78,7 +80,7 @@ export interface InputOtpCellContext {
  */
 @Component({
   selector: 'ui-input-otp',
-  imports: [NgTemplateOutlet],
+  imports: [NgTemplateOutlet, UiBrowserFill],
   templateUrl: './ui-input-otp.html',
   styleUrl: './ui-input-otp.scss',
   providers: [
@@ -199,6 +201,7 @@ export class UiInputOtp extends BaseFieldControl<string> {
         /* touched is emitted on group focusout */
       },
       paste: (event: ClipboardEvent) => this.onPaste(event, index),
+      browserFill: (event: Event) => this.onBrowserFill(event, index),
     };
   }
 
@@ -207,10 +210,13 @@ export class UiInputOtp extends BaseFieldControl<string> {
     if (this.readonly()) return;
     const target = event.target as HTMLInputElement;
     const raw = this.sanitize(target.value);
+    // A value written by the browser into a cell without focus must not pull the focus in.
+    const typed = hasFocus(target);
 
     // Multi-char (autofill / paste into a cell) → distribute across cells.
     if (raw.length > 1) {
-      this.setFromIndex(index, raw);
+      target.value = raw.charAt(0);
+      this.setFromIndex(index, raw, typed);
       return;
     }
 
@@ -218,14 +224,24 @@ export class UiInputOtp extends BaseFieldControl<string> {
     tokens[index] = raw;
     target.value = raw; // reflect the sanitised value
     this.commit(tokens);
+    if (!typed) return;
 
     const inputType = (event as InputEvent).inputType;
     if (raw) this.focusCell(index + 1);
     else if (inputType === 'deleteContentBackward') this.focusCell(index - 1);
   }
 
+  /** @ignore Value written by the browser into a cell without an `input` event. */
+  protected onBrowserFill(event: Event, index: number): void {
+    if ((event.target as HTMLInputElement).value !== this.cellValue(index)) {
+      this.onInput(event, index);
+    }
+  }
+
   /** @ignore Keyboard navigation + input guards. */
   protected onKeydown(event: KeyboardEvent, index: number): void {
+    // Chrome's autofill dispatches a bare `Event`, without `key`.
+    if (!(event instanceof KeyboardEvent)) return;
     if (event.altKey || event.ctrlKey || event.metaKey) return;
     const target = event.target as HTMLInputElement;
 
@@ -270,8 +286,12 @@ export class UiInputOtp extends BaseFieldControl<string> {
 
   /** @ignore Select the cell content on focus + track the roving index. */
   protected onFocus(event: FocusEvent, index: number): void {
+    const cell = event.target as HTMLInputElement;
+    // Chrome's autofill sends a focus event to a cell it fills without focusing it,
+    // and `select()` would pull the focus in.
+    if (!hasFocus(cell)) return;
     this.focusedIndex.set(index);
-    (event.target as HTMLInputElement).select?.();
+    cell.select?.();
   }
 
   /** @ignore Distribute a pasted code across the cells from `index`. */
@@ -288,8 +308,8 @@ export class UiInputOtp extends BaseFieldControl<string> {
     if (!next || !this.host.nativeElement.contains(next)) this.emitTouch();
   }
 
-  /** @ignore Write `chars` into the cells starting at `from`, then commit + focus. */
-  private setFromIndex(from: number, chars: string): void {
+  /** @ignore Write `chars` into the cells starting at `from`, then commit (+ focus). */
+  private setFromIndex(from: number, chars: string, moveFocus = true): void {
     const tokens = [...this.tokens()];
     const max = this.length();
     let i = from;
@@ -298,7 +318,7 @@ export class UiInputOtp extends BaseFieldControl<string> {
       tokens[i++] = ch;
     }
     this.commit(tokens);
-    this.focusCell(Math.min(i, max - 1));
+    if (moveFocus) this.focusCell(Math.min(i, max - 1));
   }
 
   /** @ignore Persist the tokens, emit the joined value (+ `completed` when full). */
diff --git a/projects/ui-kit/forms/ui-input-otp/ui-input-otp.mdx b/projects/ui-kit/forms/ui-input-otp/ui-input-otp.mdx
index 8df7140b..88d138d8 100644
--- a/projects/ui-kit/forms/ui-input-otp/ui-input-otp.mdx
+++ b/projects/ui-kit/forms/ui-input-otp/ui-input-otp.mdx
@@ -77,6 +77,10 @@ Le template `#input` **remplace la cellule par défaut** par votre propre UI. Il
 les gestionnaires à brancher (`input`/`keydown`/`focus`/`blur`/`paste`) pour conserver toute la
 mécanique (navigation clavier, avance auto, collage réparti).
 
+Pour qu'une case personnalisée suive aussi la saisie automatique du navigateur, y poser la
+directive `uiBrowserFill` (de `@4sh/ui-kit/forms`), relier `(browserFill)="events.browserFill($event)"`
+et inclure le mixin `utils.browser-fill` dans la feuille du composant qui porte le template.
+
 <Canvas of={InputOtpStories.Template} />
 
 ```html
@@ -183,6 +187,11 @@ via l'interop CVA native, ainsi qu'en `[(ngModel)]` et avec les **Reactive Forms
 <ui-input-otp [formControl]="codeCtrl" ariaLabel="Code" />
 ```
 
+Les cases portent `autocomplete="one-time-code"` : un code proposé par le système (SMS) est
+réparti dans les cases et met à jour le modèle. Écrit dans une case sans focus, il ne déplace
+pas le focus. Comportement commun aux champs : section « Saisie automatique du navigateur » de
+[`ui-input`](?path=/docs/components-ui-forms-ui-input--docs).
+
 ## Theming
 
 Les dimensions des cellules sont pilotées par une map locale `$sizes` ; les constantes
diff --git a/projects/ui-kit/forms/ui-input/src/lib/ui-input.browser-fill.spec.ts b/projects/ui-kit/forms/ui-input/src/lib/ui-input.browser-fill.spec.ts
new file mode 100644
index 00000000..2ba23091
--- /dev/null
+++ b/projects/ui-kit/forms/ui-input/src/lib/ui-input.browser-fill.spec.ts
@@ -0,0 +1,128 @@
+/**
+ * TestBed spec for a value the browser writes into `ui-input` without a
+ * keystroke (autofill): the model, `valueChange` and the CVA must follow,
+ * exactly once, while typing keeps emitting once per `input`.
+ */
+import { Component } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { describe, expect, it } from 'vitest';
+import { UiInput } from './ui-input';
+
+@Component({
+  imports: [ReactiveFormsModule, UiInput],
+  template: `<ui-input
+    label="Code postal"
+    [formControl]="control"
+    (valueChange)="emitted.push($event)"
+  />`,
+})
+class FillHost {
+  readonly control = new FormControl('');
+  readonly emitted: string[] = [];
+}
+
+async function setup() {
+  await TestBed.configureTestingModule({ imports: [FillHost] }).compileComponents();
+  const fixture: ComponentFixture<FillHost> = TestBed.createComponent(FillHost);
+  fixture.detectChanges();
+  await fixture.whenStable();
+  const host = fixture.componentInstance;
+  const changes: (string | null)[] = [];
+  host.control.valueChanges.subscribe((value) => changes.push(value));
+  const input = fixture.nativeElement.querySelector('input') as HTMLInputElement;
+  const settle = async () => {
+    fixture.detectChanges();
+    await fixture.whenStable();
+  };
+  const fire = async (type: string, init: Record<string, unknown> = {}) => {
+    const event = new Event(type, { bubbles: true });
+    for (const [key, value] of Object.entries(init)) Object.defineProperty(event, key, { value });
+    input.dispatchEvent(event);
+    await settle();
+  };
+  const autofill = () => fire('animationstart', { animationName: 'ui-browser-fill' });
+  return { host, input, changes, settle, fire, autofill };
+}
+
+describe('ui-input — browser fill', () => {
+  it('syncs a value revealed by the autofill animation alone', async () => {
+    const { host, input, changes, autofill } = await setup();
+    input.value = '75001';
+    await autofill();
+    expect(host.control.value).toBe('75001');
+    expect(host.emitted).toEqual(['75001']);
+    expect(changes).toEqual(['75001']);
+  });
+
+  it('syncs a value revealed by a change alone', async () => {
+    const { host, input, fire } = await setup();
+    input.value = '75001';
+    await fire('change');
+    expect(host.control.value).toBe('75001');
+    expect(host.emitted).toEqual(['75001']);
+  });
+
+  it('emits once for a fill reported through input, change and animation', async () => {
+    const { host, input, changes, fire, autofill } = await setup();
+    input.value = '75001';
+    await fire('input');
+    await fire('change');
+    await autofill();
+    expect(host.emitted).toEqual(['75001']);
+    expect(changes).toEqual(['75001']);
+  });
+
+  it('ignores an autofill animation over a value it cannot read yet', async () => {
+    const { host, autofill } = await setup();
+    await autofill();
+    expect(host.emitted).toEqual([]);
+  });
+
+  it('keeps emitting once per keystroke, none on the closing change', async () => {
+    const { host, input, changes, fire } = await setup();
+    input.focus();
+    for (const value of ['7', '75', '750']) {
+      input.value = value;
+      await fire('input');
+    }
+    await fire('change');
+    input.blur();
+    expect(host.emitted).toEqual(['7', '75', '750']);
+    expect(changes).toEqual(['7', '75', '750']);
+  });
+
+  it('emits a paste once', async () => {
+    const { host, input, fire } = await setup();
+    input.focus();
+    input.value = '75001';
+    await fire('input', { inputType: 'insertFromPaste' });
+    await fire('change');
+    input.blur();
+    expect(host.emitted).toEqual(['75001']);
+  });
+
+  it('syncs a fill repeating a text typed before the form reset it', async () => {
+    const { host, input, settle, fire, autofill } = await setup();
+    input.focus();
+    input.value = '75001';
+    await fire('input');
+    host.control.setValue('');
+    await settle();
+    input.blur();
+    input.value = '75001';
+    await autofill();
+    expect(host.control.value).toBe('75001');
+    expect(host.emitted).toEqual(['75001', '75001']);
+  });
+
+  it('syncs a fill over a value the form wrote', async () => {
+    const { host, input, settle, autofill } = await setup();
+    host.control.setValue('13001');
+    await settle();
+    expect(input.value).toBe('13001');
+    input.value = '75001';
+    await autofill();
+    expect(host.control.value).toBe('75001');
+  });
+});
diff --git a/projects/ui-kit/forms/ui-input/src/lib/ui-input.html b/projects/ui-kit/forms/ui-input/src/lib/ui-input.html
index 0b377223..8e0ef5b9 100644
--- a/projects/ui-kit/forms/ui-input/src/lib/ui-input.html
+++ b/projects/ui-kit/forms/ui-input/src/lib/ui-input.html
@@ -30,6 +30,7 @@
 
   <input
     #inputEl
+    uiBrowserFill
     class="ui-input-native"
     [class._small]="size() === 'small'"
     [type]="type()"
@@ -52,6 +53,7 @@
     [attr.aria-describedby]="resolvedAriaDescribedBy()"
     [attr.aria-invalid]="effectiveLevel() === 'error' ? 'true' : null"
     (input)="onInput()"
+    (browserFill)="onBrowserFill()"
     (focus)="inputFocus.emit($event)"
     (blur)="onBlur($event)"
   />
diff --git a/projects/ui-kit/forms/ui-input/src/lib/ui-input.scss b/projects/ui-kit/forms/ui-input/src/lib/ui-input.scss
index 79b7329d..f1cfdd1b 100644
--- a/projects/ui-kit/forms/ui-input/src/lib/ui-input.scss
+++ b/projects/ui-kit/forms/ui-input/src/lib/ui-input.scss
@@ -8,6 +8,8 @@
 $font-size-small: var(--ui-input-font-size-small, var(--size-typography-text-md));    /// Taille de police du contrôle et de l'unité, variante `small`.
 $unit-font-size: var(--ui-input-unit-font-size, var(--size-typography-text-default)); /// Taille de police de l'unité affichée dans le champ.
 
+@include utils.browser-fill;
+
 .ui-input {
   &-native {
     @include utils.field-native-input;
diff --git a/projects/ui-kit/forms/ui-input/src/lib/ui-input.ts b/projects/ui-kit/forms/ui-input/src/lib/ui-input.ts
index 07942453..d657118e 100644
--- a/projects/ui-kit/forms/ui-input/src/lib/ui-input.ts
+++ b/projects/ui-kit/forms/ui-input/src/lib/ui-input.ts
@@ -11,7 +11,7 @@ import {
 } from '@angular/core';
 import { NgTemplateOutlet } from '@angular/common';
 import { NG_VALUE_ACCESSOR } from '@angular/forms';
-import { BaseFormField } from '@4sh/ui-kit/forms';
+import { BaseFormField, UiBrowserFill } from '@4sh/ui-kit/forms';
 import { UiField } from '@4sh/ui-kit/forms/ui-field';
 import { UiIcon, UiIconSize } from '@4sh/ui-kit/base/ui-icon';
 
@@ -46,7 +46,7 @@ export interface UiInputIconContext {
  */
 @Component({
   selector: 'ui-input',
-  imports: [UiField, UiIcon, NgTemplateOutlet],
+  imports: [UiField, UiIcon, NgTemplateOutlet, UiBrowserFill],
   templateUrl: './ui-input.html',
   styleUrl: './ui-input.scss',
   providers: [{ provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => UiInput), multi: true }],
@@ -186,6 +186,11 @@ export class UiInput extends BaseFormField<string> {
     this.valueChange.emit(value);
   }
 
+  /** @ignore Value written by the browser without an `input` event. */
+  protected onBrowserFill(): void {
+    if (this.inputEl().nativeElement.value !== this.renderedValue()) this.onInput();
+  }
+
   /** @ignore */
   protected onBlur(event: FocusEvent): void {
     this.emitTouch();
diff --git a/projects/ui-kit/forms/ui-input/ui-input.mdx b/projects/ui-kit/forms/ui-input/ui-input.mdx
index dc27c92c..e959fe26 100644
--- a/projects/ui-kit/forms/ui-input/ui-input.mdx
+++ b/projects/ui-kit/forms/ui-input/ui-input.mdx
@@ -178,6 +178,87 @@ via l'interop CVA native, ainsi qu'aux formulaires template-driven (`[(ngModel)]
 <ui-input [formField]="field" label="Nom" placeholder="Votre nom" />
 ```
 
+## Saisie automatique du navigateur
+
+Quand le navigateur préremplit un formulaire (adresse, e-mail, code reçu par SMS), il écrit
+dans des champs où l'utilisateur n'est pas, et selon le navigateur il n'émet aucun `input`,
+seulement un `change`, ou un `input` sur un champ sans focus. Les champs du kit suivent ces
+trois cas : le modèle, `valueChange` et le `ControlValueAccessor` sont mis à jour **une seule
+fois**, sans attendre un clic dans le champ. La frappe et le collage ne changent pas.
+
+Une valeur écrite sans focus est traitée comme un remplissage, pas comme une frappe :
+
+<table className="doc-table">
+  <thead>
+    <tr>
+      <th>Champ</th>
+      <th>Valeur préremplie</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><code>ui-input</code>, <code>ui-textarea</code></td>
+      <td>Reprise telle quelle.</td>
+    </tr>
+    <tr>
+      <td><code>ui-input-number</code></td>
+      <td>Lue puis formatée aussitôt : aucune sortie du champ ne viendra le faire.</td>
+    </tr>
+    <tr>
+      <td><code>ui-input-mask</code></td>
+      <td>Passée au masque, sans placer de curseur.</td>
+    </tr>
+    <tr>
+      <td><code>ui-input-otp</code></td>
+      <td>Répartie dans les cases sans prendre le focus.</td>
+    </tr>
+    <tr>
+      <td><code>ui-datepicker</code></td>
+      <td>Validée sans attendre la sortie du champ ; si ce n'est pas une date, le champ revient à la valeur précédente.</td>
+    </tr>
+    <tr>
+      <td><code>ui-autocomplete</code></td>
+      <td>Prise comme texte libre, <code>completeMethod</code> émis aussitôt, panneau fermé. Avec <code>forceSelection</code>, la suggestion qui porte ce libellé est retenue dès qu'elle arrive.</td>
+    </tr>
+  </tbody>
+</table>
+
+Pour guider le navigateur, renseigner `autocomplete` (`name`, `email`, `tel`, `postal-code`,
+`bday`…) sur `ui-input` et `ui-datepicker`, et `name` sur les autres champs.
+
+> **À prévoir côté application.** Un champ prérempli devient `dirty` : une valeur invalide
+> affiche son erreur sans attendre le blur. `valueChange` (et `optionSelect` avec
+> `forceSelection`) peut partir sans geste de l'utilisateur : un gestionnaire qui appelle une
+> API ou remplit d'autres champs doit le tolérer. Dans les tests, un `input` envoyé à un champ
+> sans focus vaut remplissage : focaliser le champ avant de simuler une frappe (`userEvent.type`
+> ou `fill()` de Playwright le font déjà). Hors de portée : Chrome garde illisible par
+> JavaScript une valeur qu'il préremplit au chargement de la page, jusqu'à une interaction.
+
+### Dans un champ maison
+
+Un champ bâti sur `@4sh/ui-kit/forms` obtient le même comportement avec la directive
+`uiBrowserFill`, posée sur son élément natif, et le mixin `utils.browser-fill`, inclus à la
+racine de sa feuille de style. La directive émet `browserFill` sur l'animation
+`:-webkit-autofill` et sur `change` : le champ compare alors la valeur native avec celle qu'il
+affiche, ce qui évite toute double émission. `hasFocus(element)` distingue une frappe d'un
+`input` reçu sans focus, par exemple pour ne pas ouvrir de panneau.
+
+```html
+<input #native uiBrowserFill [value]="displayValue()" (input)="onInput()" (browserFill)="onBrowserFill()" />
+```
+
+```ts
+protected onBrowserFill(): void {
+  if (this.native().nativeElement.value !== this.displayValue()) this.onInput();
+}
+```
+
+```scss
+@use 'utils';
+
+@include utils.browser-fill;
+```
+
 ## Accessibilité
 
 <table className="doc-table">
diff --git a/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.browser-fill.spec.ts b/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.browser-fill.spec.ts
new file mode 100644
index 00000000..b4210bd5
--- /dev/null
+++ b/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.browser-fill.spec.ts
@@ -0,0 +1,68 @@
+/**
+ * TestBed spec for a value the browser writes into `ui-textarea` without a
+ * keystroke: the model and `valueChange` follow it once.
+ */
+import { Component } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { describe, expect, it } from 'vitest';
+import { UiTextarea } from './ui-textarea';
+
+@Component({
+  imports: [ReactiveFormsModule, UiTextarea],
+  template: `<ui-textarea
+    label="Adresse"
+    [formControl]="control"
+    (valueChange)="emitted.push($event)"
+  />`,
+})
+class FillHost {
+  readonly control = new FormControl('');
+  readonly emitted: string[] = [];
+}
+
+async function setup() {
+  await TestBed.configureTestingModule({ imports: [FillHost] }).compileComponents();
+  const fixture: ComponentFixture<FillHost> = TestBed.createComponent(FillHost);
+  fixture.detectChanges();
+  await fixture.whenStable();
+  const textarea = fixture.nativeElement.querySelector('textarea') as HTMLTextAreaElement;
+  const fire = async (type: string, animationName?: string) => {
+    const event = new Event(type, { bubbles: true });
+    if (animationName) Object.defineProperty(event, 'animationName', { value: animationName });
+    textarea.dispatchEvent(event);
+    fixture.detectChanges();
+    await fixture.whenStable();
+  };
+  return { host: fixture.componentInstance, textarea, fire };
+}
+
+describe('ui-textarea — browser fill', () => {
+  it('syncs a value revealed by the autofill animation alone', async () => {
+    const { host, textarea, fire } = await setup();
+    textarea.value = '1 rue de la Paix';
+    await fire('animationstart', 'ui-browser-fill');
+    expect(host.control.value).toBe('1 rue de la Paix');
+    expect(host.emitted).toEqual(['1 rue de la Paix']);
+  });
+
+  it('syncs a value revealed by a change alone, once', async () => {
+    const { host, textarea, fire } = await setup();
+    textarea.value = '1 rue de la Paix';
+    await fire('change');
+    await fire('animationstart', 'ui-browser-fill');
+    expect(host.emitted).toEqual(['1 rue de la Paix']);
+  });
+
+  it('emits once per keystroke, none on the closing change', async () => {
+    const { host, textarea, fire } = await setup();
+    textarea.focus();
+    textarea.value = '1';
+    await fire('input');
+    textarea.value = '1 ';
+    await fire('input');
+    await fire('change');
+    textarea.blur();
+    expect(host.emitted).toEqual(['1', '1 ']);
+  });
+});
diff --git a/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.html b/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.html
index 5d23f702..21231732 100644
--- a/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.html
+++ b/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.html
@@ -17,6 +17,7 @@
 >
   <textarea
     #textareaEl
+    uiBrowserFill
     class="ui-textarea-native"
     [class._small]="size() === 'small'"
     [class._auto-resize]="autoResize()"
@@ -36,6 +37,7 @@
     [attr.aria-describedby]="describedByIds()"
     [attr.aria-invalid]="effectiveLevel() === 'error' ? 'true' : null"
     (input)="onInput()"
+    (browserFill)="onBrowserFill()"
     (focus)="textareaFocus.emit($event)"
     (blur)="onBlur($event)"
   ></textarea>
diff --git a/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.scss b/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.scss
index ec3c0c74..a3a51af7 100644
--- a/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.scss
+++ b/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.scss
@@ -16,6 +16,8 @@ $font-size-small: var(--ui-textarea-font-size-small, var(--size-typography-text-
 $count-font-size: var(--ui-textarea-count-font-size, var(--size-typography-text-md));             /// Taille de police du compteur de caractères.
 $count-font-size-small: var(--ui-textarea-count-font-size-small, var(--size-typography-text-sm)); /// Taille de police du compteur de caractères, variante `small`.
 
+@include utils.browser-fill;
+
 .ui-textarea {
   &-native {
     @include utils.field-native-input($pad-x);
diff --git a/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.ts b/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.ts
index a69cdcb0..0dc2d444 100644
--- a/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.ts
+++ b/projects/ui-kit/forms/ui-textarea/src/lib/ui-textarea.ts
@@ -10,7 +10,7 @@ import {
   viewChild,
 } from '@angular/core';
 import { NG_VALUE_ACCESSOR } from '@angular/forms';
-import { BaseFormField } from '@4sh/ui-kit/forms';
+import { BaseFormField, UiBrowserFill } from '@4sh/ui-kit/forms';
 import { UiField } from '@4sh/ui-kit/forms/ui-field';
 
 /** Which axes the user can manually resize (ignored when `autoResize` is on). */
@@ -28,7 +28,7 @@ export type TextareaResize = 'none' | 'vertical' | 'horizontal' | 'both';
  */
 @Component({
   selector: 'ui-textarea',
-  imports: [UiField],
+  imports: [UiField, UiBrowserFill],
   templateUrl: './ui-textarea.html',
   styleUrl: './ui-textarea.scss',
   providers: [
@@ -112,6 +112,12 @@ export class UiTextarea extends BaseFormField<string> {
     if (this.autoResize()) this.resizeToContent();
   }
 
+  /** @ignore Value written by the browser without an `input` event. */
+  protected onBrowserFill(): void {
+    const el = this.textareaEl()?.nativeElement;
+    if (el && el.value !== this.displayValue()) this.onInput();
+  }
+
   /** @ignore */
   protected onBlur(event: FocusEvent): void {
     this.emitTouch();
diff --git a/projects/ui-kit/forms/ui-textarea/ui-textarea.mdx b/projects/ui-kit/forms/ui-textarea/ui-textarea.mdx
index 118cb810..451b9dfb 100644
--- a/projects/ui-kit/forms/ui-textarea/ui-textarea.mdx
+++ b/projects/ui-kit/forms/ui-textarea/ui-textarea.mdx
@@ -63,6 +63,10 @@ aussi le marqueur `*` sur le label. Pas besoin de forcer `level="error"`.
 <Canvas of={TextareaStories.Validation} />
 <Canvas of={TextareaStories.SignalForms} />
 
+Une adresse préremplie par le navigateur met à jour le modèle sans clic dans le champ, même
+quand le navigateur n'émet aucun `input` : voir la section « Saisie automatique du
+navigateur » de [`ui-input`](?path=/docs/components-ui-forms-ui-input--docs).
+
 ## Redimensionnement
 
 Par défaut, la poignée native permet d'agrandir **verticalement** le champ. `resize`
diff --git a/projects/ui-kit/styles/utils/_mixins.scss b/projects/ui-kit/styles/utils/_mixins.scss
index ef023094..509c9f74 100644
--- a/projects/ui-kit/styles/utils/_mixins.scss
+++ b/projects/ui-kit/styles/utils/_mixins.scss
@@ -114,6 +114,17 @@ $_moving-properties: (
   padding-block-start: calc(#{$extra} + var(--_field-inset-block-start, 0px));
 }
 
+/// Starts the animation `UiBrowserFill` listens to while the browser autofills
+/// a field marked `uiBrowserFill`. Include once, at the root of the stylesheet
+/// of the component whose template holds that field.
+@mixin browser-fill {
+  @keyframes ui-browser-fill {
+    from { opacity: 1; }
+  }
+
+  .ui-browser-fill:-webkit-autofill { animation: ui-browser-fill 0s; }
+}
+
 /// Bare native <input>/<textarea> filling the field box (no border/bg).
 /// `$inset` = horizontal field inset owned by the control (see
 /// `field-inset-edges`); pass `false` when the control is nested in a wrapper