stimeo-ui 0.16.0 → 0.18.0

package/dist/controllers/submit_once_controller.js

@@ -1,8 +1,5 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/submit_once_controller.ts
-
-// src/utils/announce.ts
 function announce(message, options = {}) {
   const text = message.trim();
   if (text.length === 0) return;
@@ -13,192 +10,352 @@ function announce(message, options = {}) {
   );
 }
 
-// src/utils/attribute_lease.ts
+function setAttributeIfChanged(element, name, value, beforeWrite) {
+  if (element.getAttribute(name) === value) return false;
+  if (value === null) element.removeAttribute(name);
+  else element.setAttribute(name, value);
+  return true;
+}
+
+function sharedRegistry(key, create) {
+  const symbol = Symbol.for(key);
+  const scope = globalThis;
+  const existing = scope[symbol];
+  if (existing !== void 0) return existing;
+  const registry2 = create();
+  Object.defineProperty(globalThis, symbol, { value: registry2 });
+  return registry2;
+}
+
+var registry = sharedRegistry(
+  "stimeo-ui.attribute-lease.registry.v1",
+  () => ({ stacks: /* @__PURE__ */ new WeakMap(), names: /* @__PURE__ */ new Map() })
+);
+function isAttributeValue(value) {
+  return value === null || typeof value === "string";
+}
+function readLeaseRecord(element, record) {
+  try {
+    const parsed = JSON.parse(element.getAttribute(record) ?? "null");
+    if (!Array.isArray(parsed)) return void 0;
+    const [original, written, ...rest] = parsed;
+    const linked = rest[0] !== false;
+    const beneath = linked ? rest : rest.slice(1);
+    if (!beneath.every((under) => typeof under === "string")) return void 0;
+    return isAttributeValue(original) && isAttributeValue(written) ? { original, written, linked, beneath } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function attributeStack(element, attribute) {
+  const byAttribute = registry.stacks.get(element) ?? /* @__PURE__ */ new Map();
+  registry.stacks.set(element, byAttribute);
+  const known = byAttribute.get(attribute);
+  if (known) return known;
+  const found = [];
+  for (const record of registry.names.get(attribute) ?? []) {
+    const read = readLeaseRecord(element, record);
+    if (read) found.push({ ...read, record });
+  }
+  const depth = ({ beneath }) => beneath.filter((name) => found.some((other) => other.record === name)).length;
+  const stack = found.sort((one, other) => depth(one) - depth(other)).map(({ record, written, original, linked }, index) => ({
+    lease: null,
+    record,
+    written,
+    original,
+    linked: linked && index > 0
+  }));
+  byAttribute.set(attribute, stack);
+  return stack;
+}
+function findHold(stack, lease, record) {
+  return stack.find((held) => held.lease === lease) ?? stack.find((held) => held.lease === null && held.record === record);
+}
 var AttributeLease = class {
   #attribute;
-  #records = /* @__PURE__ */ new Map();
-  /** @param attribute - The attribute whose temporary values this lease owns. */
-  constructor(attribute) {
+  #record;
+  #base;
+  #preserveAuthor;
+  #held = /* @__PURE__ */ new Set();
+  constructor(attribute, owner, options = {}) {
     this.#attribute = attribute;
+    this.#record = `data-${owner}-${attribute}-lease`;
+    this.#base = options.base === true;
+    this.#preserveAuthor = options.preserveAuthor === true;
+    const names = registry.names;
+    names.set(attribute, (names.get(attribute) ?? /* @__PURE__ */ new Set()).add(this.#record));
   }
-  /** Writes or removes the leased attribute while preserving its authored value. */
   write(element, value) {
-    const existing = this.#records.get(element);
-    if (existing) {
-      existing.written = value;
-    } else {
-      this.#records.set(element, {
-        original: element.getAttribute(this.#attribute),
-        written: value
-      });
-    }
-    this.#reflect(element, value);
+    const stack = attributeStack(element, this.#attribute);
+    const hold = this.#take(stack) ?? this.#acquire(element, stack);
+    this.#held.add(element);
+    const shows = !this.#covered(element, stack, hold);
+    hold.written = value;
+    this.#mark(element, stack);
+    if (shows) this.#reflect(element, value);
   }
-  /** Returns one lease without overwriting a value subsequently authored by a consumer. */
   return(element) {
-    const record = this.#records.get(element);
-    if (!record) return;
-    this.#records.delete(element);
-    const stillOwned = element.getAttribute(this.#attribute) === record.written;
-    if (stillOwned) this.#reflect(element, record.original);
-  }
-  /** Reflects only a real value transition, avoiding self-triggered mutation work. */
-  #reflect(element, value) {
-    if (element.getAttribute(this.#attribute) === value) return;
-    if (value === null) element.removeAttribute(this.#attribute);
-    else element.setAttribute(this.#attribute, value);
+    const held = this.#held.delete(element);
+    const known = registry.stacks.get(element)?.has(this.#attribute);
+    const stack = held || known || element.hasAttribute(this.#record) ? attributeStack(element, this.#attribute) : [];
+    const hold = this.#take(stack);
+    if (!hold) return false;
+    const carries = element.getAttribute(this.#attribute) === hold.written;
+    const owns = carries && !this.#covered(element, stack, hold);
+    const index = stack.indexOf(hold);
+    stack.splice(index, 1);
+    const above = stack[index];
+    if (above) above.linked &&= hold.linked;
+    this.#mark(element, stack);
+    if (!owns) return true;
+    const below = hold.linked ? stack[index - 1] : void 0;
+    this.#reflect(element, below ? below.written : hold.original);
+    return true;
   }
-  /** Returns every outstanding lease using the same ownership check as {@link return}. */
   returnAll() {
-    for (const element of Array.from(this.#records.keys())) this.return(element);
-  }
-};
-
-// 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);
+    for (const element of Array.from(this.#held)) this.return(element);
+  }
+  #take(stack) {
+    const hold = findHold(stack, this, this.#record);
+    if (hold) hold.lease = this;
+    return hold;
+  }
+  #acquire(element, stack) {
+    const current = element.getAttribute(this.#attribute);
+    const top = stack.at(-1);
+    const bottom = stack[0];
+    const over = top?.written === current ? top : void 0;
+    const from = this.#base ? this.#preserveAuthor && !stack.some((held) => held.written === current) ? void 0 : bottom : over;
+    const hold = {
+      lease: this,
+      record: this.#record,
+      written: current,
+      original: from ? from.original : current,
+      linked: !this.#base && over !== void 0
+    };
+    if (this.#base && bottom) {
+      bottom.linked = true;
+      stack.unshift(hold);
+    } else stack.push(hold);
+    return hold;
+  }
+  #covered(element, stack, hold) {
+    const current = element.getAttribute(this.#attribute);
+    return stack.slice(stack.indexOf(hold) + 1).some((above) => above.written === current);
+  }
+  #mark(element, stack) {
+    const records = /* @__PURE__ */ new Map([[this.#record, null]]);
+    stack.forEach((hold, index) => {
+      const names = stack.slice(0, index).map((under) => under.record);
+      const beneath = [...new Set(names.reverse())].filter((name) => name !== hold.record);
+      const marker = hold.linked || beneath.length === 0 ? [] : [false];
+      records.set(
+        hold.record,
+        hold.written === hold.original && beneath.length === 0 && index === stack.length - 1 ? null : JSON.stringify([hold.original, hold.written, ...marker, ...beneath])
+      );
+    });
+    for (const [name, recorded] of records) {
+      setAttributeIfChanged(element, name, recorded);
     }
   }
-  /** 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);
+  #reflect(element, value) {
+    setAttributeIfChanged(element, this.#attribute, value);
   }
 };
 
-// src/utils/detach_gate.ts
 var DetachGate = class _DetachGate {
-  /** Set while a probe is queued, waiting for a reconnect to cancel it. */
   #pending = false;
-  /**
-   * True while a probe is queued — the last disconnect was ambiguous and no
-   * reconnect has cancelled it yet. Read it from `connect()` to tell the
-   * reconnect half of an in-page move from a first connect: a controller whose
-   * initialisation restarts a measurement (a min-duration floor, an elapsed
-   * counter) must skip it for the move, where nothing actually restarted.
-   */
   get pending() {
     return this.#pending;
   }
-  /**
-   * True when the disconnect is definitely a real detach — the element left
-   * the document, or `data-controller` no longer lists the identifier. False
-   * means ambiguous (in-page move or observed-root exit), NOT "alive".
-   */
   static isDetached(host) {
-    if (!host.element.isConnected) return true;
-    const tokens = (host.element.getAttribute("data-controller") ?? "").split(/\s+/);
-    return !tokens.includes(host.identifier);
-  }
-  /**
-   * Call from `disconnect()`: runs `teardown` synchronously on a definite
-   * detach (fast path), otherwise defers it one microtask — a reconnect
-   * ({@link cancel} from `connect()`) keeps the state, no reconnect runs it.
-   * One microtask is the whole probe window: Stimulus reconnects a moved
-   * element within the same mutation batch, before the checkpoint drains.
-   */
+    return !host.element.isConnected || !_DetachGate.#listed(host);
+  }
   disconnected(host, teardown) {
-    if (_DetachGate.isDetached(host)) {
+    const carried = _DetachGate.#carried(host);
+    if (!carried && _DetachGate.isDetached(host)) {
       this.#pending = false;
       teardown();
       return;
     }
     this.#pending = true;
-    queueMicrotask(() => {
+    const probe = () => {
       if (!this.#pending) return;
       this.#pending = false;
       teardown();
-    });
+    };
+    if (carried) setTimeout(probe, 0);
+    else queueMicrotask(probe);
+  }
+  static #carried(host) {
+    const element = host.element;
+    return !element.isConnected && element.closest("[data-turbo-permanent]") !== null && _DetachGate.#listed(host);
+  }
+  static #listed(host) {
+    const tokens = (host.element.getAttribute("data-controller") ?? "").split(/\s+/);
+    return tokens.includes(host.identifier);
   }
-  /**
-   * Disarms a pending probe. Call from `connect()` (the reconnect that proves
-   * an in-page move) and from the head of any teardown path not routed through
-   * {@link disconnected} (disabled-toggle, Escape), so an orphaned probe can
-   * never run the teardown a second time.
-   */
   cancel() {
     this.#pending = false;
   }
 };
 
-// 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/safe_timeout.ts
+var MAX_TIMER_DELAY_MS = 2147483647;
+
+var NUMBER_BOUNDS = {
+  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 OwnedText = class {
+  #attribute;
+  #channel;
+  #guard;
+  #writes = /* @__PURE__ */ new WeakMap();
+  constructor(attribute, channel = "text", guard = () => true) {
+    this.#attribute = attribute;
+    this.#channel = channel;
+    this.#guard = guard;
+  }
+  hasRecord(element) {
+    return element.hasAttribute(this.#attribute);
+  }
+  read(element, evidence = {}) {
+    if (evidence.source === "live") return this.#writes.get(element) ?? null;
+    const raw = element.getAttribute(this.#attribute);
+    if (raw === null) return null;
+    try {
+      const record = JSON.parse(raw);
+      if (!Array.isArray(record) || record.length !== 3 || record[0] !== this.#channel || typeof record[1] !== "string" || typeof record[2] !== "string")
+        return null;
+      return { original: record[1], written: record[2] };
+    } catch {
+      return null;
+    }
+  }
+  owns(element, evidence = {}) {
+    return this.#ownedRecord(element, evidence) !== null;
+  }
+  #ownedRecord(element, evidence) {
+    const record = this.read(element, evidence);
+    if (record === null || !this.#guard(element)) return null;
+    if (this.#channel === "text" && element.firstElementChild !== null) return null;
+    const current = this.#current(element);
+    return current === record.written || evidence.source === "live" && evidence.allowOriginal === true && current === record.original ? record : null;
+  }
+  write(element, written, original, force = false) {
+    const current = this.#current(element);
+    if (current === null) return;
+    const before = original ?? this.#writes.get(element)?.original ?? this.read(element)?.original ?? current;
+    if (force || current !== written) this.#put(element, written);
+    this.remember(element, written, before);
+  }
+  remember(element, written, original) {
+    const current = this.#current(element);
+    if (current === null) return;
+    const before = original ?? this.#writes.get(element)?.original ?? this.read(element)?.original ?? current;
+    this.#writes.set(element, { original: before, written });
+    setAttributeIfChanged(
+      element,
+      this.#attribute,
+      JSON.stringify([this.#channel, before, written])
+    );
+  }
+  clear(element, evidence = {}) {
+    if (!this.owns(element, evidence)) return false;
+    if (this.#current(element) !== "") this.#put(element, "");
+    this.forget(element);
+    return true;
+  }
+  restore(element, evidence = {}) {
+    const record = this.#ownedRecord(element, evidence);
+    if (record === null) return false;
+    if (this.#current(element) !== record.original) this.#put(element, record.original);
+    this.forget(element);
+    return true;
+  }
+  forget(element) {
+    setAttributeIfChanged(element, this.#attribute, null);
+    this.#writes.delete(element);
+  }
+  #current(element) {
+    if (this.#channel === "text") return element.textContent ?? "";
+    return element instanceof HTMLInputElement ? element.value : null;
+  }
+  #put(element, text) {
+    if (this.#channel === "text") element.textContent = text;
+    else if (element instanceof HTMLInputElement) element.value = text;
+  }
+};
+
 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);
@@ -215,9 +372,13 @@ var SafeTimeout = class extends TimerRegistry {
   }
 };
 
-// src/controllers/submit_once_controller.ts
 var BUTTON_BUSY_LABEL = "data-submit-once-busy-label";
-var SubmitOnceController = class extends Controller {
+var LABEL_RECORD = "label";
+var SUBMITTER_MARK = "submitter";
+var SubmitOnceController = class _SubmitOnceController extends Controller {
+  #textLabel = new OwnedText(this.#labelRecord);
+  #valueLabel = new OwnedText(this.#labelRecord, "value");
+  #numbers = new NumberValueReader();
   static targets = ["submit", "idle", "busy"];
   static values = {
     announceText: { type: String, default: "" },
@@ -226,26 +387,27 @@ var SubmitOnceController = class extends Controller {
     timeout: { type: Number, default: 0 },
     restoreFocus: { type: Boolean, default: false }
   };
+  static valueConstraints = {
+    timeout: NUMBER_BOUNDS.timer
+  };
   static actions = ["cancel", "finish", "start"];
   static events = ["start", "end", "reconcile"];
   #timers = new SafeTimeout();
   #gate = new DetachGate();
   #listeners = new ListenerSet();
-  #beforeCache = new BeforeCacheReset(() => this.#rewindForCache());
   #sessions = /* @__PURE__ */ new Map();
-  #disabled = new AttributeLease("disabled");
-  #controlBusy = new AttributeLease("aria-busy");
-  #formBusy = new AttributeLease("aria-busy");
-  #submitting = new AttributeLease("data-submitting");
-  #ariaLabel = new AttributeLease("aria-label");
-  #hidden = new AttributeLease("hidden");
+  #disabled = new AttributeLease("disabled", this.identifier);
+  #controlBusy = new AttributeLease("aria-busy", this.identifier);
+  #formBusy = new AttributeLease("aria-busy", this.identifier);
+  #submitting = new AttributeLease("data-submitting", this.identifier);
+  #ariaLabel = new AttributeLease("aria-label", this.identifier);
+  #hidden = new AttributeLease("hidden", this.identifier);
   #onSubmitStart = (event) => {
     this.start(event);
   };
   #onSubmitEnd = (event) => {
     this.#complete(this.#eventForm(event), "turbo", this.#eventSuccess(event));
   };
-  /** Blocks a later native submit while one for the same form is still active. */
   #onNativeSubmit = (event) => {
     const session = this.#sessionFor(event.target);
     if (!session) return;
@@ -254,24 +416,67 @@ var SubmitOnceController = class extends Controller {
   };
   connect() {
     this.#gate.cancel();
-    this.#beforeCache.activate();
     this.#listeners.add(this.element, "submit", this.#onNativeSubmit, { capture: true });
     this.#listeners.add(this.element, "turbo:submit-start", this.#onSubmitStart);
     this.#listeners.add(this.element, "turbo:submit-end", this.#onSubmitEnd);
+    if (this.#sessions.size === 0) this.#releaseInherited();
   }
   disconnect() {
     this.#listeners.dispose();
-    this.#beforeCache.deactivate();
     this.#gate.disconnected(this, () => this.#teardown());
   }
-  /**
-   * Begins the submission represented by `event`.
-   *
-   * Native `submit` events are intended for non-Turbo async forms. Turbo calls
-   * this path through its auto-subscribed `turbo:submit-start` event. An event
-   * whose default an earlier listener already cancelled carries no submission,
-   * so it starts nothing.
-   */
+  get #labelRecord() {
+    return `data-${this.identifier}-${LABEL_RECORD}`;
+  }
+  get #submitterMark() {
+    return `data-${this.identifier}-${SUBMITTER_MARK}`;
+  }
+  #releaseInherited() {
+    const forms = this.#ownedForms();
+    const controls = new Set(
+      this.element.querySelectorAll(`[${this.#labelRecord}]`)
+    );
+    for (const form of forms) {
+      for (const control of this.#submitControls(form)) {
+        if (control.hasAttribute(this.#labelRecord)) controls.add(control);
+      }
+    }
+    for (const control of controls) {
+      if (control.form && !this.#ownsForm(control.form)) continue;
+      this.#restoreLabel(control);
+    }
+    const copied = forms.filter((form) => this.#returnCopied(form));
+    if (copied.length > 0) this.dispatch("reconcile", { detail: { forms: copied } });
+  }
+  #returnCopied(form) {
+    let copied = this.#submitting.return(form);
+    this.#formBusy.return(form);
+    const parts = [...this.idleTargets, ...this.busyTargets];
+    for (const control of this.#submitControls(form)) {
+      this.#disabled.return(control);
+      this.#controlBusy.return(control);
+      if (control instanceof HTMLButtonElement) this.#ariaLabel.return(control);
+      for (const part of parts) if (control.contains(part)) this.#hidden.return(part);
+      if (!control.hasAttribute(this.#submitterMark)) continue;
+      control.removeAttribute(this.#submitterMark);
+      control.disabled = false;
+      if (control.getAttribute("aria-disabled") === "true")
+        control.removeAttribute("aria-disabled");
+      copied = true;
+    }
+    if (copied && form.getAttribute("aria-busy") === "true") form.removeAttribute("aria-busy");
+    return copied;
+  }
+  #restoreLabel(control) {
+    const owner = control instanceof HTMLInputElement ? this.#valueLabel : this.#textLabel;
+    owner.restore(control);
+    owner.forget(control);
+  }
+  #ownedForms() {
+    const forms = Array.from(this.element.querySelectorAll("form"));
+    if (this.element instanceof HTMLFormElement) forms.unshift(this.element);
+    return forms.filter((form) => this.#ownsForm(form));
+  }
   start(event) {
     if (event.defaultPrevented) return;
     const form = this.#eventForm(event);
@@ -289,54 +494,33 @@ var SubmitOnceController = class extends Controller {
       busyPart: null
     };
     this.#sessions.set(form, session);
+    submitter?.setAttribute(this.#submitterMark, "");
     this.#formBusy.write(form, "true");
     this.#submitting.write(form, "true");
     this.#syncControls(session, controls);
     this.#enterLabel(session);
     this.dispatch("start", { detail: { form, submitter } });
-    if (this.timeoutValue > 0) {
+    if (this.#safeTimeout > 0) {
       session.timeoutId = this.#timers.set(
         () => this.#complete(form, "timeout", false),
-        this.timeoutValue
+        this.#safeTimeout
       );
     }
     announce(this.announceTextValue);
   }
-  /**
-   * Completes a non-Turbo async submission for the form associated with
-   * `event`. When called directly with no event, it completes the controller's
-   * sole active form (or the controller element itself when it is a form).
-   */
   finish(event) {
     const form = event ? this.#eventForm(event) : this.#defaultForm();
     this.#complete(form, "manual", event ? this.#eventSuccess(event) : void 0);
   }
-  /**
-   * Abandons the submission for the form associated with `event` because it
-   * never reached the network — a veto from validation, or a request the
-   * consumer gave up before sending. With no event it targets the controller's
-   * sole active form, exactly like {@link finish}.
-   *
-   * The distinction from `finish` is observable: a request that ran and failed
-   * is `finish` with `success: false` and still announces completion, while a
-   * submission that never happened announces nothing.
-   */
   cancel(event) {
     const form = event ? this.#eventForm(event) : this.#defaultForm();
     this.#complete(form, "canceled", false);
   }
-  /** Disables a newly connected explicit submit target during its form's session. */
   submitTargetConnected(target) {
     const session = this.#sessionFor(target.form);
     if (!session || !this.#isNativeSubmitControl(target)) return;
     this.#enterControl(session, target);
   }
-  /**
-   * Ends one session, restores owned state, and reports the observable completion.
-   *
-   * @stimeoRuntimeOnly `announceReadyText` words the one announcement of this finished submission
-   *   and `restoreFocus` decides where its focus returns.
-   */
   #complete(form, reason, success) {
     const session = this.#sessionFor(form);
     if (!session) return;
@@ -347,23 +531,15 @@ var SubmitOnceController = class extends Controller {
     this.#restoreFocus(session);
     if (reason !== "canceled") announce(this.announceReadyTextValue);
   }
-  /** Applies the busy state to every current native/explicit control exactly once. */
   #syncControls(session, controls = this.#submitControls(session.form)) {
     for (const control of controls) this.#enterControl(session, control);
   }
-  /** Temporarily disables one enabled submit control while retaining authored state. */
   #enterControl(session, control) {
     if (session.controls.has(control) || control.matches(":disabled")) return;
     session.controls.add(control);
     this.#disabled.write(control, "");
     this.#controlBusy.write(control, "true");
   }
-  /**
-   * Swaps only the triggering control's safe label channel.
-   *
-   * @stimeoRuntimeOnly `busyLabel` is the label this one submission shows until it ends; the idle
-   *   label comes back with the state it returns.
-   */
   #enterLabel(session) {
     const control = session.submitter;
     if (!control) return;
@@ -379,13 +555,9 @@ var SubmitOnceController = class extends Controller {
     if (label.length === 0) return;
     if (control instanceof HTMLInputElement) {
       if (control.type !== "submit") return;
-      session.labelWrite = {
-        channel: "value",
-        control,
-        original: control.value,
-        written: label
-      };
-      control.value = label;
+      const owner2 = new OwnedText(this.#labelRecord, "value");
+      session.labelWrite = { control, owner: owner2 };
+      owner2.write(control, label, control.value);
       return;
     }
     if (control.hasAttribute("aria-label")) {
@@ -393,30 +565,22 @@ var SubmitOnceController = class extends Controller {
       return;
     }
     if (control.childElementCount > 0) return;
-    session.labelWrite = {
-      channel: "text",
-      control,
-      original: control.textContent ?? "",
-      written: label
-    };
-    control.textContent = label;
+    const owner = new OwnedText(this.#labelRecord);
+    session.labelWrite = { control, owner };
+    owner.write(control, label, control.textContent ?? "");
   }
-  /** Returns labels, controls, and form hooks, respecting intervening consumer writes. */
-  #returnSessionState(session) {
+  #returnSessionState(session, unfinished = false) {
     if (session.timeoutId !== null) {
       this.#timers.clear(session.timeoutId);
       session.timeoutId = null;
     }
-    if (session.labelWrite?.channel === "value") {
-      const { control, original, written } = session.labelWrite;
-      if (control.value === written) control.value = original;
-    } else if (session.labelWrite?.channel === "text") {
-      const { control, original, written } = session.labelWrite;
-      if (control.childElementCount === 0 && control.textContent === written) {
-        control.textContent = original;
-      }
+    if (session.labelWrite) {
+      const { control, owner } = session.labelWrite;
+      owner.restore(control, { source: "live" });
+      owner.forget(control);
     }
     session.labelWrite = null;
+    if (!unfinished) session.submitter?.removeAttribute(this.#submitterMark);
     if (session.submitter instanceof HTMLButtonElement) {
       this.#ariaLabel.return(session.submitter);
     }
@@ -428,11 +592,9 @@ var SubmitOnceController = class extends Controller {
       this.#controlBusy.return(control);
       this.#disabled.return(control);
     }
-    session.controls.clear();
     this.#submitting.return(session.form);
     this.#formBusy.return(session.form);
   }
-  /** Restores focus only when disabling the focused submitter actually stranded it. */
   #restoreFocus(session) {
     const submitter = session.submitter;
     if (!this.restoreFocusValue || !session.submitterHadFocus || !submitter?.isConnected) return;
@@ -441,30 +603,18 @@ var SubmitOnceController = class extends Controller {
       submitter.focus();
     }
   }
-  /** Silently abandons every session before caching or on a real detach. */
   #abandonSessions() {
     this.#timers.clearAll();
+    const departed = !this.element.isConnected;
     for (const session of this.#sessions.values()) {
       session.timeoutId = null;
-      this.#returnSessionState(session);
+      this.#returnSessionState(session, departed);
     }
     this.#sessions.clear();
   }
-  /**
-   * Keeps Turbo's cached snapshot idle without `end`, announcements, or focus
-   * moves; the abandoned forms are reported once as `reconcile`.
-   */
-  #rewindForCache() {
-    const forms = [...this.#sessions.keys()];
-    this.#abandonSessions();
-    if (forms.length > 0) this.dispatch("reconcile", { detail: { forms } });
-  }
-  /** Tears down a true detach; an in-page move is canceled by the next `connect()`. */
   #teardown() {
-    this.#gate.cancel();
     this.#abandonSessions();
   }
-  /** All native controls associated with `form`, plus valid explicit targets. */
   #submitControls(form) {
     const controls = /* @__PURE__ */ new Set();
     for (const element of Array.from(form.elements)) {
@@ -476,13 +626,11 @@ var SubmitOnceController = class extends Controller {
     }
     return Array.from(controls);
   }
-  /** Resolves the real submitter, falling back to the first enabled submit control. */
   #resolveSubmitter(event, controls) {
     const submitter = this.#eventSubmitter(event);
     if (submitter && controls.includes(submitter)) return submitter;
     return controls.find((control) => !control.matches(":disabled")) ?? controls[0] ?? null;
   }
-  /** Reads a native or Turbo submitter without assuming `SubmitEvent` exists. */
   #eventSubmitter(event) {
     if (typeof SubmitEvent !== "undefined" && event instanceof SubmitEvent) {
       return this.#isNativeSubmitControl(event.submitter) ? event.submitter : null;
@@ -491,21 +639,18 @@ var SubmitOnceController = class extends Controller {
     const submitter = detail?.formSubmission?.submitter;
     return this.#isNativeSubmitControl(submitter) ? submitter : null;
   }
-  /** Finds the form represented by an action/Turbo event and verifies this scope owns it. */
   #eventForm(event) {
     const detail = event.detail;
     const target = event.target;
     const candidate = (target instanceof HTMLFormElement ? target : null) ?? (target instanceof Element ? target.closest("form") : null) ?? detail?.formSubmission?.formElement ?? detail?.form ?? this.#eventSubmitter(event)?.form ?? (this.element instanceof HTMLFormElement ? this.element : null);
     return candidate && this.#ownsForm(candidate) ? candidate : null;
   }
-  /** The only unambiguous form for a direct `finish()` call. */
   #defaultForm() {
     if (this.element instanceof HTMLFormElement && this.#ownsForm(this.element))
       return this.element;
     if (this.#sessions.size === 1) return this.#sessions.keys().next().value ?? null;
     return null;
   }
-  /** Prevents an ancestor controller from also taking over a nested instance's form. */
   #ownsForm(form) {
     let candidate = form;
     while (candidate) {
@@ -515,29 +660,33 @@ var SubmitOnceController = class extends Controller {
     }
     return false;
   }
-  /** Returns the active session for a form-shaped external event value. */
   #sessionFor(candidate) {
     if (!(candidate instanceof HTMLFormElement)) return void 0;
     return this.#sessions.get(candidate);
   }
-  /** Effective native submit controls, including implicit buttons and image inputs. */
   #isNativeSubmitControl(element) {
     if (element instanceof HTMLButtonElement) return element.type === "submit";
     return element instanceof HTMLInputElement && (element.type === "submit" || element.type === "image");
   }
-  /** Finds a structured label part belonging to this button, not a nested control. */
   #partInside(control, parts) {
     return parts.find(
       (part) => control.contains(part) && part.closest("button, input[type=submit], input[type=image]") === control
     ) ?? null;
   }
-  /** Reads an optional boolean `success` from Turbo or a manual completion event. */
   #eventSuccess(event) {
     const success = event.detail?.success;
     return typeof success === "boolean" ? success : void 0;
   }
+  get #safeTimeout() {
+    return this.#numbers.read(
+      this,
+      "timeout",
+      this.timeoutValue,
+      _SubmitOnceController.values.timeout.default,
+      _SubmitOnceController.valueConstraints.timeout
+    );
+  }
 };
 
 export { SubmitOnceController };
-//# sourceMappingURL=submit_once_controller.js.map
 //# sourceMappingURL=submit_once_controller.js.map