stimeo-ui 0.11.0 → 0.13.0

data/dist/index.js

@@ -1886,6 +1886,15 @@ function parseISOMonthString(monthStr) {
 function toISOMonthString(date) {
   return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}`;
 }
+function monthLabelFormatter(locale) {
+  const options = { month: "long", year: "numeric" };
+  try {
+    return new Intl.DateTimeFormat(locale, options);
+  } catch (error) {
+    if (!(error instanceof RangeError)) throw error;
+    return new Intl.DateTimeFormat("en", options);
+  }
+}
 
 // src/controllers/calendar_controller.ts
 var OWNED_DISABLED = "data-stimeo--calendar-owns-disabled";
@@ -2070,8 +2079,7 @@ var CalendarController = class extends Controller {
     const month = monthStart.getMonth() + 1;
     if (this.hasLabelTarget) {
       const lang = document.documentElement.lang || "en";
-      const formatter = new Intl.DateTimeFormat(lang, { month: "long", year: "numeric" });
-      this.labelTarget.textContent = formatter.format(monthStart);
+      this.labelTarget.textContent = monthLabelFormatter(lang).format(monthStart);
     }
     const days = this.#calculateGridDays(year, month);
     const dayElements = this.dayTargets;
@@ -2323,7 +2331,7 @@ var CarouselController = class extends Controller {
   #handledEvents = /* @__PURE__ */ new WeakSet();
   /**
    * Whether `connect()` has run. Scheduling is already inert outside that window
-   * ({@link MicrotaskCoalescer}), so this gates the Value callbacks Stimulus
+   * (`MicrotaskCoalescer`), so this gates the Value callbacks Stimulus
    * delivers ahead of `connect()`.
    */
   #connected = false;
@@ -4383,7 +4391,7 @@ var CommandPaletteController = class _CommandPaletteController extends Controlle
    * re-deriving from the declarative `open` Value (which would slam a user-opened
    * palette shut). The `open` Value only seeds the initial state of a genuinely
    * fresh render. We normalize to a clean closed baseline first so {@link open}
-   * runs its full setup — the {@link FocusTrap} is a fresh instance after a
+   * runs its full setup — the `FocusTrap` is a fresh instance after a
    * reconnect and must be re-activated.
    */
   connect() {
@@ -4488,7 +4496,7 @@ var CommandPaletteController = class _CommandPaletteController extends Controlle
   }
   /**
    * Combobox navigation keys (arrows / Home / End / Enter), bound to the input.
-   * `Tab` (focus trap) and `Escape` (close) are owned by the {@link FocusTrap} at
+   * `Tab` (focus trap) and `Escape` (close) are owned by the shared `FocusTrap` at
    * the document level, so they work no matter which element inside the dialog has
    * focus — not only the input.
    */
@@ -5332,23 +5340,54 @@ var ContextMenuController = class extends Controller {
     return this.hasMenuTarget && !this.menuTarget.hidden;
   }
 };
+
+// src/utils/authored_integer.ts
+var TOKEN_BODY = /\d[\d.,'’’    _]*\d|\d/;
+var SIGN_OPENER = /[\s([]/;
+function authoredInteger(text) {
+  const firstDigit = /\d/.exec(text);
+  if (firstDigit === null) return null;
+  const at = firstDigit.index;
+  const signed = at > 0 && text[at - 1] === "-" && (at === 1 || SIGN_OPENER.test(text[at - 2]));
+  const body = TOKEN_BODY.exec(text.slice(at));
+  const runs = body[0].split(/\D+/);
+  const separators = body[0].match(/\D+/g) ?? [];
+  const lead = runs[0];
+  const heads = lead.length <= 3 && !lead.startsWith("0");
+  let digits = lead;
+  for (let i = 1; heads && i < runs.length; i += 1) {
+    if (separators[i - 1]?.length !== 1 || runs[i]?.length !== 3) break;
+    digits += runs[i];
+  }
+  const magnitude = Number.parseInt(digits, 10);
+  return signed ? -magnitude || 0 : magnitude;
+}
+
+// src/controllers/count_up_controller.ts
+var DEFAULT_DURATION = 1200;
 var CountUpController = class extends Controller {
   static values = {
-    duration: { type: Number, default: 1200 },
+    duration: { type: Number, default: DEFAULT_DURATION },
     from: { type: Number, default: 0 },
     once: { type: Boolean, default: true }
   };
   static actions = ["start"];
   static events = ["end"];
   #frame = null;
-  /** The authored final text, restored verbatim when the run settles. */
-  #finalText = "";
+  /** The animation length, with a declaration outside its domain read as the default. */
+  get #duration() {
+    return Number.isFinite(this.durationValue) && this.durationValue > 0 ? this.durationValue : DEFAULT_DURATION;
+  }
+  /** The starting value, with a declaration that is not a finite number read as zero. */
+  get #from() {
+    return Number.isFinite(this.fromValue) ? this.fromValue : 0;
+  }
   connect() {
-    if (this.element.hasAttribute("data-count-up-label")) {
-      this.element.textContent = this.element.getAttribute("aria-label") ?? this.element.textContent;
-      this.#restoreLabel();
-      this.element.setAttribute("data-count-up-done", "true");
-    }
+    const ticker = this.#ownedTicker();
+    if (ticker === null) return;
+    const authored = ticker.getAttribute("aria-label");
+    this.#unwrap(ticker, authored);
+    if (authored !== null) this.element.setAttribute("data-count-up-done", "true");
   }
   disconnect() {
     if (this.#frame !== null) this.#settle();
@@ -5360,27 +5399,22 @@ var CountUpController = class extends Controller {
   start() {
     if (this.#frame !== null) return;
     if (this.onceValue && this.element.hasAttribute("data-count-up-done")) return;
-    this.#finalText = this.element.textContent ?? "";
-    const target = Number.parseInt(this.#finalText.replace(/[^0-9-]/g, ""), 10);
-    if (Number.isNaN(target)) return;
+    const node = this.#numericNode();
+    if (node === null) return;
+    const authored = node.data;
+    const target = authoredInteger(authored);
     if (prefersReducedMotion()) {
       this.element.setAttribute("data-count-up-done", "true");
       this.dispatch("end", { detail: { value: target } });
       return;
     }
-    const authored = this.element.getAttribute("aria-label");
-    if (authored !== null) {
-      this.element.setAttribute("data-count-up-original-label", authored);
-    }
-    this.element.setAttribute("data-count-up-label", "true");
-    this.element.setAttribute("aria-label", this.#finalText);
+    const ticker = this.#wrap(node, authored);
+    const from = this.#from;
     const started = performance.now();
     const step = (now) => {
-      const t = Math.min((now - started) / this.durationValue, 1);
+      const t = Math.min((now - started) / this.#duration, 1);
       const eased = 1 - (1 - t) ** 3;
-      this.element.textContent = String(
-        Math.round(this.fromValue + (target - this.fromValue) * eased)
-      );
+      ticker.textContent = String(Math.round(from + (target - from) * eased));
       if (t < 1) {
         this.#frame = requestAnimationFrame(step);
       } else {
@@ -5390,26 +5424,41 @@ var CountUpController = class extends Controller {
     };
     this.#frame = requestAnimationFrame(step);
   }
+  /** The first text node that displays a number, or null when the host has none. */
+  #numericNode() {
+    const walker = document.createTreeWalker(this.element, NodeFilter.SHOW_TEXT);
+    let node = walker.nextNode();
+    while (node !== null && authoredInteger(node.data) === null) {
+      node = walker.nextNode();
+    }
+    return node;
+  }
+  /** The wrapper this controller published, if one outlived its run. */
+  #ownedTicker() {
+    return this.element.querySelector("[data-count-up-label]");
+  }
+  /** Publishes the ticking number inside a named wrapper, replacing `node`. */
+  #wrap(node, authored) {
+    const ticker = document.createElement("span");
+    ticker.setAttribute("data-count-up-label", "true");
+    ticker.setAttribute("role", "img");
+    ticker.setAttribute("aria-label", authored);
+    node.replaceWith(ticker);
+    ticker.append(node);
+    return ticker;
+  }
+  /** Puts `text` back where the wrapper stood, leaving the rest of the host alone. */
+  #unwrap(ticker, text) {
+    ticker.replaceWith(document.createTextNode(text ?? ticker.textContent ?? ""));
+  }
   /** Ends the run: cancels the frame and restores the authored presentation. */
   #settle() {
     if (this.#frame !== null) cancelAnimationFrame(this.#frame);
     this.#frame = null;
-    this.element.textContent = this.#finalText;
-    this.#restoreLabel();
+    const ticker = this.#ownedTicker();
+    if (ticker !== null) this.#unwrap(ticker, ticker.getAttribute("aria-label"));
     this.element.setAttribute("data-count-up-done", "true");
   }
-  /** Releases the marker-owned aria-label, restoring any parked authored value. */
-  #restoreLabel() {
-    if (!this.element.hasAttribute("data-count-up-label")) return;
-    const original = this.element.getAttribute("data-count-up-original-label");
-    if (original !== null) {
-      this.element.setAttribute("aria-label", original);
-      this.element.removeAttribute("data-count-up-original-label");
-    } else {
-      this.element.removeAttribute("aria-label");
-    }
-    this.element.removeAttribute("data-count-up-label");
-  }
 };
 var SECOND_MS = 1e3;
 var CountdownController = class extends Controller {
@@ -6525,7 +6574,7 @@ var DateRangePickerController = class extends Controller {
     if (this.#previewDate && !this.#isSelectable(this.#previewDate)) this.#previewDate = "";
     if (this.hasMonthLabelTarget) {
       const lang = document.documentElement.lang || "en";
-      const formatter = monthFormatter(lang);
+      const formatter = monthLabelFormatter(lang);
       this.monthLabelTarget.textContent = formatter.format(new Date(year, month - 1, 1));
     }
     const [rangeStart, rangeEnd] = this.#visualRange();
@@ -6680,15 +6729,6 @@ function normalizeISO(value) {
 function orderRange(start, end) {
   return start && end && end < start ? [end, start] : [start, end];
 }
-function monthFormatter(locale) {
-  const options = { month: "long", year: "numeric" };
-  try {
-    return new Intl.DateTimeFormat(locale, options);
-  } catch (error) {
-    if (!(error instanceof RangeError)) throw error;
-    return new Intl.DateTimeFormat("en", options);
-  }
-}
 function computePreset(name) {
   const today = /* @__PURE__ */ new Date();
   const todayStr = toISODateString(today);
@@ -7370,7 +7410,7 @@ var DrawerController = class extends Controller {
    * rather than being re-derived from the declarative `open` Value (which would
    * close a user-opened drawer). The `open` Value only seeds a genuinely fresh
    * render. We normalize to a clean closed baseline first so {@link open} runs its
-   * full reveal + trap activation — the {@link FocusTrap} is inactive after a
+   * full reveal + trap activation — the `FocusTrap` is inactive after a
    * disconnect and must be re-activated.
    */
   connect() {
@@ -7503,7 +7543,7 @@ var DrawerController = class extends Controller {
    * Runs once the close transition has finished: applies `hidden` to the panel
    * and overlay, then reverts the modal side effects (scroll lock, background
    * `inert`, keydown listener) and restores focus to the opener. Deferring the
-   * {@link FocusTrap} teardown to here — rather than at {@link close} time — keeps
+   * `FocusTrap` teardown to here — rather than at {@link close} time — keeps
    * the background unreachable and focus trapped for the whole exit animation.
    */
   #applyHidden(panel) {
@@ -10193,6 +10233,14 @@ function isBeforeRootStart(entry) {
   const rootTop = entry.rootBounds?.top ?? 0;
   return rect.bottom <= rootTop;
 }
+function queryRoot(selector) {
+  if (!selector) return null;
+  try {
+    return document.querySelector(selector);
+  } catch {
+  }
+  return null;
+}
 var IntersectionWatcher = class {
   #onEntries;
   #observer = null;
@@ -10214,7 +10262,10 @@ var IntersectionWatcher = class {
    * the watcher inert — without `IntersectionObserver` support (very old
    * browsers; the caller's no-JS fallback stays in charge) or with no targets.
    * If initial construction with the configured options fails, the watcher
-   * warns and retries once with the same root and platform defaults.
+   * warns and retries once with the same root and platform defaults. A
+   * `rootSelector` that does not parse resolves to the viewport (see
+   * {@link IntersectionWatchOptions.rootSelector}), so a typo never fails the
+   * call.
    *
    * @throws The fallback constructor error if both construction attempts fail,
    *   or whatever the platform throws from `observe()`. The exception is passed
@@ -10227,7 +10278,7 @@ var IntersectionWatcher = class {
     if (typeof IntersectionObserver === "undefined") return false;
     const list = Array.isArray(targets) ? targets : [targets];
     if (list.length === 0) return false;
-    const root = "root" in options ? options.root ?? null : options.rootSelector ? document.querySelector(options.rootSelector) : null;
+    const root = "root" in options ? options.root ?? null : queryRoot(options.rootSelector);
     let observer = null;
     try {
       const onEntries = (entries) => {
@@ -10320,6 +10371,25 @@ var IntersectionController = class extends Controller {
   }
   connect() {
     if (this.onceValue && this.element.getAttribute("data-intersecting") === "true") return;
+    this.#observe();
+  }
+  disconnect() {
+    this.#watcher.stop();
+  }
+  /**
+   * Re-reads the visibility line and rebuilds the observer. Turbo 8 morphing
+   * rewrites the attribute in place without a reconnect, and the line is what
+   * the intersection callback compares every ratio against, so a value frozen at
+   * connect time would decide `data-intersecting` wrongly for the rest of the
+   * page's life. Nothing to rebuild before the first `connect()`; after a spent
+   * one-shot the watcher is deliberately stopped, and re-observing would deliver
+   * the current state and fire `enter` a second time.
+   */
+  thresholdValueChanged() {
+    if (this.#watcher.active) this.#observe();
+  }
+  /** (Re)installs the observer from the current Values. */
+  #observe() {
     this.#effectiveThreshold = this.#clampedThreshold();
     this.#watcher.start(this.element, {
       rootSelector: this.rootSelectorValue,
@@ -10328,9 +10398,6 @@ var IntersectionController = class extends Controller {
     });
     if (this.#watcher.usingPlatformDefaults) this.#effectiveThreshold = 0;
   }
-  disconnect() {
-    this.#watcher.stop();
-  }
   /**
    * Re-delivers the current intersection state as a fresh transition. Bound via
    * `data-action` (e.g. `my-feed:appended@window->stimeo--intersection#refresh`).
@@ -10361,14 +10428,29 @@ var IntersectionController = class extends Controller {
     const previous = this.element.getAttribute("data-intersecting");
     this.element.setAttribute("data-intersecting", intersecting ? "true" : "false");
     if (intersecting && previous !== "true") {
-      this.dispatch("enter", { detail: { ratio } });
       if (this.onceValue) this.#watcher.stop();
+      this.dispatch("enter", { detail: { ratio } });
     } else if (!intersecting && previous === "true") {
       this.dispatch("exit", {
-        detail: { ratio, position: isBeforeRootStart(entry) ? "before" : "after" }
+        detail: { ratio, position: this.#leftViaStartEdge(entry) ? "before" : "after" }
       });
     }
   }
+  /**
+   * Which edge the element left across, for the `exit` detail. A non-zero
+   * `threshold` withdraws visibility while the element still overlaps the root,
+   * so the leaving rect can straddle the start edge — the direction is the
+   * element's own top against that edge, not whether it has cleared the root
+   * entirely (that is what `passed` reports). An element with no layout box
+   * (`display: none`, a collapsed `<details>`) is reported with an empty rect
+   * that carries no position at all, so it is deliberately neither direction
+   * and takes the "still ahead" reading.
+   */
+  #leftViaStartEdge(entry) {
+    const rect = entry.boundingClientRect;
+    if (rect.width === 0 && rect.height === 0) return false;
+    return rect.top < (entry.rootBounds?.top ?? 0);
+  }
   /**
    * Reflects the "scrolled past" state onto `data-passed` and fires `passed` on
    * transitions — the line sticky headers and reading progress key off. Like
@@ -10388,9 +10470,14 @@ var IntersectionController = class extends Controller {
   /**
    * Observer thresholds: the `threshold` line itself, plus `ratioSteps` evenly
    * spaced steps when fine-grained `change` ratios are wanted (progress bars).
+   *
+   * 0 is always observed. An observer notifies only at the lines it was given,
+   * so a non-zero `threshold` on its own delivers its last callback while the
+   * element is still partly visible: the element leaving for good would never be
+   * reported, freezing the ratio and `data-passed` mid-departure.
    */
   #thresholds() {
-    const thresholds = /* @__PURE__ */ new Set([this.#clampedThreshold()]);
+    const thresholds = /* @__PURE__ */ new Set([0, this.#clampedThreshold()]);
     if (this.ratioStepsValue > 0) {
       for (let i = 0; i <= this.ratioStepsValue; i += 1) {
         thresholds.add(i / this.ratioStepsValue);
@@ -10408,47 +10495,98 @@ var LazyFrameController = class extends Controller {
   static events = ["load"];
   /** Shared IO plumbing (support guard, active guard, teardown). */
   #watcher = new IntersectionWatcher((entries) => this.#onIntersect(entries));
+  #connected = false;
   #loaded = false;
-  /** Focus reaching the frame triggers the load before it intersects (keyboard / AT). */
-  #onFocus = () => this.#trigger();
+  /**
+   * Whether the observer last saw the frame inside the observed area — `null`
+   * until it has reported. A re-entry needs a frame that was seen inside and
+   * then left, so an unknown position is never a departure.
+   */
+  #inside = null;
+  /**
+   * Focus reaching the frame starts the FIRST load before it intersects (keyboard / AT).
+   * `#load` releases this listener, so focus never reaches an already-loaded frame.
+   */
+  #onFocus = () => this.#load();
+  /**
+   * Follows the held URL at runtime: one that arrives arms the frame, one that is
+   * taken away disarms it, so an empty `url` holds no triggers either way.
+   *
+   * Stimulus runs value callbacks before `connect()`, so the connected guard keeps
+   * arming in one place. A frame that already loaded keeps its held URL for the next
+   * re-entry instead of fetching on the spot.
+   */
+  urlValueChanged() {
+    if (!this.#connected || this.#loaded) return;
+    if (this.urlValue) this.#arm();
+    else this.#stopObserving();
+  }
+  /** Rebuilds the observer when the early-load margin changes at runtime. */
+  rootMarginValueChanged() {
+    if (this.#connected && this.#watcher.active) this.#observe();
+  }
   connect() {
-    if (this.element.hasAttribute("data-lazy-loaded")) {
-      this.#loaded = true;
-      return;
-    }
-    if (!this.urlValue) return;
-    this.element.addEventListener("focusin", this.#onFocus);
-    this.#watcher.start(this.element, { rootMargin: this.rootMarginValue });
+    this.#loaded = this.element.hasAttribute("data-lazy-loaded");
+    this.#inside = null;
+    this.#connected = true;
+    if (this.#loaded && this.onceValue) return;
+    this.#arm();
   }
   disconnect() {
+    this.#connected = false;
     this.#stopObserving();
   }
+  /** Attaches the triggers that still have a job to do. */
+  #arm() {
+    if (!this.urlValue) return;
+    if (!this.#loaded) this.element.addEventListener("focusin", this.#onFocus);
+    this.#observe();
+  }
+  #observe() {
+    this.#watcher.start(this.element, { rootMargin: this.rootMarginValue });
+  }
   #onIntersect(entries) {
     for (const entry of entries) {
       if (entry.isIntersecting) {
-        this.#trigger();
-        return;
+        const returning = this.#inside === false;
+        this.#inside = true;
+        this.#enter(returning);
+      } else if (this.#inside) {
+        this.#inside = false;
       }
     }
   }
-  #trigger() {
-    if (!this.#loaded) this.#load();
-    else if (!this.onceValue) this.#reload();
+  /** Applies an intersecting entry: the first one loads, a return re-fetches. */
+  #enter(returning) {
+    if (!this.#loaded) {
+      this.#load();
+      return;
+    }
+    if (this.onceValue || !returning) return;
+    this.#reload();
   }
   /** Starts the load by writing the held URL to `src`. */
   #load() {
+    if (!this.urlValue) return;
     this.#loaded = true;
     this.element.setAttribute("src", this.urlValue);
     this.element.setAttribute("data-lazy-loaded", "true");
     this.dispatch("load", { detail: { url: this.urlValue } });
-    if (this.onceValue) this.#stopObserving();
+    this.element.removeEventListener("focusin", this.#onFocus);
+    if (this.onceValue) this.#watcher.stop();
   }
-  /** Re-entry while `once` is off: ask Turbo to reload the frame's current `src`. */
+  /** Re-entry while `once` is off: fetch the held URL again. */
   #reload() {
+    const src = this.element.getAttribute("src");
+    if (this.urlValue && this.urlValue !== src) {
+      this.element.setAttribute("src", this.urlValue);
+      this.dispatch("load", { detail: { url: this.urlValue } });
+      return;
+    }
     const frame = this.element;
     if (typeof frame.reload !== "function") return;
     frame.reload();
-    this.dispatch("load", { detail: { url: this.urlValue } });
+    this.dispatch("load", { detail: { url: src ?? "" } });
   }
   #stopObserving() {
     this.#watcher.stop();
@@ -14082,32 +14220,58 @@ var NumberInputController = class _NumberInputController extends Controller {
     this.#ariaValueMax.returnAll();
   }
 };
-var TOGGLED_MARKER = "data-optimistic-toggled";
+var HIDDEN_MARKER = "data-optimistic-toggled";
+var BUSY_MARKER = "data-optimistic-busy";
+var AUTHORED_ABSENT = "absent";
+var AUTHORED_VALUE = "value:";
+var SYNTHETIC_SUBMISSION = {};
+function submissionOf(event) {
+  const detail = event.detail;
+  return detail?.formSubmission ?? SYNTHETIC_SUBMISSION;
+}
 var OptimisticController = class extends Controller {
   static targets = ["show", "hide"];
   static events = ["commit", "rollback"];
+  /** The submission that owns the applied optimistic state, if any. */
+  #pending = null;
+  #gate = new DetachGate();
+  /** True between `connect()` and `disconnect()`, so a repeat connect rewinds nothing. */
+  #connected = false;
   connect() {
-    if (this.element.hasAttribute("data-optimistic")) this.#revert();
+    const restored = !this.#connected && !this.#gate.pending;
+    this.#gate.cancel();
+    this.#connected = true;
+    if (restored && this.element.hasAttribute("data-optimistic")) this.#revert();
     this.element.addEventListener("turbo:submit-start", this.#onSubmitStart);
     this.element.addEventListener("turbo:submit-end", this.#onSubmitEnd);
   }
   disconnect() {
+    this.#connected = false;
     this.element.removeEventListener("turbo:submit-start", this.#onSubmitStart);
     this.element.removeEventListener("turbo:submit-end", this.#onSubmitEnd);
+    this.#gate.disconnected(this, () => {
+      this.#pending = null;
+    });
   }
-  #onSubmitStart = () => {
+  #onSubmitStart = (event) => {
+    this.#pending = submissionOf(event);
+    if (this.element instanceof HTMLFormElement && !this.element.hasAttribute(BUSY_MARKER)) {
+      this.element.setAttribute(BUSY_MARKER, AUTHORED_ABSENT);
+    }
+    this.#write(this.element, "aria-busy", "true", BUSY_MARKER);
     this.element.setAttribute("data-optimistic", "true");
-    this.element.setAttribute("aria-busy", "true");
-    for (const target of this.showTargets) this.#toggleHidden(target, false);
-    for (const target of this.hideTargets) this.#toggleHidden(target, true);
+    for (const target of this.showTargets) this.#setHidden(target, false);
+    for (const target of this.hideTargets) this.#setHidden(target, true);
   };
   #onSubmitEnd = (event) => {
+    if (submissionOf(event) !== this.#pending) return;
+    this.#pending = null;
     const success = event.detail?.success === true;
-    this.element.removeAttribute("aria-busy");
     if (success) {
       this.element.removeAttribute("data-optimistic");
+      this.#restore(this.element, "aria-busy", BUSY_MARKER, "true");
       for (const target of [...this.showTargets, ...this.hideTargets]) {
-        target.removeAttribute(TOGGLED_MARKER);
+        target.removeAttribute(HIDDEN_MARKER);
       }
       this.dispatch("commit");
     } else {
@@ -14115,21 +14279,59 @@ var OptimisticController = class extends Controller {
       this.dispatch("rollback");
     }
   };
-  /** Sets `hidden` only when it actually changes, marker-tracking the mutation. */
-  #toggleHidden(target, hidden) {
-    if (target.hidden === hidden) return;
-    target.hidden = hidden;
-    target.setAttribute(TOGGLED_MARKER, "true");
+  /** Hides or reveals a target, recording the authored `hidden` on first write. */
+  #setHidden(target, hidden) {
+    if (target.hasAttribute("hidden") === hidden) return;
+    this.#write(target, "hidden", hidden ? "" : null, HIDDEN_MARKER);
+  }
+  /** Writes an attribute, recording what it displaced under `marker` once. */
+  #write(element, attribute, value, marker) {
+    if (!element.hasAttribute(marker)) {
+      const authored = element.getAttribute(attribute);
+      element.setAttribute(
+        marker,
+        authored === null ? AUTHORED_ABSENT : `${AUTHORED_VALUE}${authored}`
+      );
+    }
+    if (value === null) element.removeAttribute(attribute);
+    else element.setAttribute(attribute, value);
   }
-  /** Reverts exactly the mutations this controller made (marker-owned only). */
+  /**
+   * Puts back the value `marker` recorded and drops the record.
+   *
+   * `written` is what this controller last put in the attribute. Anything else
+   * there now belongs to whoever wrote it — Turbo owns `aria-busy` on a form and
+   * clears it before the terminal arrives, and a consumer may have moved a face
+   * mid-flight — so the record is dropped without touching the attribute. A
+   * marker this build did not write names no authored value, so the attribute
+   * goes back to being absent.
+   */
+  #restore(element, attribute, marker, written) {
+    const recorded = element.getAttribute(marker);
+    if (recorded === null) return;
+    element.removeAttribute(marker);
+    if (element.getAttribute(attribute) !== written) return;
+    if (recorded.startsWith(AUTHORED_VALUE)) {
+      element.setAttribute(attribute, recorded.slice(AUTHORED_VALUE.length));
+      return;
+    }
+    element.removeAttribute(attribute);
+  }
+  /**
+   * Puts back exactly the markup this controller displaced (record-owned only).
+   *
+   * A face can be registered on both sides, and the hide pass runs last, so what
+   * this controller wrote there is `hidden` — matching it against the reveal's
+   * absent value instead would read as someone else's write and leave the face
+   * hidden. Each target is therefore restored once, against the write it last
+   * received.
+   */
   #revert() {
     this.element.removeAttribute("data-optimistic");
-    this.element.removeAttribute("aria-busy");
-    for (const target of [...this.showTargets, ...this.hideTargets]) {
-      if (target.hasAttribute(TOGGLED_MARKER)) {
-        target.hidden = !target.hidden;
-        target.removeAttribute(TOGGLED_MARKER);
-      }
+    this.#restore(this.element, "aria-busy", BUSY_MARKER, "true");
+    const hidden = new Set(this.hideTargets);
+    for (const target of /* @__PURE__ */ new Set([...this.showTargets, ...this.hideTargets])) {
+      this.#restore(target, "hidden", HIDDEN_MARKER, hidden.has(target) ? "" : null);
     }
   }
 };
@@ -16480,6 +16682,10 @@ var PointerDragController = class _PointerDragController extends Controller {
       return;
     }
     if (!this.#keyboard) return;
+    if (event.key === "Home" || event.key === "End") {
+      event.preventDefault();
+      return;
+    }
     const step = this.#keyboardDelta(event.key);
     if (!step) return;
     event.preventDefault();
@@ -18373,9 +18579,16 @@ var ReadMoreController = class extends Controller {
 var PROGRESS_PROPERTY = "--stimeo--reading-progress";
 var ReadingProgressController = class extends Controller {
   static events = ["change", "complete"];
+  /** Owns both faces of the published property so teardown can hand them back. */
+  #lease = new StylePropertyLease(PROGRESS_PROPERTY);
+  /** The article's own box and the viewport: either changes the span. */
+  #layout = new LayoutObserver(() => this.#onScroll());
+  #beforeCache = new BeforeCacheReset(() => this.#rewindForCache());
   #frame = null;
   /** Last published progress, so `change`/`complete` fire only on movement. */
   #progress = -1;
+  /** False until the connect frame has run: `complete` needs real reading. */
+  #baselined = false;
   #onScroll = () => {
     if (this.#frame !== null) return;
     this.#frame = requestAnimationFrame(() => {
@@ -18385,20 +18598,45 @@ var ReadingProgressController = class extends Controller {
   };
   connect() {
     this.#progress = -1;
+    this.#baselined = false;
     window.addEventListener("scroll", this.#onScroll, { passive: true, capture: true });
-    window.addEventListener("resize", this.#onScroll, { passive: true });
+    this.#layout.observe(this.element);
+    this.#layout.observeViewport();
+    this.#beforeCache.activate();
     this.#measure();
+    this.#frame = requestAnimationFrame(() => {
+      this.#frame = null;
+      this.#measure();
+      this.#baselined = true;
+    });
   }
   disconnect() {
     window.removeEventListener("scroll", this.#onScroll, { capture: true });
-    window.removeEventListener("resize", this.#onScroll);
+    this.#layout.disconnect();
+    this.#beforeCache.deactivate();
+    this.#cancelFrame();
+    this.#lease.returnAll();
+  }
+  /**
+   * Hands both declarations back before the page is snapshotted, so a restored
+   * page starts from the authored DOM rather than from someone else's progress.
+   * The baseline goes back with them: a cancelled visit leaves this page on
+   * screen, and the next measurement has to publish afresh rather than match a
+   * value that has already been handed back.
+   */
+  #rewindForCache() {
+    this.#cancelFrame();
+    this.#lease.returnAll();
+    this.#progress = -1;
+  }
+  #cancelFrame() {
     if (this.#frame !== null) cancelAnimationFrame(this.#frame);
     this.#frame = null;
-    document.documentElement.style.removeProperty(PROGRESS_PROPERTY);
   }
   /** Computes and publishes the progress; emits on movement only. */
   #measure() {
     const rect = this.element.getBoundingClientRect();
+    if (rect.width === 0 && rect.height === 0) return;
     const span = rect.height - window.innerHeight;
     const raw = span > 0 ? -rect.top / span : rect.top <= 0 ? 1 : 0;
     const progress = Math.min(1, Math.max(0, raw));
@@ -18406,10 +18644,10 @@ var ReadingProgressController = class extends Controller {
     const previous = this.#progress;
     this.#progress = progress;
     const value = String(progress);
-    this.element.style.setProperty(PROGRESS_PROPERTY, value);
-    document.documentElement.style.setProperty(PROGRESS_PROPERTY, value);
+    this.#lease.write(this.element, value);
+    this.#lease.write(document.documentElement, value);
     this.dispatch("change", { detail: { progress } });
-    if (progress === 1 && previous !== -1) this.dispatch("complete");
+    if (progress === 1 && previous !== -1 && this.#baselined) this.dispatch("complete");
   }
 };
 var YEAR_SCALE = { limit: Number.POSITIVE_INFINITY, unit: "year", ms: 315576e5 };
@@ -20933,19 +21171,32 @@ var SliderController = class extends Controller {
     drag?.pointer?.end();
   }
 };
+var DEFAULT_OFFSET2 = 80;
 var SmartStickyHeaderController = class extends Controller {
   static values = {
     containerSelector: { type: String, default: "" },
-    offset: { type: Number, default: 80 },
+    offset: { type: Number, default: DEFAULT_OFFSET2 },
     tolerance: { type: Number, default: 4 }
   };
   static events = ["change"];
+  #connected = false;
   #frame = null;
   /** The scroll source resolved at connect — disconnect must unbind the SAME node. */
   #scrollerEl = window;
+  /** The validated `containerSelector`, or `""` when the declaration cannot be parsed. */
+  #containerSelector = "";
   #lastY = 0;
   /** Last published state, so `change` fires only on transitions. */
   #hidden = null;
+  /**
+   * The depth that never hides. A declaration that is not a finite number reads
+   * as the default, so the comparison path never sees `NaN` — which would
+   * answer `false` to every comparison and hide the header inside the very
+   * zone the value exists to protect.
+   */
+  get #offset() {
+    return Number.isFinite(this.offsetValue) ? this.offsetValue : DEFAULT_OFFSET2;
+  }
   #onScroll = () => {
     if (this.#frame !== null) return;
     this.#frame = requestAnimationFrame(() => {
@@ -20958,15 +21209,25 @@ var SmartStickyHeaderController = class extends Controller {
    * hold while focus *stays* inside is the `#apply` hide invariant.
    */
   #onFocusin = () => this.#apply(false);
+  /** Validates `containerSelector` once so connect never parses a selector that throws. */
+  containerSelectorValueChanged() {
+    this.#containerSelector = this.#validSelector(this.containerSelectorValue);
+  }
+  /** Re-decides when application code (or a Turbo morph) changes `offset` at runtime. */
+  offsetValueChanged() {
+    if (this.#connected) this.#measure();
+  }
   connect() {
     this.#hidden = null;
     this.#scrollerEl = this.#resolveScroller();
     this.#lastY = this.#scrollY;
     this.#scrollerEl.addEventListener("scroll", this.#onScroll, { passive: true });
     this.element.addEventListener("focusin", this.#onFocusin);
-    this.#apply(false);
+    this.#apply(false, false);
+    this.#connected = true;
   }
   disconnect() {
+    this.#connected = false;
     this.#scrollerEl.removeEventListener("scroll", this.#onScroll);
     this.element.removeEventListener("focusin", this.#onFocusin);
     if (this.#frame !== null) cancelAnimationFrame(this.#frame);
@@ -20974,43 +21235,69 @@ var SmartStickyHeaderController = class extends Controller {
   }
   /** Resolves the scroll source: the `containerSelector` match, else the window. */
   #resolveScroller() {
-    if (this.containerSelectorValue) {
-      const container = document.querySelector(this.containerSelectorValue);
+    if (this.#containerSelector) {
+      const container = document.querySelector(this.#containerSelector);
       if (container) return container;
     }
     return window;
   }
+  /** Returns `declared` when it parses as a selector, and `""` when it does not. */
+  #validSelector(declared) {
+    if (declared.length > 0) {
+      try {
+        this.element.matches(declared);
+        return declared;
+      } catch {
+      }
+    }
+    return "";
+  }
   get #scrollY() {
     const scroller = this.#scrollerEl;
     return scroller === window ? window.scrollY : scroller.scrollTop;
   }
   #measure() {
     const y = this.#scrollY;
+    if (y <= this.#offset) {
+      this.#lastY = y;
+      this.#apply(false);
+      return;
+    }
     const delta = y - this.#lastY;
     if (Math.abs(delta) < this.toleranceValue) return;
     this.#lastY = y;
-    if (y <= this.offsetValue) this.#apply(false);
-    else if (delta > 0) this.#apply(true);
-    else this.#apply(false);
+    this.#apply(delta > 0);
   }
-  /** Reflects the state onto the hook and emits `change` on transitions. */
-  #apply(hidden) {
+  /**
+   * Reflects the state onto the hook and emits `change` on transitions.
+   *
+   * @param notify - whether a transition announces itself. The reflection
+   *   `connect()` performs is the current state, not a change.
+   */
+  #apply(hidden, notify = true) {
     if (hidden && this.element.contains(document.activeElement)) return;
     if (hidden === this.#hidden) return;
     this.#hidden = hidden;
     this.element.setAttribute("data-header-hidden", hidden ? "true" : "false");
-    this.dispatch("change", { detail: { hidden } });
+    if (notify) this.dispatch("change", { detail: { hidden } });
   }
 };
 var SortableController = class extends Controller {
-  static targets = ["list", "item", "status"];
+  static targets = ["list", "item"];
   static values = {
-    orientation: { type: String, default: "vertical" }
+    orientation: { type: String, default: "vertical" },
+    announceGrabbedText: { type: String, default: "" },
+    announceMovedText: { type: String, default: "" },
+    announceDroppedText: { type: String, default: "" },
+    announceCanceledText: { type: String, default: "" }
   };
   static events = ["reorder"];
   #session = null;
+  /** Defers the lost-item check to after the mutation batch (see below). */
+  #settle = new MicrotaskCoalescer(() => this.#dropLostSession());
   connect() {
     this.element.removeAttribute("data-sortable-dragging");
+    this.#settle.activate();
     this.element.addEventListener("stimeo--pointer-drag:start", this.#onDragStart);
     this.element.addEventListener("stimeo--pointer-drag:move", this.#onDragMove);
     this.element.addEventListener("stimeo--pointer-drag:end", this.#onDragEnd);
@@ -21021,49 +21308,121 @@ var SortableController = class extends Controller {
     this.element.removeEventListener("stimeo--pointer-drag:move", this.#onDragMove);
     this.element.removeEventListener("stimeo--pointer-drag:end", this.#onDragEnd);
     this.element.removeEventListener("stimeo--pointer-drag:cancel", this.#onDragCancel);
+    this.#settle.cancel();
+    this.#session = null;
+    this.element.removeAttribute("data-sortable-dragging");
+  }
+  /**
+   * Ends a session whose item left the item set.
+   *
+   * The controller's own reorder detaches and reattaches the item inside one
+   * mutation batch, so the loss is only real once the batch has settled — the
+   * check therefore runs a microtask later and asks whether the item is a target
+   * again. Without it a deleted row (a broadcast that drops it from the board)
+   * or a morph that strips the item's target attribute would hold the
+   * one-at-a-time session for the rest of the page's life, with the root hook
+   * stuck on and every later grab refused with no way out.
+   */
+  itemTargetDisconnected(item) {
+    if (this.#session?.item !== item) return;
+    this.#settle.schedule();
+  }
+  #dropLostSession() {
+    const session = this.#session;
+    if (!session) return;
+    const items = this.#items();
+    if (items.includes(session.item)) return;
     this.#session = null;
     this.element.removeAttribute("data-sortable-dragging");
+    if (session.item.isConnected) this.#restore(session, items);
   }
-  /** Picks the item up: remembers its origin and announces the grab. */
+  /** Picks the item up: remembers its neighbours and announces the grab. */
   #onDragStart = (event) => {
     if (this.#session) return;
-    const item = this.#itemFor(event.target);
+    const items = this.#items();
+    const item = this.#itemFor(event.target, items);
     if (!item) return;
-    this.#session = { item, from: this.#items().indexOf(item), lastPrimary: 0 };
+    const index = items.indexOf(item);
+    this.#session = {
+      item,
+      anchor: items[index + 1] ?? null,
+      predecessor: items[index - 1] ?? null,
+      lastPrimary: 0
+    };
     this.element.setAttribute("data-sortable-dragging", "true");
     this.#announce("grabbed", item);
   };
   #onDragMove = (event) => {
     const session = this.#session;
+    if (!session) return;
+    const items = this.#items();
+    if (this.#itemFor(event.target, items) !== session.item) return;
     const detail = event.detail;
-    if (!session || this.#itemFor(event.target) !== session.item) return;
     if (detail.pointerType === "keyboard") {
-      this.#stepFromKeyboard(session, detail);
+      this.#stepFromKeyboard(session, detail, items);
     } else {
-      this.#followPointer(session, detail);
+      this.#followPointer(session, detail, items);
     }
   };
   /** Drops the item: announces, then reports `reorder` if the position changed. */
   #onDragEnd = (event) => {
     const session = this.#session;
-    if (!session || this.#itemFor(event.target) !== session.item) return;
+    if (!session) return;
+    const items = this.#items();
+    if (this.#itemFor(event.target, items) !== session.item) return;
     this.#session = null;
     this.element.removeAttribute("data-sortable-dragging");
     this.#announce("dropped", session.item);
-    const to = this.#items().indexOf(session.item);
-    if (to !== session.from) {
-      this.dispatch("reorder", { detail: { item: session.item, from: session.from, to } });
+    const to = items.indexOf(session.item);
+    const from = this.#pickupSlot(session, items) ?? to;
+    if (to !== from) {
+      this.dispatch("reorder", { detail: { item: session.item, from, to } });
     }
   };
   /** Restores the pickup position (Escape / OS `pointercancel`). */
   #onDragCancel = (event) => {
     const session = this.#session;
-    if (!session || this.#itemFor(event.target) !== session.item) return;
+    if (!session) return;
+    const items = this.#items();
+    if (this.#itemFor(event.target, items) !== session.item) return;
     this.#session = null;
     this.element.removeAttribute("data-sortable-dragging");
-    this.#moveTo(session.item, session.from);
+    this.#restore(session, items);
     this.#announce("canceled", session.item);
   };
+  /**
+   * The slot the item was picked up from, read back through the neighbours it
+   * had then — `null` when neither survives and the item itself is gone.
+   *
+   * The anchor is the item that followed it, so restoring means "before that one
+   * again". When the anchor was deleted mid-drag the predecessor answers the
+   * same question from the other side. With both gone the item's current slot is
+   * the honest answer: nothing is known to have moved, so no reorder is reported
+   * and a cancel leaves the item where it is.
+   */
+  #pickupSlot(session, items) {
+    const others = items.filter((candidate) => candidate !== session.item);
+    if (session.anchor) {
+      const at = others.indexOf(session.anchor);
+      if (at !== -1) return at;
+    }
+    if (session.predecessor) {
+      const at = others.indexOf(session.predecessor);
+      if (at !== -1) return at + 1;
+    }
+    const here = items.indexOf(session.item);
+    return here === -1 ? null : here;
+  }
+  /** Puts the item back where it was picked up from. */
+  #restore(session, items) {
+    const slot = this.#pickupSlot(session, items);
+    if (slot === null) return;
+    this.#insertAt(
+      session.item,
+      items.filter((candidate) => candidate !== session.item),
+      slot
+    );
+  }
   /**
    * Keyboard stepping: `pointer-drag` reports *cumulative* synthetic deltas, so
    * the difference from the last consumed value is one arrow press — its sign is
@@ -21075,77 +21434,116 @@ var SortableController = class extends Controller {
    * `roving` already moves focus logically, so the same arrow would send the
    * focus and the grabbed item opposite ways.
    */
-  #stepFromKeyboard(session, detail) {
+  #stepFromKeyboard(session, detail, items) {
     const primary = Number(this.#isVertical ? detail.dy : detail.dx) || 0;
     const delta = primary - session.lastPrimary;
     session.lastPrimary = primary;
     if (delta === 0) return;
-    const items = this.#items();
     const index = items.indexOf(session.item);
     const step = (delta > 0 ? 1 : -1) * (this.#isReversed ? -1 : 1);
     const next = Math.max(0, Math.min(index + step, items.length - 1));
     if (next === index) return;
-    this.#moveTo(session.item, next);
+    this.#insertAt(
+      session.item,
+      items.filter((candidate) => candidate !== session.item),
+      next
+    );
     this.#announce("moved", session.item);
   }
   /**
    * Pointer following: the item moves to the slot whose siblings' midpoints the
-   * pointer has passed (per `orientation`). Skipped when the list has no layout
-   * geometry (every rect is zero — nothing meaningful to compare against).
-   */
-  #followPointer(session, detail) {
+   * pointer has passed (per `orientation`).
+   *
+   * Only siblings that occupy space take part. A row with no layout box — a
+   * filtered-out item, a `display: none` ancestor, a collapsed `<details>` — is
+   * reported with an empty rect at the document origin, and its midpoint of `0`
+   * sits below every pointer position: counted, it would read as passed on the
+   * very first move and send the item across a slot the pointer never crossed.
+   * With no laid-out sibling at all there is nothing to compare against and the
+   * move is skipped entirely.
+   */
+  #followPointer(session, detail, items) {
     const pointer = Number(this.#isVertical ? detail.y : detail.x) || 0;
-    const others = this.#items().filter((item) => item !== session.item);
-    if (others.length === 0) return;
-    let laidOut = false;
-    let target = 0;
+    const vertical = this.#isVertical;
     const reversed = this.#isReversed;
-    for (const other of others) {
-      const rect = other.getBoundingClientRect();
-      if (rect.width > 0 || rect.height > 0) laidOut = true;
-      const midpoint = this.#isVertical ? rect.top + rect.height / 2 : rect.left + rect.width / 2;
-      const precedes = reversed ? pointer < midpoint : pointer > midpoint;
-      if (precedes) target += 1;
-    }
-    if (!laidOut) return;
-    const current = this.#items().indexOf(session.item);
-    if (target !== current) {
-      this.#moveTo(session.item, target);
-      this.#announce("moved", session.item);
-    }
-  }
-  /** Reinserts `item` so it lands at `index` among the list's items. */
-  #moveTo(item, index) {
-    const others = this.#items().filter((candidate) => candidate !== item);
-    const clamped = Math.max(0, Math.min(index, others.length));
-    const reference = others[clamped] ?? null;
+    const here = items.indexOf(session.item);
+    const laidOut = [];
+    let target = 0;
+    let current = 0;
+    items.forEach((item, index) => {
+      if (item === session.item) return;
+      const rect = item.getBoundingClientRect();
+      if (rect.width === 0 && rect.height === 0) return;
+      if (index < here) current += 1;
+      laidOut.push(item);
+      const midpoint = vertical ? rect.top + rect.height / 2 : rect.left + rect.width / 2;
+      if (reversed ? pointer < midpoint : pointer > midpoint) target += 1;
+    });
+    if (laidOut.length === 0 || target === current) return;
+    this.#insertAt(session.item, laidOut, target);
+    this.#announce("moved", session.item);
+  }
+  /**
+   * Reinserts `item` at `index` among `scope`, relative to the sibling already
+   * standing there.
+   *
+   * The reorder is defined against the items, not against a container: the
+   * neighbour's own parent is where the item belongs. A `list` target that is
+   * not the items' parent — or none at all, which the markup contract allows —
+   * therefore still lands the move in the right place instead of throwing, and
+   * the last slot is *after the last item* rather than after whatever else the
+   * container holds (a live region, a footer), which would put the row outside
+   * the reading order the list publishes.
+   */
+  #insertAt(item, scope, index) {
+    const clamped = Math.max(0, Math.min(index, scope.length));
+    const ahead = scope[clamped] ?? null;
+    const behind = ahead ? null : scope[scope.length - 1] ?? null;
+    const neighbour = ahead ?? behind;
+    if (!neighbour) return;
+    const parent = neighbour.parentNode;
+    if (!parent) return;
     const active = document.activeElement;
     const hadFocus = active instanceof HTMLElement && item.contains(active);
-    this.#list.insertBefore(item, reference);
+    parent.insertBefore(item, ahead ?? neighbour.nextSibling);
     if (hadFocus) active.focus();
   }
   /**
-   * Mirrors a step into the `status` live region. Copy is localizable through
-   * `data-grabbed` / `data-moved` / `data-dropped` / `data-canceled` templates on
-   * the status element (`%{name}` / `%{position}` / `%{total}` placeholders);
-   * terse English is the fallback.
+   * Hands one step to the page's shared announcer.
+   *
+   * The library carries no live region and no English copy: the wording is the
+   * consumer's, written into `announceGrabbedText` / `announceMovedText` /
+   * `announceDroppedText` / `announceCanceledText` with `{name}` / `{position}` /
+   * `{total}` placeholders, and an unset one announces nothing.
+   *
+   * Only transitions reach here — the pickup, a step that actually changed the
+   * landing slot, and the single end of the session — so a pointer crossing the
+   * same slot twice or an arrow clamped at an end stays silent.
    */
   #announce(key, item) {
-    if (!this.hasStatusTarget) return;
-    const position = String(this.#items().indexOf(item) + 1);
-    const total = String(this.#items().length);
-    const name = this.#nameOf(item);
-    const fallback = {
-      grabbed: `Grabbed ${name}, position ${position} of ${total}`,
-      moved: `${name}, position ${position} of ${total}`,
-      dropped: `Dropped ${name} at position ${position} of ${total}`,
-      canceled: `Reorder canceled, ${name} returned to position ${position} of ${total}`
-    };
-    const values = { name, position, total };
-    const template = this.statusTarget.dataset[key];
-    this.statusTarget.textContent = template ? template.replace(/%\{(name|position|total)\}/g, (match, token) => {
-      return values[token] ?? match;
-    }) : fallback[key];
+    const template = this.#announceTemplate(key);
+    if (template.length === 0) return;
+    const items = this.#items();
+    announce(
+      fillTemplate(template, {
+        name: this.#nameOf(item),
+        position: items.indexOf(item) + 1,
+        total: items.length
+      })
+    );
+  }
+  /** The consumer's wording for one step, or `""` when they authored none. */
+  #announceTemplate(key) {
+    switch (key) {
+      case "grabbed":
+        return this.announceGrabbedTextValue;
+      case "moved":
+        return this.announceMovedTextValue;
+      case "dropped":
+        return this.announceDroppedTextValue;
+      case "canceled":
+        return this.announceCanceledTextValue;
+    }
   }
   /** The announced item name: the authored override, else its collapsed text. */
   #nameOf(item) {
@@ -21153,11 +21551,17 @@ var SortableController = class extends Controller {
     if (authored) return authored;
     return (item.textContent ?? "").replace(/\s+/g, " ").trim();
   }
-  /** Resolves the sortable item owning a bubbled `pointer-drag` event. */
-  #itemFor(target) {
-    const node = target;
-    if (!node) return null;
-    return this.#items().find((item) => item === node || item.contains(node)) ?? null;
+  /**
+   * Resolves the sortable item owning a bubbled `pointer-drag` event.
+   *
+   * `pointer-drag` dispatches on its own element, and the markup contract puts
+   * one on each item, so the owner is the item that **is** the target. Matching
+   * an ancestor instead would make a card's own inner draggable — a knob, a
+   * split pane, anything the primitive is composed into — drive the card.
+   */
+  #itemFor(target, items) {
+    if (!target) return null;
+    return items.find((item) => item === target) ?? null;
   }
   /** The items in live DOM order (targets re-query the DOM on every access). */
   #items() {
@@ -23294,7 +23698,7 @@ var ToastController = class extends Controller {
   static events = ["dismiss", "show"];
   /**
    * Registry for every auto-dismiss and transition-finalize timer the controller
-   * schedules. {@link SafeTimeout} owns *registration and teardown only*; the
+   * schedules. `SafeTimeout` owns *registration and teardown only*; the
    * pause/resume remaining-time accounting stays in `#activeTimeouts` so the
    * per-widget WCAG 2.2.1 semantics are not flattened into the helper.
    */