stimeo-ui 0.16.0 → 0.18.0

package/dist/controllers/flash_controller.js

@@ -1,8 +1,27 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/flash_controller.ts
+var FOCUS_EVENTS = /* @__PURE__ */ new Set(["blur", "focus", "focusin", "focusout"]);
+var POINTER_EVENTS = /* @__PURE__ */ new Set(["mouseenter", "mouseleave", "pointerenter", "pointerleave"]);
+function stateReasonFor(event) {
+  if (!event) return "api";
+  if (FOCUS_EVENTS.has(event.type)) return "focus";
+  if (POINTER_EVENTS.has(event.type)) return "pointer";
+  return "user";
+}
+
+function actionSource(source) {
+  if (source instanceof HTMLElement) {
+    return { event: null, host: source, origin: source, reason: "api" };
+  }
+  const event = source ?? null;
+  return {
+    event,
+    host: event?.currentTarget instanceof Element ? event.currentTarget : null,
+    origin: event?.target instanceof Element ? event.target : null,
+    reason: stateReasonFor(event)
+  };
+}
 
-// src/utils/announce.ts
 function announce(message, options = {}) {
   const text = message.trim();
   if (text.length === 0) return;
@@ -13,36 +32,6 @@ function announce(message, options = {}) {
   );
 }
 
-// src/utils/before_cache_reset.ts
-var BeforeCacheReset = class _BeforeCacheReset {
-  /** Every subscribed instance, iterated by the one shared document listener. */
-  static #subscribers = /* @__PURE__ */ new Set();
-  /** The shared listener; installed while at least one instance is subscribed. */
-  static #onBeforeCache = () => {
-    for (const subscriber of _BeforeCacheReset.#subscribers) subscriber.#rewind();
-  };
-  #rewind;
-  /** @param rewind - the pass that returns this controller's state to its initial form. */
-  constructor(rewind) {
-    this.#rewind = rewind;
-  }
-  /** Subscribes to `turbo:before-cache`; call from `connect()`. Idempotent. */
-  activate() {
-    const first = _BeforeCacheReset.#subscribers.size === 0;
-    _BeforeCacheReset.#subscribers.add(this);
-    if (first) {
-      document.addEventListener("turbo:before-cache", _BeforeCacheReset.#onBeforeCache);
-    }
-  }
-  /** Unsubscribes; call from `disconnect()`. Safe when never subscribed. */
-  deactivate() {
-    _BeforeCacheReset.#subscribers.delete(this);
-    if (_BeforeCacheReset.#subscribers.size > 0) return;
-    document.removeEventListener("turbo:before-cache", _BeforeCacheReset.#onBeforeCache);
-  }
-};
-
-// src/utils/event_owner.ts
 function ownerIndex(candidates, node) {
   if (!(node instanceof Node)) return -1;
   return candidates.findIndex((candidate) => candidate.contains(node));
@@ -51,43 +40,79 @@ function ownerOf(candidates, node) {
   return candidates[ownerIndex(candidates, node)] ?? null;
 }
 
-// src/utils/safe_timeout.ts
+var ListenerSet = class {
+  #abort = new AbortController();
+  add(target, type, handler, options) {
+    target.addEventListener(type, handler, { ...options, signal: this.#abort.signal });
+  }
+  dispose() {
+    this.#abort.abort();
+    this.#abort = new AbortController();
+  }
+};
+
+var HoverRecheck = class {
+  #document;
+  #release;
+  #listeners = new ListenerSet();
+  #pending = /* @__PURE__ */ new Set();
+  #tickets = /* @__PURE__ */ new WeakMap();
+  constructor(document2, release) {
+    this.#document = document2;
+    this.#release = release;
+  }
+  wait(element) {
+    this.#pending.add(element);
+    this.#tickets.set(element, /* @__PURE__ */ Symbol());
+    this.#listeners.add(this.#document, "pointermove", this.#onPointerMove, {
+      capture: true,
+      passive: true
+    });
+  }
+  cancel(element) {
+    this.#tickets.delete(element);
+    this.#pending.delete(element);
+    if (this.#pending.size === 0) this.#listeners.dispose();
+  }
+  dispose() {
+    this.#listeners.dispose();
+    this.#pending.clear();
+    this.#tickets = /* @__PURE__ */ new WeakMap();
+  }
+  #onPointerMove = () => {
+    this.#listeners.dispose();
+    const waiting = [...this.#pending].map(
+      (element) => [element, this.#tickets.get(element)]
+    );
+    this.#pending.clear();
+    for (const [element, ticket] of waiting) {
+      if (this.#tickets.get(element) !== ticket) continue;
+      if (element.matches(":hover")) continue;
+      this.#release(element);
+    }
+  };
+};
+
+var MAX_TIMER_DELAY_MS = 2147483647;
+
 var TimerRegistry = class {
-  /** Live timer ids that have not yet been cleared (or, for timeouts, fired). */
   ids = /* @__PURE__ */ new Set();
-  /**
-   * Cancels a single tracked timer.
-   *
-   * No-ops if the id is unknown (already cleared, fired, or never owned by this
-   * registry), so callers can clear defensively without guarding.
-   */
   clear(id) {
     if (this.ids.delete(id)) {
       this.cancel(id);
     }
   }
-  /**
-   * Cancels every tracked timer. Call this from a controller's `disconnect()`
-   * to guarantee no timer outlives the element.
-   */
   clearAll() {
     for (const id of this.ids) {
       this.cancel(id);
     }
     this.ids.clear();
   }
-  /** Number of timers currently tracked (pending). */
   get size() {
     return this.ids.size;
   }
 };
 var SafeTimeout = class extends TimerRegistry {
-  /**
-   * Schedules `callback` after `delay` ms and returns the timer id.
-   *
-   * The id is removed from the registry automatically when the timeout fires,
-   * so {@link TimerRegistry.size | size} reflects only still-pending timers.
-   */
   set(callback, delay) {
     const id = this.schedule(() => {
       this.ids.delete(id);
@@ -104,16 +129,9 @@ var SafeTimeout = class extends TimerRegistry {
   }
 };
 
-// src/utils/keyed_timers.ts
 var KeyedTimers = class {
   #timers = new SafeTimeout();
-  /** The pending timer of each key; an entry lives exactly as long as its timer. */
   #pending = /* @__PURE__ */ new Map();
-  /**
-   * Arms `callback` after `delay` ms for `key`, cancelling the timer `key` had
-   * pending. The entry is dropped before the callback runs, so the callback sees
-   * the key unarmed and may arm it again for the next round.
-   */
   set(key, callback, delay) {
     this.clear(key);
     const id = this.#timers.set(() => {
@@ -122,76 +140,38 @@ var KeyedTimers = class {
     }, delay);
     this.#pending.set(key, id);
   }
-  /**
-   * Cancels `key`'s pending timer, if it has one.
-   *
-   * A timer id is a positive integer, so `-1` stands for "nothing pending" and
-   * the registry ignores an id it does not own — the unarmed case needs no
-   * branch of its own, and no other key's timer can be reached from here.
-   */
   clear(key) {
     this.#timers.clear(this.#pending.get(key) ?? -1);
     this.#pending.delete(key);
   }
-  /**
-   * Cancels every pending timer and forgets every key. Call this from a
-   * controller's `disconnect()` so no timer, and no entry, outlives the element.
-   */
   clearAll() {
     this.#timers.clearAll();
     this.#pending.clear();
   }
-  /** Whether `key` has a timer pending. */
   has(key) {
     return this.#pending.has(key);
   }
 };
 
-// src/utils/listener_set.ts
-var ListenerSet = class {
-  /** The generation every `add` joins until the next `dispose()`. */
-  #abort = new AbortController();
-  /**
-   * Attaches `handler` to the open generation, exactly as the caller spelled it.
-   *
-   * The set supplies the signal, so `options` carries everything else the DOM
-   * accepts — `capture` included, which has to match at release time and no
-   * longer has a second place to drift from.
-   */
-  add(target, type, handler, options) {
-    target.addEventListener(type, handler, { ...options, signal: this.#abort.signal });
-  }
-  /**
-   * Releases every listener of the open generation, synchronously, and opens the
-   * next one. Idempotent, and safe before anything has been added.
-   */
-  dispose() {
-    this.#abort.abort();
-    this.#abort = new AbortController();
-  }
-};
-
-// src/utils/microtask_coalescer.ts
 var MicrotaskCoalescer = class {
   #run;
   #queued = false;
   #active = false;
   #generation = 0;
-  /** @param run - the single reconciliation pass, invoked at most once per batch. */
   constructor(run) {
     this.#run = run;
   }
-  /** Opens the window in which {@link schedule} is honoured; call from `connect()`. */
   activate() {
     this.#active = true;
   }
-  /** Closes the window and drops any pending pass; call from `disconnect()`. */
   cancel() {
     this.#active = false;
     this.#queued = false;
     this.#generation += 1;
   }
-  /** Requests one pass after the batch settles. Idempotent; inert outside the window. */
+  get pending() {
+    return this.#queued;
+  }
   schedule() {
     if (!this.#active || this.#queued) return;
     this.#queued = true;
@@ -204,27 +184,88 @@ var MicrotaskCoalescer = class {
   }
 };
 
-// src/utils/pausable_timers.ts
+var MorphRenderWatcher = class {
+  #listeners = new ListenerSet();
+  #pass;
+  #element = null;
+  #onMorph = () => this.#pass.schedule();
+  constructor(run) {
+    this.#pass = new MicrotaskCoalescer(run);
+  }
+  observe(element) {
+    if (this.#element === element) return;
+    this.disconnect();
+    this.#element = element;
+    this.#pass.activate();
+    this.#listeners.add(element, "turbo:morph-element", this.#onMorph);
+  }
+  schedule() {
+    this.#pass.schedule();
+  }
+  get pending() {
+    return this.#pass.pending;
+  }
+  disconnect() {
+    this.#listeners.dispose();
+    this.#pass.cancel();
+    this.#element = null;
+  }
+};
+
+var NUMBER_BOUNDS = {
+  finite: { finite: true },
+  timer: { finite: true, min: 0, max: MAX_TIMER_DELAY_MS }};
+function matchesNumberBounds(value, bounds) {
+  if (!Number.isFinite(value)) {
+    const direction = value === Infinity ? "positive" : value === -Infinity ? "negative" : null;
+    if (direction === null) return false;
+    if (bounds.allowInfinity !== "both" && bounds.allowInfinity !== direction) return false;
+  }
+  if (bounds.min !== void 0 && value < bounds.min) return false;
+  if (bounds.max !== void 0 && value > bounds.max) return false;
+  if (bounds.exclusiveMin !== void 0 && value <= bounds.exclusiveMin) return false;
+  if (bounds.integer && !Number.isInteger(value)) return false;
+  if (bounds.allowedValues !== void 0 && !bounds.allowedValues.includes(value)) return false;
+  return true;
+}
+
+function readNumber(raw, fallback, bounds) {
+  return matchesNumberBounds(raw, bounds) ? raw : fallback;
+}
+
+var NumberValueReader = class {
+  #lastRejected = /* @__PURE__ */ new Map();
+  read(owner, name, raw, fallback, bounds) {
+    const resolved = readNumber(raw, fallback, bounds);
+    if (matchesNumberBounds(raw, bounds)) {
+      this.#lastRejected.delete(name);
+      return resolved;
+    }
+    const attribute = `data-${owner.identifier}-${name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}-value`;
+    const literal = owner.element.getAttribute(attribute);
+    if (literal === null) {
+      this.#lastRejected.delete(name);
+      return resolved;
+    }
+    if (this.#lastRejected.get(name) !== literal) {
+      this.#lastRejected.set(name, literal);
+      console.warn(
+        `Stimeo UI: "${owner.identifier}" has an invalid number Value "${name}" declaration ${JSON.stringify(literal)}; using ${fallback}.`
+      );
+    }
+    return resolved;
+  }
+};
+
 var PausableTimers = class {
   #timers = new KeyedTimers();
-  /** Every key armed or held; an entry goes as its timer fires, or with the key. */
   #entries = /* @__PURE__ */ new Map();
-  /**
-   * Arms `callback` after `delay` ms for `key`, replacing whatever `key` had.
-   * A held key stays held and banks `delay` for its resume.
-   */
   set(key, callback, delay) {
     const reasons = this.#entries.get(key)?.reasons ?? /* @__PURE__ */ new Set();
     const entry = { callback, startedAt: 0, remaining: delay, reasons };
     this.#entries.set(key, entry);
     if (reasons.size === 0) this.#arm(key, entry, callback);
   }
-  /**
-   * Holds `key` for `reason` and banks the time left, with a floor of one
-   * millisecond. A key with no timer is held all the same. Reports whether this
-   * call is the one that stopped a running timer, so the caller can write its
-   * held-state hook exactly once.
-   */
   pause(key, reason) {
     let entry = this.#entries.get(key);
     if (entry === void 0) {
@@ -237,11 +278,6 @@ var PausableTimers = class {
     entry.remaining = Math.max(1, entry.remaining - (Date.now() - entry.startedAt));
     return true;
   }
-  /**
-   * Releases `reason` on `key`, arming the banked time again once no reason is
-   * left; a key released with no timer is forgotten. Reports whether this call
-   * is the one that started the timer again.
-   */
   resume(key, reason) {
     const entry = this.#entries.get(key);
     if (entry === void 0) return false;
@@ -255,38 +291,20 @@ var PausableTimers = class {
     this.#arm(key, entry, callback);
     return true;
   }
-  /** Whether any reason holds `key`, with or without a timer. */
   isHeld(key) {
     return (this.#entries.get(key)?.reasons.size ?? 0) > 0;
   }
-  /** Whether `key` is armed or held — that is, whether this registry drives it at all. */
   tracks(key) {
     return this.#entries.has(key);
   }
-  /**
-   * Cancels `key`'s timer and keeps its hold, so a release arms nothing; a key
-   * nothing holds is forgotten.
-   */
-  disarm(key) {
-    this.#timers.clear(key);
-    const entry = this.#entries.get(key);
-    if (entry?.reasons.size) entry.callback = null;
-    else this.#entries.delete(key);
-  }
-  /** Cancels `key`'s timer and drops its hold. */
   clear(key) {
     this.#timers.clear(key);
     this.#entries.delete(key);
   }
-  /**
-   * Cancels every timer and forgets every key. Call this from a controller's
-   * `disconnect()` so neither a timer nor a hold outlives the element.
-   */
   clearAll() {
     this.#timers.clearAll();
     this.#entries.clear();
   }
-  /** Starts `entry`'s banked time running for `key`, and drops it as `callback` fires. */
   #arm(key, entry, callback) {
     entry.startedAt = Date.now();
     this.#timers.set(
@@ -300,12 +318,10 @@ var PausableTimers = class {
   }
 };
 
-// src/utils/target_selector.ts
 function targetSelector(identifier, name) {
   return `[data-${identifier}-target~="${name}"]`;
 }
 
-// src/utils/transition_completion.ts
 function timeMs(value) {
   const trimmed = value.trim();
   const amount = Number.parseFloat(trimmed);
@@ -339,11 +355,11 @@ function maxTransitionTotalMs(style) {
   return maxTotalMs(transitionTimings(style));
 }
 
-// src/controllers/flash_controller.ts
 var ASSERTIVE_TYPES = /* @__PURE__ */ new Set(["alert", "error"]);
 var MESSAGE_PART = "message";
-var FlashController = class extends Controller {
-  /** Selects the message parts, in the namespace this controller is registered under. */
+var SHOWN_ATTRIBUTE = "shown";
+var FlashController = class _FlashController extends Controller {
+  #numbers = new NumberValueReader();
   get #messageSelector() {
     return targetSelector(this.identifier, MESSAGE_PART);
   }
@@ -353,54 +369,31 @@ var FlashController = class extends Controller {
     pauseOnHover: { type: Boolean, default: true },
     max: { type: Number, default: 0 }
   };
+  static valueConstraints = {
+    duration: NUMBER_BOUNDS.timer,
+    max: NUMBER_BOUNDS.finite
+  };
   static actions = ["dismiss"];
   static events = ["show", "dismiss", "reconcile"];
-  /** Removal timers for the leaving transition; the auto-dismiss ones live below. */
   #timers = new SafeTimeout();
-  /**
-   * Per-message auto-dismiss held open while the message is hovered or focused, and
-   * the one record of which messages hover or focus holds, which the cap reads.
-   */
   #dismiss = new PausableTimers();
-  /**
-   * Auto-dismiss of the messages taken on while `pauseOnHover` is off. It runs on
-   * whatever holds the message; the hold itself still keeps the cap away.
-   */
   #fixedDismiss = new KeyedTimers();
-  /** Applies the cap again once the event that released a hold has run its course. */
-  #reapply = new MicrotaskCoalescer(() => this.#reapplyCap());
-  /** Messages the pointer or focus moved into since the cap was last applied again. */
+  #reapply = new MorphRenderWatcher(() => this.#reapplyCap());
   #spared = [];
-  /** The next pointer movement, listened for while a hover hold waits on it. */
-  #pointer = new ListenerSet();
-  /** Messages whose hover hold waits for the next pointer movement to be confirmed. */
-  #awaitingPointer = /* @__PURE__ */ new Set();
+  #pointer = new HoverRecheck(
+    this.element.ownerDocument,
+    (message) => this.#resume(message, "hover", null)
+  );
   #observer = null;
-  /** Whether the controller is between `connect()` and `disconnect()`. */
   #connected = false;
-  /**
-   * The `max` the stack was last held to, or `null` before the first time. `connect()`
-   * applies the cap only when `max` is not that one, so a reconnect of the same instance
-   * leaves the stack as it was unless `max` changed while it was away.
-   */
+  #arrivals = /* @__PURE__ */ new Set();
   #appliedMax = null;
-  /** Messages already processed, in insertion order, to enforce `max` and avoid double work. */
   #order = [];
-  /**
-   * Messages between `leaving` and their removal. {@link FlashController.#beginDismiss}
-   * releases the bookkeeping above *before* the transition wait, so for that window the
-   * element is in the DOM but in neither collection — without this set a re-scan would
-   * read it as a brand-new flash and show it a second time.
-   */
   #leaving = /* @__PURE__ */ new Set();
-  #beforeCache = new BeforeCacheReset(() => this.#rewindForCache());
+  get #shownAttribute() {
+    return `data-${this.identifier}-${SHOWN_ATTRIBUTE}`;
+  }
   #onEnter = (event) => this.#pause(event.currentTarget, event.type === "focusin" ? "focus" : "hover");
-  /**
-   * Releases hover or focus on a message. Focus moving between two of the message's
-   * own controls is no release, since `focusout` names a control still inside it; and
-   * the message the pointer or focus is moving into is spared when the release
-   * applies the cap again, because its own hold only arrives after this event.
-   */
   #onLeave = (event) => {
     const message = event.currentTarget;
     const next = ownerOf(this.#order, event.relatedTarget);
@@ -409,92 +402,58 @@ var FlashController = class extends Controller {
   };
   connect() {
     this.#connected = true;
-    this.#reapply.activate();
+    const current = this.messageTargets;
+    for (const item of this.#arrivals) {
+      if (!current.includes(item)) this.#arrivals.delete(item);
+    }
+    this.#discardInherited();
+    this.#reapply.observe(this.element);
     for (const message of this.messageTargets) {
       if (this.#owns(message)) this.#process(message, true);
     }
-    if (!Object.is(this.#appliedMax, this.maxValue)) {
-      this.#appliedMax = this.maxValue;
+    if (!Object.is(this.#appliedMax, this.#safeMax)) {
+      this.#appliedMax = this.#safeMax;
       this.#enforceMax();
     }
     this.#syncObservation();
-    this.#beforeCache.activate();
   }
   disconnect() {
     this.#connected = false;
-    this.#beforeCache.deactivate();
     this.#stopObserving();
     this.#timers.clearAll();
     this.#dismiss.clearAll();
     this.#fixedDismiss.clearAll();
-    this.#reapply.cancel();
+    this.#reapply.disconnect();
     this.#spared = [];
     this.#pointer.dispose();
-    this.#awaitingPointer.clear();
     for (const message of this.#order) this.#unbindPause(message);
     this.#order.length = 0;
     this.#leaving.clear();
   }
-  /**
-   * Takes the managed flashes out of the page just before Turbo freezes it, so a
-   * restored snapshot carries no notification the visitor has already received: the
-   * fresh `connect()` there reads a leftover flash as a brand-new one and announces it
-   * a second time. A message that never auto-dismisses (`duration: 0`) is one of these
-   * too — that value governs the timer, not what belongs in a cached page. Removal
-   * only: `dismiss` reports a dismissal, and freezing the page is not one.
-   */
-  #rewindForCache() {
-    const removed = this.#order.length;
-    for (const message of [...this.#order]) {
+  #discardInherited() {
+    let removed = 0;
+    for (const message of this.messageTargets) {
+      if (!message.hasAttribute(this.#shownAttribute) || this.#arrivals.has(message)) continue;
+      if (!this.#owns(message)) continue;
       message.remove();
-      this.#forget(message);
+      removed += 1;
     }
-    for (const message of this.#leaving) message.remove();
-    this.#leaving.clear();
     if (removed > 0) this.dispatch("reconcile", { detail: { removed } });
   }
-  /** Follows a `region` element swapped in — or arriving — at runtime (Turbo Stream). */
   regionTargetConnected() {
     this.#resync();
   }
-  /** Releases the observation when the `region` element leaves the target set. */
   regionTargetDisconnected() {
     this.#resync();
   }
-  /**
-   * Holds the stack to a changed `max`: lowering it below the count dismisses the
-   * oldest messages hover and focus do not hold, with reason `limit`, as an arrival
-   * past the cap does, while raising it or setting `0` dismisses nothing. Stimulus can
-   * also call this ahead of `connect()` — for an attribute that changed while the
-   * controller was away, and on every connect for an undeclared `max`, with its default;
-   * `connect()` decides then.
-   */
   maxValueChanged() {
     if (!this.#connected) return;
-    this.#appliedMax = this.maxValue;
+    this.#appliedMax = this.#safeMax;
     this.#enforceMax();
   }
-  /**
-   * Whether this controller owns `message`. Ownership is the current `region`'s
-   * subtree: a message target anywhere else in the controller's scope is the
-   * consumer's, and so is one in a region that has gone away. The initial scan, a
-   * re-scan after a `region` swap, and a departure from the target set all resolve
-   * ownership through this one test; the observation gets it structurally, by watching
-   * that subtree and nothing else.
-   */
   #owns(message) {
     return this.hasRegionTarget && this.regionTarget.contains(message);
   }
-  /**
-   * Releases a message that left the target set (a Turbo Stream `remove`, the consumer
-   * detaching the node, or a morph that rewrote the target attribute in place): it
-   * stops occupying a `max` slot, and both its pending auto-dismiss and an already
-   * scheduled removal are cancelled. A move *within* the region keeps all of them —
-   * which is why the element must still be a message to be treated as one: ownership
-   * alone reads an in-place attribute rewrite as a move, and a node outside the target
-   * set belongs to the consumer, so nothing here may dismiss it. A move may still have
-   * ended a hold, so those are read again.
-   */
   messageTargetDisconnected(message) {
     if (!this.#connected) return;
     const moved = this.#owns(message) && message.matches(this.#messageSelector);
@@ -503,15 +462,9 @@ var FlashController = class extends Controller {
       return;
     }
     this.#forget(message);
+    this.#arrivals.delete(message);
     this.#leaving.delete(message);
   }
-  /**
-   * Re-points the observation after a `region` swap and picks up the messages the
-   * new element brought with it (dynamic inserts, so their own `role` announces
-   * them). The `#connected` guard is load-bearing: Stimulus runs target callbacks
-   * for the initial markup *before* `connect()` and again during teardown *after*
-   * `disconnect()`, and re-observing there would outlive the controller.
-   */
   #resync() {
     if (!this.#connected) return;
     this.#syncObservation();
@@ -519,11 +472,6 @@ var FlashController = class extends Controller {
       if (this.#owns(message)) this.#process(message, false);
     }
   }
-  /**
-   * Points the mutation observation at the current `region` target, re-resolved on
-   * every sync rather than captured at connect, so an element swapped in at runtime
-   * is observed instead of the detached original.
-   */
   #syncObservation() {
     this.#stopObserving();
     if (!this.hasRegionTarget || typeof MutationObserver === "undefined") return;
@@ -534,11 +482,6 @@ var FlashController = class extends Controller {
     this.#observer?.disconnect();
     this.#observer = null;
   }
-  /**
-   * Hover and focus listeners, bound and unbound as a pair so the two sides stay in
-   * sync. Every message gets them, whatever `pauseOnHover` says, because the cap reads
-   * the holds they record; unbinding is idempotent (a no-op when nothing was bound).
-   */
   #bindPause(message) {
     message.addEventListener("mouseenter", this.#onEnter);
     message.addEventListener("mouseleave", this.#onLeave);
@@ -551,13 +494,14 @@ var FlashController = class extends Controller {
     message.removeEventListener("focusin", this.#onEnter);
     message.removeEventListener("focusout", this.#onLeave);
   }
-  /** Dismisses the flash whose close control fired the event. */
-  dismiss(event) {
-    const target = event.currentTarget || event.target;
-    const message = target?.closest(this.#messageSelector);
-    if (message) this.#beginDismiss(message, "user");
+  dismiss(input) {
+    const source = actionSource(input);
+    if (source.origin && source.origin.closest(`[data-controller~="${this.identifier}"]`) !== this.element)
+      return;
+    const message = (source.origin ?? source.host)?.closest(this.#messageSelector);
+    if (message && this.messageTargets.includes(message))
+      this.#beginDismiss(message, source.reason);
   }
-  /** Processes messages added after connect (Turbo Stream); their own role announces them. */
   #onMutations(mutations) {
     for (const mutation of mutations) {
       for (const node of mutation.addedNodes) {
@@ -569,14 +513,6 @@ var FlashController = class extends Controller {
       }
     }
   }
-  /**
-   * Applies role/state, wires pause listeners, takes the holds the message already has,
-   * and schedules auto-dismiss. A message `connect()` takes on (`atConnect`) is bridged
-   * to the Announcer and meets no cap here, `connect()` holding the stack to it; a later
-   * insert announces through its own role and meets the cap as it arrives. Idempotent
-   * per message, and a node that has left the region by the time its insertion is
-   * reported is not taken on.
-   */
   #process(message, atConnect) {
     if (this.#order.includes(message) || this.#leaving.has(message) || !this.#owns(message)) {
       return;
@@ -587,134 +523,74 @@ var FlashController = class extends Controller {
       message.setAttribute("role", assertive ? "alert" : "status");
     }
     message.setAttribute("data-flash-state", "visible");
+    message.setAttribute(this.#shownAttribute, "");
+    const known = this.#arrivals.has(message);
     this.#order.push(message);
+    this.#arrivals.add(message);
     this.#bindPause(message);
     this.#readHolds(message);
-    const text = message.textContent?.trim() ?? "";
-    this.dispatch("show", { target: message, detail: { type, message: text } });
-    if (atConnect) announce(text, { assertive });
+    if (!known) {
+      const text = message.textContent?.trim() ?? "";
+      this.dispatch("show", { target: message, detail: { type, message: text } });
+      if (atConnect) announce(text, { assertive });
+    }
     this.#startTimer(message);
     if (!atConnect) this.#enforceMax([message]);
   }
-  /**
-   * Dismisses the oldest messages with reason `limit` while more than `max` are shown
-   * (0 or less, or not a finite number, means no cap), passing over every message hover
-   * or focus holds and those in `spared` — the message just taken on, or the ones the
-   * pointer or focus moved into. Only messages still in the region count or go: one a
-   * script has just taken out stays on the stack until its removal is reported. With
-   * nothing else left to go the stack stays over the cap. The loop walks a copy and
-   * re-reads the count on every step, because a `dismiss` listener may already have
-   * changed both.
-   *
-   * @stimeoRenderRoot
-   */
   #enforceMax(spared = []) {
-    if (!Number.isFinite(this.maxValue) || this.maxValue <= 0) return;
-    for (const message of [...this.#order]) {
-      if (this.#shownCount() <= this.maxValue) return;
+    if (this.#safeMax <= 0) return;
+    for (const message of [...this.#arrivals]) {
+      if (this.#shownCount() <= this.#safeMax) return;
       if (this.#owns(message) && !spared.includes(message) && !this.#dismiss.isHeld(message)) {
         this.#beginDismiss(message, "limit");
       }
     }
   }
-  /** How many messages the stack shows: the ones taken on that are still in the region. */
   #shownCount() {
     return this.#order.filter((message) => this.#owns(message)).length;
   }
-  /**
-   * Arms a message's auto-dismiss; a non-positive `duration` means it never expires.
-   * The timer waits out hover and focus when `pauseOnHover` is on, and runs on
-   * regardless when it is off.
-   *
-   * @stimeoRuntimeOnly `duration` is the delay of the one dismissal timer this call arms,
-   *   and `pauseOnHover` whether hover and focus hold that timer.
-   */
   #startTimer(message) {
-    if (this.durationValue <= 0) return;
+    if (this.#safeDuration <= 0) return;
     const dismiss = () => this.#beginDismiss(message, "timeout");
-    if (this.pauseOnHoverValue) this.#dismiss.set(message, dismiss, this.durationValue);
-    else this.#fixedDismiss.set(message, dismiss, this.durationValue);
-  }
-  /**
-   * Records hover or focus on a message. Hover and focus are independent reasons:
-   * the registry banks the time left on the first of them and waits for the last
-   * (WCAG 2.2 2.2.1), and the cap passes over the message while either is held.
-   */
+    if (this.pauseOnHoverValue) this.#dismiss.set(message, dismiss, this.#safeDuration);
+    else this.#fixedDismiss.set(message, dismiss, this.#safeDuration);
+  }
   #pause(message, reason) {
     this.#dismiss.pause(message, reason);
   }
-  /**
-   * Releases one reason, resuming the banked time once no reason is left. Releasing
-   * the last one applies the cap again, sparing `spare`.
-   */
   #resume(message, reason, spare) {
     const held = this.#dismiss.isHeld(message);
     this.#dismiss.resume(message, reason);
     if (held && !this.#dismiss.isHeld(message)) this.#capLater(spare);
   }
-  /**
-   * Applies the cap again once the current event is over, sparing `spare`. A hold can
-   * end in a `focusout` the engine fires while it is itself taking the node out for a
-   * script's move or removal, and dismissing the message inside that event would pull
-   * the node from under the caller's own call.
-   */
   #capLater(spare) {
     if (spare) this.#spared.push(spare);
     this.#reapply.schedule();
   }
-  /** Applies the cap again, sparing every message gathered since the last pass. */
   #reapplyCap() {
+    for (const message of [...this.#order, ...this.#leaving]) {
+      if (!this.#owns(message)) continue;
+      message.setAttribute("data-flash-state", this.#leaving.has(message) ? "leaving" : "visible");
+      message.setAttribute(this.#shownAttribute, "");
+      if (!message.hasAttribute("role")) {
+        const assertive = ASSERTIVE_TYPES.has(message.getAttribute("data-flash-type") ?? "");
+        message.setAttribute("role", assertive ? "alert" : "status");
+      }
+    }
     const spared = this.#spared;
     this.#spared = [];
     this.#enforceMax(spared);
   }
-  /**
-   * Reads the holds of a message that moved within the region. Focus is read at once:
-   * an ordinary move ends it with a `focusout` and `moveBefore` keeps it. Where the
-   * pointer is, nothing says until it moves again: no `mouseleave` reaches a moved node,
-   * and `:hover` can answer from before the move. A message still held waits for that
-   * movement.
-   */
   #afterMove(message) {
     if (!message.contains(document.activeElement)) this.#resume(message, "focus", null);
-    if (this.#dismiss.isHeld(message)) this.#awaitPointer(message);
+    if (this.#dismiss.isHeld(message)) this.#pointer.wait(message);
   }
-  /**
-   * Takes the holds a message already has as it is taken on: focus inside it, and the
-   * pointer over it by `:hover`. That answer can date from before the message came here,
-   * so a hover hold taken on it waits for the next pointer movement to be confirmed.
-   */
   #readHolds(message) {
     if (message.contains(document.activeElement)) this.#pause(message, "focus");
     if (!message.matches(":hover")) return;
     this.#pause(message, "hover");
-    this.#awaitPointer(message);
+    this.#pointer.wait(message);
   }
-  /** Leaves `message`'s hover hold to be confirmed or let go on the next pointer movement. */
-  #awaitPointer(message) {
-    this.#awaitingPointer.add(message);
-    this.#pointer.add(document, "pointermove", this.#onPointerMove, {
-      capture: true,
-      passive: true
-    });
-  }
-  /**
-   * Reads `:hover` once the pointer has moved, when the answer is current, and lets go of
-   * the hover hold of every waiting message the pointer is not over. Listens once.
-   */
-  #onPointerMove = () => {
-    this.#pointer.dispose();
-    const waiting = [...this.#awaitingPointer];
-    this.#awaitingPointer.clear();
-    for (const message of waiting) {
-      if (!message.matches(":hover")) this.#resume(message, "hover", null);
-    }
-  };
-  /**
-   * Releases every per-message resource: timers, hold, stacking slot, pause listeners,
-   * and the wait on the pointer. A message something still held counts as released: the
-   * cap is applied again.
-   */
   #forget(message) {
     if (this.#dismiss.isHeld(message)) this.#capLater(null);
     this.#dismiss.clear(message);
@@ -722,10 +598,8 @@ var FlashController = class extends Controller {
     const index = this.#order.indexOf(message);
     if (index !== -1) this.#order.splice(index, 1);
     this.#unbindPause(message);
-    this.#awaitingPointer.delete(message);
-    if (this.#awaitingPointer.size === 0) this.#pointer.dispose();
+    this.#pointer.cancel(message);
   }
-  /** Marks a message leaving, then removes it after its CSS transition and emits dismiss. */
   #beginDismiss(message, reason) {
     if (!this.#order.includes(message)) return;
     this.#forget(message);
@@ -734,6 +608,7 @@ var FlashController = class extends Controller {
     const finalize = () => {
       if (!this.#leaving.delete(message)) return;
       message.remove();
+      this.#arrivals.delete(message);
       this.dispatch("dismiss", { detail: { element: message, reason } });
     };
     const transition = this.#transitionMs(message);
@@ -743,13 +618,29 @@ var FlashController = class extends Controller {
       finalize();
     }
   }
-  /** Maximum transition total (duration + delay) of `el` in ms (0 when none / unsupported). */
   #transitionMs(el) {
     if (typeof window.getComputedStyle !== "function") return 0;
     return maxTransitionTotalMs(window.getComputedStyle(el));
   }
+  get #safeDuration() {
+    return this.#numbers.read(
+      this,
+      "duration",
+      this.durationValue,
+      _FlashController.values.duration.default,
+      _FlashController.valueConstraints.duration
+    );
+  }
+  get #safeMax() {
+    return this.#numbers.read(
+      this,
+      "max",
+      this.maxValue,
+      _FlashController.values.max.default,
+      _FlashController.valueConstraints.max
+    );
+  }
 };
 
 export { FlashController };
-//# sourceMappingURL=flash_controller.js.map
 //# sourceMappingURL=flash_controller.js.map