@50arms/ui 0.0.0-stage → 35.1.0

package/dist/components/InlineEdit.js

@@ -0,0 +1,432 @@
+import { jsxs as we, jsx as P } from "react/jsx-runtime";
+import { useState as ae, useRef as b, useId as ie, useEffect as L } from "react";
+import { useRender as Ee } from "@base-ui/react/use-render";
+import { tv as ye } from "tailwind-variants";
+import { cn as q } from "../lib/cn.js";
+import { useControllable as Ce } from "../lib/use-controllable.js";
+import { Spinner as Te } from "./Spinner.js";
+import { Tooltip as Ne } from "./Popover.js";
+import { assertActivationPair as Re } from "./edit/activation.js";
+import { OutcomeMessage as Ie, isPromise as ke, isRefusal as X } from "./edit/outcome.js";
+import { useEditSession as Se } from "./edit/use-edit-session.js";
+import { useUiStrings as Pe } from "../lib/i18n/provider.js";
+import { chordLabel as Ae } from "../lib/i18n/areas/keys.js";
+const _e = ye({
+  slots: {
+    /* THE ONE GEOMETRY RECIPE. Every property that can move text inside the
+       box lives here, on the SAME element in both states — there is no second
+       recipe to drift out of step with this one, which is what made 5.2.1's
+       "class for class" unit test necessary in the first place. */
+    box: [
+      "block w-full min-w-0 text-left",
+      "border rounded-md",
+      "dx-inline-type",
+      "cursor-text outline-none",
+      "transition-[var(--tx-colors),box-shadow] duration-(--dur-fast) ease-hover"
+    ],
+    /* The refusal/failure message is `OutcomeMessage` (`edit/outcome.tsx`) —
+       an OVERLAY, for the reason 5.2.1 measured: in normal flow a refusal
+       grows the control's own wrapper, which inside a fixed-height row shoves
+       everything beside it. Shared with `InlineMarkdownEdit` since DX-3372. */
+    spinner: "pointer-events-none absolute top-1/2 right-2 -translate-y-1/2",
+    /* Reuses `box` verbatim (border, padding, radius, typography) rather than
+       hand-computed offsets, so the ghost text lines up with real caret
+       position with no separate recipe to drift out of step — the same
+       "one recipe" reasoning `box` itself exists for. `border-transparent`
+       overrides `box`'s own visible border so the ghost never draws a second
+       outline over the real control sitting right behind it. */
+    placeholder: "pointer-events-none absolute inset-0 select-none border-transparent text-field-placeholder"
+  },
+  variants: {
+    /* Same names as `Input`, same tighter ramp 5.2.1 chose over `Input`'s own
+           padding — an inline field sits in running content, not a form.
+    
+           `min-h-[…]` HOLDS THE LINE BOX OPEN WHEN THE NODE HAS NOTHING IN IT —
+           see the module comment above `readText`/`writeText` for the DX-2930
+           review that replaced a zero-width-space seed with this. Tailwind's
+           preflight puts every element in `box-sizing: border-box`, so a
+           `min-height` that is only the text's own `1lh` would still let the box
+           shrink by its padding and border the moment it went empty; the formula
+           has to add BOTH back in, per size, to match that size's own `py-*` +
+           the 1px `border` the shared `box` array below already carries. `1lh`
+           rather than a fixed pixel figure so a consumer's own font-size or
+           line-height override is still honoured — the same reasoning
+           `CodeEditor`'s own `calc(… * 1lh + …)` uses. Proven in a real browser,
+           per size, single-line AND multiline, at rest AND editing, by
+           `scripts/probe-inline-edit.mjs`. */
+    size: {
+      sm: { box: "px-1.5 py-0.5 min-h-[calc(1lh+0.25rem+2px)]" },
+      md: { box: "px-2 py-1 min-h-[calc(1lh+0.5rem+2px)]" },
+      lg: { box: "rounded-lg px-2.5 py-1.5 min-h-[calc(1lh+0.75rem+2px)]" }
+    }
+  },
+  defaultVariants: { size: "md" }
+});
+function se(n) {
+  return n.textContent ?? "";
+}
+function ce(n, e) {
+  n.textContent = e;
+}
+function ue(n) {
+  const e = window.getSelection();
+  if (!e) return;
+  const o = document.createRange(), c = n.lastChild;
+  if (c && c.nodeType === Node.TEXT_NODE) {
+    const s = c.textContent?.length ?? 0;
+    o.setStart(c, s), o.setEnd(c, s);
+  } else
+    o.selectNodeContents(n), o.collapse(!1);
+  e.removeAllRanges(), e.addRange(o);
+}
+function le(n, e) {
+  const o = window.getSelection();
+  if (!o || o.rangeCount === 0 || !n.contains(o.anchorNode)) {
+    n.appendChild(document.createTextNode(e)), ue(n);
+    return;
+  }
+  const c = o.getRangeAt(0);
+  c.deleteContents();
+  const s = document.createTextNode(e);
+  c.insertNode(s), c.setStartAfter(s), c.setEndAfter(s), o.removeAllRanges(), o.addRange(c), n.normalize();
+}
+const De = /* @__PURE__ */ new Set([
+  "insertFromPaste",
+  "insertFromPasteAsQuotation",
+  "insertFromDrop",
+  "insertReplacementText",
+  "insertFromYank"
+]);
+function Fe(n, e) {
+  return e === "multiline" ? n : e === "wrap" ? n.replace(/\r\n|\r|\n/g, " ") : n.replace(/\r\n|\r|\n/g, "");
+}
+function Me(n, e, o) {
+  const c = b(o);
+  c.current = o, L(() => {
+    const s = n.current;
+    if (!s) return;
+    function I(y) {
+      if (!De.has(y.inputType)) return;
+      y.preventDefault();
+      const A = n.current;
+      if (!A) return;
+      const C = y.dataTransfer?.getData("text/plain") ?? y.data ?? "", u = Fe(C, e);
+      le(A, u), c.current();
+    }
+    return s.addEventListener("beforeinput", I), () => s.removeEventListener("beforeinput", I);
+  }, [n, e]);
+}
+function ze({ delayMs: n, session: e, elRef: o, openRef: c, composingRef: s, ...I }) {
+  const y = n !== void 0, [A, C] = ae(!1), u = b(null), v = b(""), x = b(""), h = b("none"), _ = b(!1), l = b(I);
+  l.current = I;
+  function T() {
+    u.current !== null && (clearTimeout(u.current), u.current = null);
+  }
+  L(
+    () => () => {
+      if (_.current = !0, u.current === null) return;
+      T();
+      const r = () => {
+        const i = x.current;
+        if (i !== v.current && l.current.validate?.(i) == null)
+          try {
+            Promise.resolve(l.current.onCommit(i, v.current)).catch(
+              (p) => l.current.onError?.(p)
+            );
+          } catch (p) {
+            l.current.onError?.(p);
+          }
+      }, a = e.inFlight();
+      a ? a.then(r) : r();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  function U(r) {
+    T(), v.current = r, x.current = r, h.current = "none";
+  }
+  function V() {
+    T(), h.current = "none", C(!1);
+  }
+  function Y(r) {
+    x.current = r, !(!y || !c.current) && (T(), u.current = setTimeout(() => {
+      u.current = null, N("debounce");
+    }, n));
+  }
+  function D() {
+    const r = h.current;
+    h.current = "none", r === "cancel" ? l.current.close() : r === "commit" ? N("commit") : r === "save" && N("debounce");
+  }
+  function F(r) {
+    const a = h.current === "none";
+    r === "save" && !a || (h.current = r, r !== "save" && e.setPending(!0), a && e.whenIdle(D));
+  }
+  function N(r) {
+    if (T(), s.current) return;
+    if (e.busy()) {
+      F(r === "commit" ? "commit" : "save");
+      return;
+    }
+    const a = o.current ? se(o.current) : x.current;
+    if (x.current = a, a === v.current) {
+      r === "commit" && l.current.close();
+      return;
+    }
+    const i = l.current.validate?.(a) ?? null;
+    if (i !== null) {
+      e.refuse(i, "validate");
+      return;
+    }
+    const p = e.token();
+    let d;
+    try {
+      d = l.current.onCommit(a, v.current);
+    } catch (g) {
+      e.fail(g);
+      return;
+    }
+    if (!ke(d)) {
+      M(a, r, { outcome: d });
+      return;
+    }
+    r === "commit" ? e.setPending(!0) : C(!0), e.track(
+      d,
+      p,
+      (g) => M(a, r, g),
+      (g) => {
+        _.current && "outcome" in g && !X(g.outcome) && (v.current = a);
+      }
+    );
+  }
+  function M(r, a, i) {
+    C(!1);
+    const p = "outcome" in i && !X(i.outcome);
+    p && (v.current = r);
+    const d = h.current;
+    if (h.current = "none", d === "cancel") {
+      "error" in i && l.current.onError?.(i.error), l.current.close();
+      return;
+    }
+    const g = x.current !== r;
+    if (!p && !g) {
+      "error" in i ? e.fail(i.error) : X(i.outcome) && e.refuse(i.outcome.refusal, "onCommit");
+      return;
+    }
+    if (a === "commit" || d === "commit") {
+      N("commit");
+      return;
+    }
+    g && u.current === null && N("debounce");
+  }
+  function z() {
+    return T(), e.busy() ? (F("cancel"), !0) : !1;
+  }
+  return { enabled: y, saving: A, seed: U, reset: V, noteText: Y, save: N, cancel: z };
+}
+function Je(n) {
+  const {
+    value: e,
+    onCommit: o,
+    validate: c,
+    liveValidate: s,
+    label: I,
+    placeholder: y,
+    size: A = "md",
+    lineMode: C = "single",
+    autosaveMs: u,
+    commitMode: v,
+    readOnly: x,
+    onError: h,
+    editing: _,
+    onEditingChange: l,
+    render: T,
+    className: U,
+    messageClassName: V,
+    inputMode: Y,
+    ref: D
+  } = n;
+  if (u !== void 0 && !(Number.isFinite(u) && u > 0))
+    throw new Error(
+      `InlineEdit: autosaveMs must be a positive number of milliseconds, got ${String(u)}. Omit it to commit only on blur or Enter.`
+    );
+  if (v === "close" && u !== void 0)
+    throw new Error(
+      'InlineEdit: commitMode "close" cannot be combined with autosaveMs. An autosaving field saves while it stays open, so there is no commit to close on. Drop one of them.'
+    );
+  Re("InlineEdit", _, l);
+  const { inlineEdit: F, keyNames: N } = Pe(), M = y ?? F.empty, z = C === "multiline", r = n.failureMessage ?? // I18N-ALLOW: key ids of the retry chord, named by the catalog through chordLabel
+  F.failure(Ae(z && u === void 0 ? "ctrl+enter" : "enter", N)), a = _e({ size: A }), i = _ !== void 0, [p, d] = Ce(_, !1, l), [g, H] = ae(e.length === 0), R = b(null), K = b(!1), k = b(!1), $ = b(!1), S = Se({
+    component: "InlineEdit",
+    value: e,
+    onCommit: o,
+    onError: h,
+    failureMessage: r,
+    close: Q,
+    refocus: () => R.current?.focus(),
+    commitMode: v,
+    reopen: () => d(!0)
+  }), f = ze({
+    delayMs: u,
+    session: S,
+    elRef: R,
+    openRef: K,
+    composingRef: k,
+    validate: c,
+    onCommit: o,
+    onError: h,
+    close: Q
+  }), { pending: w, refusal: G, blocked: O } = S, J = ie(), Z = ie(), E = x !== void 0, m = p && !E;
+  L(() => {
+    i && p && E && d(!1);
+  }, [i, p, E, d]);
+  function fe(t) {
+    R.current = t, typeof D == "function" ? D(t) : D && (D.current = t);
+  }
+  L(() => {
+    const t = R.current;
+    if (!t) return;
+    if (m && !$.current) {
+      const B = S.begin(e, s?.(e) ?? null);
+      f.seed(e), K.current = !0, ce(t, B), ue(t), t.focus(), H(B.length === 0);
+    } else m || (K.current && te(), ce(t, e), H(e.length === 0));
+    $.current = m;
+  }, [m, e]);
+  function ee() {
+    return R.current ? se(R.current) : "";
+  }
+  Me(R, C, j);
+  function ne() {
+    i || E || m || w || d(!0);
+  }
+  function te() {
+    K.current = !1, S.end(), f.reset();
+  }
+  function Q() {
+    te(), d(!1);
+  }
+  function re() {
+    k.current || S.commit(ee(), c);
+  }
+  function j() {
+    if (k.current) return;
+    const t = ee();
+    H(t.length === 0), S.setRefusal(s?.(t) ?? null), S.clearFailure(), f.noteText(t);
+  }
+  function de() {
+    k.current = !0;
+  }
+  function me() {
+    k.current = !1, j();
+  }
+  function pe(t) {
+    if (!m) {
+      if (E || i) return;
+      (t.key === "Enter" || t.key === "F2") && (t.preventDefault(), ne());
+      return;
+    }
+    k.current || t.nativeEvent.isComposing || (t.key === "Escape" ? he(t) : t.key === "Enter" && ge(t));
+  }
+  function he(t) {
+    w || (t.preventDefault(), !(f.enabled && f.cancel()) && Q());
+  }
+  function ge(t) {
+    if (t.preventDefault(), f.enabled && w) return;
+    const W = f.enabled ? () => f.save("commit") : re;
+    if (!z) {
+      t.shiftKey || W();
+      return;
+    }
+    if (t.metaKey || t.ctrlKey || f.enabled && !t.shiftKey) {
+      W();
+      return;
+    }
+    const B = R.current;
+    B && le(B, `
+`), j();
+  }
+  function be() {
+    !K.current || w || k.current || O === null && (f.enabled ? f.save("commit") : re());
+  }
+  const ve = [O !== null ? Z : null, E ? J : null].filter(Boolean).join(" ") || void 0, xe = Ee({
+    render: T,
+    ref: fe,
+    // I18N-ALLOW: DOM tag name handed to the Base UI render slot
+    defaultTagName: "div",
+    props: {
+      role: "textbox",
+      "aria-label": I,
+      /* Not for `"wrap"` — ARIA's `aria-multiline` tells assistive tech Enter
+         inserts a line break, which is exactly what `"wrap"` does NOT do
+         (its Enter commits, same as `"single"`). Only `"multiline"` changes
+         that key, so only `"multiline"` earns the attribute. */
+      "aria-multiline": z || void 0,
+      "aria-describedby": ve,
+      "aria-disabled": E || void 0,
+      "aria-invalid": G !== null || void 0,
+      "aria-busy": w || void 0,
+      "aria-placeholder": M,
+      "aria-readonly": !m || w || void 0,
+      /* Controlled and at rest, the trigger is the one tab stop (DX-3372). */
+      tabIndex: i && !m ? -1 : 0,
+      contentEditable: m && !w,
+      suppressContentEditableWarning: !0,
+      spellCheck: m,
+      inputMode: Y,
+      "data-slot": "inline-edit",
+      "data-editing": m || void 0,
+      className: q(
+        a.box(),
+        Ke({ editing: m, controlled: i, unavailable: E, pending: w, refused: G !== null }),
+        Be(C, m),
+        U
+      ),
+      onClick: ne,
+      onKeyDown: pe,
+      onBlur: be,
+      onInput: j,
+      onCompositionStart: de,
+      onCompositionEnd: me,
+      children: void 0
+    }
+  }), oe = /* @__PURE__ */ we("div", { className: "relative w-full min-w-0", children: [
+    xe,
+    g && /* @__PURE__ */ P("span", { "aria-hidden": "true", className: q(a.box(), a.placeholder()), children: M }),
+    (w || f.saving) && /* @__PURE__ */ P("span", { className: a.spinner(), "data-slot": "inline-edit-saving", children: /* @__PURE__ */ P(Te, { size: "sm" }) }),
+    f.enabled && /* A background save changes nothing a screen reader can see — the
+    text is where it was — so it is announced instead. */
+    /* @__PURE__ */ P("span", { role: "status", className: "sr-only", children: f.saving || w ? F.saving : "" }),
+    E && /* @__PURE__ */ P("span", { id: J, className: "sr-only", children: x.reason }),
+    O !== null && /* @__PURE__ */ P(Ie, { id: Z, className: V, children: O })
+  ] });
+  return E ? /* @__PURE__ */ P(Ne, { content: x.reason, children: oe }) : oe;
+}
+function Ke({
+  editing: n,
+  controlled: e,
+  unavailable: o,
+  pending: c,
+  refused: s
+}) {
+  return n ? q(
+    "border-field-border bg-field text-primary",
+    "focus:outline-none focus:shadow-[0_0_0_3px_var(--control-focus-halo)]",
+    c && "cursor-wait bg-surface-sunken",
+    s && "border-danger"
+  ) : q(
+    "border-transparent bg-transparent text-primary",
+    /* Under controlled activation the text at rest is READ-ONLY and says so:
+       no hover fill, no text cursor, because clicking it does nothing — the
+       trigger beside it is the way in (DX-3372). */
+    e ? "cursor-auto" : "hover:border-field-border hover:bg-surface-active",
+    "focus-visible:border-control focus-visible:bg-field focus-visible:outline-none",
+    "focus-visible:shadow-[0_0_0_3px_var(--control-focus-halo)]",
+    o && ["cursor-not-allowed", "hover:border-transparent hover:bg-transparent"]
+  );
+}
+function Be(n, e) {
+  return n === "multiline" ? "whitespace-pre-wrap break-words" : n === "wrap" ? "whitespace-normal break-words" : e ? "whitespace-nowrap overflow-x-auto" : "truncate";
+}
+export {
+  Je as InlineEdit
+};
+//# sourceMappingURL=InlineEdit.js.map

package/dist/components/InlineEdit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineEdit.js","sources":["../../src/components/InlineEdit.tsx"],"sourcesContent":["import { useEffect, useId, useRef, useState, type Ref, type RefObject } from \"react\";\nimport { useRender } from \"@base-ui/react/use-render\";\nimport { tv } from \"tailwind-variants\";\nimport { cn } from \"../lib/cn\";\nimport { chordLabel, useUiStrings } from \"../lib/i18n\";\nimport { useControllable } from \"../lib/use-controllable\";\nimport { Spinner } from \"./Spinner\";\nimport { Tooltip } from \"./Popover\";\nimport { assertActivationPair, type EditActivation } from \"./edit/activation\";\nimport {\n  OutcomeMessage,\n  isPromise,\n  isRefusal,\n  type EditCommit,\n  type EditOutcome,\n} from \"./edit/outcome\";\nimport { useEditSession, type CommitMode, type EditSession, type SaveResult } from \"./edit/use-edit-session\";\n\n/* ============================================================================\n   INLINE EDIT — click the value, and IT becomes the field. No swap.\n\n   DX-2930 REPLACED THE PREVIOUS DESIGN ENTIRELY. Until 5.2.1 this rendered a\n   `<button>` showing the value and, on click, mounted a SEPARATE `<input>` /\n   `<textarea>` in its place — a display element and a field element, sharing a\n   geometry recipe so the swap did not visibly jump. The operator's ruling on\n   DX-2907 (2026-09-17) was that this was the wrong shape from the start: \"inline\n   edit should use contenteditable and should be seemless editing on the page.\"\n\n   So there is now exactly ONE element, always mounted, for the life of the\n   control. `contentEditable` toggles true/false on it; nothing else changes\n   identity. A consumer's own `ref` receives the same node whether or not\n   editing is in progress — there is no display/field pair to keep in sync, no\n   focus to hand back after an unmount, and the \"no layout jump\" guarantee is\n   now structural rather than a recipe two elements have to agree on: the box\n   never becomes a DIFFERENT box.\n\n   ------------------------------------------------------------------------\n   REACT DOES NOT OWN THE TEXT — the same rule `MarkdownEditor` documents, for\n   the same reason. A contenteditable's content is mutated by the browser on\n   every keystroke, on its own schedule; React reconciles on ITS own schedule.\n   Two owners of one subtree is a caret that jumps or a keystroke that vanishes,\n   so this component never passes the value as JSX `children`. The element's\n   `textContent` is written imperatively, in exactly two places: the instant\n   editing BEGINS (seeded from `value`, caret moved to the end) and whenever the\n   control is NOT editing (kept in sync with `value`, including immediately\n   after a commit or a cancel). While editing is in progress, nothing writes to\n   the node except the browser's own input handling and this component's own\n   Enter/insertion interception below — a re-render triggered by `pending` or a\n   refusal message never touches the text, because nothing in this file's JSX\n   ever names it.\n\n   ------------------------------------------------------------------------\n   THE FOUR THINGS THAT MAKE IT TRUSTWORTHY — unchanged from 5.2.1, because\n   none of them were about the swap:\n\n   1. A TYPED VALUE IS NEVER DISCARDED SILENTLY. `onCommit` may return a\n      promise; until it settles the control stays in a PENDING state, editable\n      surface frozen (`contentEditable={false}` so no further keystrokes land)\n      but the typed text still on screen. A rejection restores editability with\n      the text and the failure both intact.\n\n   2. AN UNCHANGED VALUE IS NOT A WRITE. Comparing the live `textContent`\n      against `value` before calling anything — a focus-then-blur with no edit\n      must not produce a request, an audit row, or a broadcast.\n\n   3. A REFUSAL CARRIES A REASON, AND THE REASON IS THE CALLER'S — `validate`\n      for what is knowable without a request, `onCommit` resolving\n      `{ refusal }` for what only the server knows. Both render through the\n      same live region. An empty reason throws, for the reason given in 5.2.1:\n      a refusal nobody can read is the exact silent failure this exists to rule\n      out.\n\n   4. THE BOX DOES NOT MOVE WHEN IT BECOMES EDITABLE — now trivially true for\n      the box itself (it is the same node), but the TEXT inside it can still\n      shift if the two states carry different padding, border width or\n      typography. `box` below is the one recipe both states draw from; only\n      colour, cursor and overflow behaviour differ between them, and the\n      border is the display state's own colour made transparent rather than\n      removed, for the same 1px-of-width reason 5.2.1 gave. Measured in a real\n      browser by `scripts/probe-inline-edit.mjs`, because happy-dom returns\n      zeros from `getBoundingClientRect` and would pass against any layout.\n\n   ------------------------------------------------------------------------\n   THE OVERWRITE-PROTECTION CONTRACT — DX-2907 problem 137, solution 280.\n\n   `onCommit(next, base)`. `base` is the `value` this component saw at the\n   MOMENT editing began — captured once, as editing opens, and handed back\n   unchanged no matter how long the edit or the save takes. A caller comparing\n   `base` against whatever it currently believes is authoritative can tell \"I\n   am about to overwrite someone else's change\" from \"this is still the record\n   I opened\" — which `InlineEdit` itself cannot know, because it holds no\n   memory of anything beyond the current draft. This is what let\n   `PlanRecordList.tsx` stop resetting a field out from under whoever was\n   mid-edit: previously there was no way to tell \"the record changed while I\n   was typing\" from \"the record has always been this\", so it reset unconditionally.\n\n   `onEditingChange(editing)` reports the control's OWN transitions: it\n   fires `true` when the self-activated control opens itself, and `false`\n   when the control closes itself (a landed commit, Escape) or, under\n   controlled activation, declines to open because it is read-only. It never\n   echoes a change the caller made through `editing`. A caller uses it to\n   suspend its own re-render-from-server logic for exactly as long as someone\n   is actually looking at the field — the other half of the same fix.\n\n   ------------------------------------------------------------------------\n   CONTROLLED ACTIVATION — DX-3372. The operator's design for danxbot\n   (DX-3371): editable text is READ-ONLY until a pencil in the left gutter is\n   clicked; clicking the text itself does nothing. So `editing` is a\n   controllable prop (`useControllable`, the same pair `ReadMore` has for\n   `expanded`): omit it and the control opens itself on click / Enter / F2 as\n   it always has; pass it and ONLY the caller opens it. Everything that\n   happens once it is open — the snapshot, the caret, commit on blur, the\n   outcome contract, autosave — is identical either way, because the\n   start-of-edit work lives in the one effect that sees editing begin, not in\n   the click handler. `EditGutter` is the pencil that drives it. The\n   controlled pair is all-or-nothing (`InlineEditProps`): `editing` without\n   `onEditingChange` is a type error, and throws at render for a caller that\n   got past the types — the control could never hand the closed state back,\n   so the caller's `editing` would stay true over a shut field and nothing\n   would be saved again (DX-3372 review P0).\n\n   THE EDIT SESSION. Pending / refusal / failure, the unchanged check and the\n   outcome handling are `edit/use-edit-session.ts`, shared with\n   `InlineMarkdownEdit`. Every opening is a session; a save that settles\n   after its session ended (the caller closed, or closed and reopened) is\n   dropped rather than acting on the field it no longer belongs to, and saves\n   are serialised across sessions — see that file's header (DX-3372 review H2).\n\n   ------------------------------------------------------------------------\n   KEYBOARD, INSERTION, IME — the browser's own contenteditable defaults are\n   not trusted for any of these, because they are NOT drop-in replacements for\n   a `<textarea>`'s: pressing Enter in a plain `<div contentEditable>` inserts\n   a new block-level child in most engines (a `<div>`, sometimes a `<br>`)\n   rather than the \"\\n\" character this component's `multiline` string contract\n   needs, and paste / drag-drop / a spell-check replacement / a same-page drag\n   \"yank\" all carry the source's HTML rather than plain text. So:\n\n   - EVERY Enter is intercepted in `onKeyDown` and `preventDefault`ed\n     unconditionally — never left to the browser's default action.\n     `lineMode: \"single\"` and `\"wrap\"` (DX-3388): commits unless Shift is\n     held (which does nothing at all, rather than inserting a line the\n     field can never display — `\"wrap\"` wraps VISUALLY but is still a\n     single logical line, so it takes the exact same Enter contract as\n     `\"single\"`). `\"multiline\"`: Mod/Ctrl+Enter commits, a bare Enter\n     inserts a literal \"\\n\" via `insertTextAtCaret` below — never the\n     browser's own paragraph-insertion.\n\n   - EVERY RICH-CONTENT INSERTION ROUTE IS OWNED BY ONE HANDLER, a NATIVE\n     `beforeinput` listener `addEventListener`ed onto the element directly —\n     not the React `onBeforeInput` PROP, and not a paste-only handler with\n     drop/replace/yank left to the browser's own defaults. (React's own\n     `onBeforeInput` is a legacy shim registered for exactly FOUR underlying\n     DOM events — `compositionend` / `keypress` / `textInput` / `paste` — and\n     never fires for a real `beforeinput` event at all; see the effect's own\n     doc for the exact `registerTwoPhaseEvent` call this was checked against.)\n     The native event fires, with the DOM's own `InputEvent.inputType` naming\n     exactly what is about to happen, for every one of them: a paste\n     (`insertFromPaste`, `insertFromPasteAsQuotation`), a native drag-and-drop\n     of rich content INTO the field (`insertFromDrop` — dropping is a\n     contenteditable's default behaviour with no separate `drop` listener\n     needed to arm it), a spell-check correction (`insertReplacementText`),\n     and a same-document drag \"yank\" (`insertFromYank`). The listener\n     recognises exactly that set — DX-2930 review, `RICH_INSERT_INPUT_TYPES`\n     below — `preventDefault`s the browser's own handling (which would carry\n     HTML / a whole subtree) and reads `text/plain` off the event's\n     `dataTransfer`, falling back to its `data` for the replace/yank cases\n     that carry a plain string with no transfer at all; single-line\n     additionally strips every newline so a multi-line source cannot smuggle\n     a linebreak into a field that cannot display one. Ordinary typing\n     (`insertText`, `deleteContentBackward`, …) is NOT in that set and is left\n     alone — those never carry a dataTransfer worth intercepting, and\n     intercepting them too would fight the browser's own caret/undo handling\n     for no reason. One listener for every insertion route means there is no\n     second path (a `drop` listener sibling, a duplicated paste-only handler)\n     to drift out of sync with this one the next time a new route is\n     discovered.\n\n   - The native `beforeinput` listener and Enter's \"\\n\" insertion both go through\n     `insertTextAtCaret`, a small Range-based splice — delete the current\n     selection, insert one text node, collapse the caret after it. Deliberately\n     NOT `document.execCommand`: it is long-deprecated, its cross-browser\n     text-node-splitting behaviour is exactly the un-owned mutation this file\n     avoids elsewhere, and a manual Range gives this component a node it can\n     immediately `normalize()` back down to one text node — which is also what\n     keeps `textContent` a reliable read of \"everything the person typed\" at\n     every commit.\n\n   - COMPOSITION (IME) is tracked in a ref, not state — a render mid-composition\n     is exactly the DOM disturbance the ref-based text ownership above exists\n     to avoid. While `composingRef.current` is true, Enter and Escape are both\n     no-ops: a composing Enter is very often the IME's OWN \"confirm this\n     candidate\" keystroke, and treating it as a commit would submit an\n     unfinished word. `compositionend` clears the ref and re-reads\n     `textContent` for the empty/placeholder state, the same as any other\n     mutation.\n\n   ------------------------------------------------------------------------\n   THE ACCESSIBLE SHAPE CHANGED WITH THE ELEMENT. 5.2.1 was a `<button>` whose\n   accessible NAME was `label` and whose accessible DESCRIPTION carried the\n   value — because a button's content is not, semantically, \"a value\" at all.\n   A `role=\"textbox\"` element is different: ARIA defines its accessible VALUE\n   as its own text content, which is exactly what this component's `textContent`\n   already is. So `aria-label` is still required and is still the name in both\n   states (nothing about identity or naming changes on entering edit — the\n   defect 5.2.1's own header warned about, a control silently renaming itself\n   mid-interaction, cannot recur when there is only one element to name).\n   `aria-multiline` is set only when `lineMode` is `\"multiline\"` — not for\n   `\"wrap\"` (DX-3388), whose Enter commits exactly like `\"single\"`, so\n   advertising multiline semantics to assistive tech would be a lie about\n   what the Enter key does. Unlike\n   `MarkdownEditor`, which carries no role at all and for which the attribute\n   would be an ARIA 1.3 violation, this element legitimately owns\n   `role=\"textbox\"` and the attribute is valid on it.\n\n   THE EMPTY STATE uses `aria-placeholder`, the ARIA analogue of an `<input>`'s\n   `placeholder` attribute, alongside a visual ghost node that is\n   `aria-hidden` and contributes no text of its own — so an empty field is\n   still a real, sized, clickable target (this component's own `box` padding\n   guarantees a non-zero box even with nothing in it) without a screen reader\n   ever reading placeholder prose as if it were the value.\n\n   ------------------------------------------------------------------------\n   AUTOSAVE — `autosaveMs`, OPT-IN (SG-665). Without it nothing below applies\n   and the control behaves exactly as described above.\n\n   WHY IT IS HERE. The Demand Desk (gpt-manager) grew its own `AutosaveField`\n   because this component \"could not\" save while the reader was still typing:\n   it exposed no per-keystroke hook and committed only on blur or Enter. Two\n   inline editors for one interaction is the duplication this closes — the\n   debounce now lives in the one control, so every consumer gets the same keys,\n   the same pending/refusal/failure surfaces and the same overlap handling.\n\n   THE CONTRACT, when `autosaveMs` is set:\n\n   - Every text mutation restarts a timer of `autosaveMs`; when it fires the\n     live text is committed WHILE THE FIELD STAYS OPEN AND EDITABLE. A spinner\n     shows while that background save is out; the field is not frozen, because\n     freezing it would eat the keystrokes the debounce exists to allow.\n   - Enter commits and exits, in multiline mode too — Shift+Enter inserts the\n     newline instead (Cmd/Ctrl+Enter also commits). This is the key contract\n     the Demand Desk's `AutosaveField` had, and it differs from plain\n     `multiline` on purpose: an autosaving field has already saved what matters,\n     so the reader's \"I'm done\" key has to be the easy one.\n   - Blur commits and exits, as it always has.\n   - Escape cancels the pending debounce and exits WITHOUT writing, reverting\n     the display to the last COMMITTED value — which, after a background save\n     has landed, is that save, not the value editing began with. Nothing that\n     was already saved is un-saved.\n   - \"Unchanged\" is measured against the last value THIS edit committed, not\n     against `value` — so a background save followed by Enter with no further\n     typing writes once, not twice.\n   - `base` (see the overwrite-protection contract above) is the value each\n     write REPLACES: the value editing began against for the first save, then\n     whatever the previous save in the same edit committed. A caller comparing\n     it against its own authoritative copy therefore never mistakes its own\n     earlier autosave for someone else's change.\n\n   IN-FLIGHT OVERLAP — the reason this is an engine and not a `setTimeout`.\n   Saves are SERIALISED: at most one `onCommit` is ever outstanding per\n   control. A debounce that fires while a save is out does not start a second\n   one; it marks the field dirty, and the moment the first save lands the\n   newer text is saved in turn. That rules out the out-of-order case entirely\n   — two concurrent writes whose responses arrive swapped, leaving the OLDER\n   text as the last one written — rather than trying to detect it after the\n   fact. (gpt-manager's `use-autosave.ts`, the hook this replaces, fired\n   overlapping saves concurrently and recorded whichever settled last as\n   \"committed\"; that is the behaviour deliberately NOT mirrored.) And since\n   the editable text is never written from React while editing, a response\n   landing mid-typing cannot overwrite a newer keystroke either. A refusal or\n   failure that comes back for text the reader has since changed is stale —\n   it is dropped, and the newer text is saved instead of the stale message\n   being shown against it.\n\n   Enter/blur while a background save is out FREEZES the field (the normal\n   pending state) until that save lands, then commits whatever is left and\n   closes. Escape while one is out freezes it the same way and closes once it\n   lands, writing nothing further.\n\n   UNMOUNT with unsaved text still waiting on the debounce sends it rather\n   than dropping it — \"a typed value is never discarded silently\" (point 1\n   above) holds for a dialog closing under the reader too. It goes out after\n   any in-flight save, never alongside it; its failure reaches `onError`.\n   ========================================================================= */\n\nconst inlineEdit = tv({\n  slots: {\n    /* THE ONE GEOMETRY RECIPE. Every property that can move text inside the\n       box lives here, on the SAME element in both states — there is no second\n       recipe to drift out of step with this one, which is what made 5.2.1's\n       \"class for class\" unit test necessary in the first place. */\n    box: [\n      \"block w-full min-w-0 text-left\",\n      \"border rounded-md\",\n      \"dx-inline-type\",\n      \"cursor-text outline-none\",\n      \"transition-[var(--tx-colors),box-shadow] duration-(--dur-fast) ease-hover\",\n    ],\n    /* The refusal/failure message is `OutcomeMessage` (`edit/outcome.tsx`) —\n       an OVERLAY, for the reason 5.2.1 measured: in normal flow a refusal\n       grows the control's own wrapper, which inside a fixed-height row shoves\n       everything beside it. Shared with `InlineMarkdownEdit` since DX-3372. */\n    spinner: \"pointer-events-none absolute top-1/2 right-2 -translate-y-1/2\",\n    /* Reuses `box` verbatim (border, padding, radius, typography) rather than\n       hand-computed offsets, so the ghost text lines up with real caret\n       position with no separate recipe to drift out of step — the same\n       \"one recipe\" reasoning `box` itself exists for. `border-transparent`\n       overrides `box`'s own visible border so the ghost never draws a second\n       outline over the real control sitting right behind it. */\n    placeholder: \"pointer-events-none absolute inset-0 select-none border-transparent text-field-placeholder\",\n  },\n  variants: {\n    /* Same names as `Input`, same tighter ramp 5.2.1 chose over `Input`'s own\n       padding — an inline field sits in running content, not a form.\n\n       `min-h-[…]` HOLDS THE LINE BOX OPEN WHEN THE NODE HAS NOTHING IN IT —\n       see the module comment above `readText`/`writeText` for the DX-2930\n       review that replaced a zero-width-space seed with this. Tailwind's\n       preflight puts every element in `box-sizing: border-box`, so a\n       `min-height` that is only the text's own `1lh` would still let the box\n       shrink by its padding and border the moment it went empty; the formula\n       has to add BOTH back in, per size, to match that size's own `py-*` +\n       the 1px `border` the shared `box` array below already carries. `1lh`\n       rather than a fixed pixel figure so a consumer's own font-size or\n       line-height override is still honoured — the same reasoning\n       `CodeEditor`'s own `calc(… * 1lh + …)` uses. Proven in a real browser,\n       per size, single-line AND multiline, at rest AND editing, by\n       `scripts/probe-inline-edit.mjs`. */\n    size: {\n      sm: { box: \"px-1.5 py-0.5 min-h-[calc(1lh+0.25rem+2px)]\" },\n      md: { box: \"px-2 py-1 min-h-[calc(1lh+0.5rem+2px)]\" },\n      lg: { box: \"rounded-lg px-2.5 py-1.5 min-h-[calc(1lh+0.75rem+2px)]\" },\n    },\n  },\n  defaultVariants: { size: \"md\" },\n});\n\ninterface InlineEditFieldProps {\n  /**\n   * The committed value. Controlled — this component never holds the truth,\n   * only the draft while somebody is typing one.\n   */\n  value: string;\n  /**\n   * Commit a new value. Called ONLY when the live text differs both from\n   * `value` and from the value editing began from — text the reader did not\n   * change is never written back, even if `value` moved underneath the open\n   * field (with `autosaveMs`, \"unchanged\" is measured against the last value\n   * this edit committed instead — see \"AUTOSAVE\").\n   *\n   * `base` is the `value` this control saw at the moment editing BEGAN —\n   * captured once and handed back unchanged regardless of how long the edit or\n   * the save takes. Compare it against whatever you currently believe is\n   * authoritative to tell \"this would overwrite a change that landed while I\n   * was editing\" from \"nothing has moved\". See the module comment\n   * (\"THE OVERWRITE-PROTECTION CONTRACT\") for the DX-2907 problem this closes.\n   *\n   * May return a promise, in which case the field stays open and pending until\n   * it settles. Resolve/return `{ refusal }` to reject the value with a\n   * reason; throw or reject to report that the save itself failed.\n   */\n  onCommit: EditCommit;\n  /**\n   * The refusals that are knowable WITHOUT a request. Return the reason, or\n   * `null` to accept. Runs after the unchanged check and before `onCommit`.\n   */\n  validate?: (value: string) => string | null;\n  /**\n   * The same shape as `validate`, but checked on EVERY keystroke instead of\n   * only at commit (SG-909) — an email/URL field flagging a typo while the\n   * reviewer is still typing, not only once they leave the box. Shares the\n   * one message slot `validate`'s refusal already draws from, so a live\n   * warning and a commit-time refusal never show two different sentences at\n   * once — whichever is current simply replaces the other. Purely advisory:\n   * it never freezes the field or drops a keystroke (R-12) the way a refused\n   * COMMIT does; it only decides what the message area says while typing.\n   * Pass the identical function as `validate` too if an invalid value should\n   * also be refused at commit — `liveValidate` on its own only ever warns.\n   *\n   * ALSO RUNS THE INSTANT EDITING OPENS (`begin()`), not only on the first\n   * keystroke — so a field that already holds an invalid stored value (e.g.\n   * a bad address that predates this check) shows the warning as soon as the\n   * reviewer clicks in, before they have typed anything at all, rather than\n   * waiting for them to disturb the text first.\n   */\n  liveValidate?: (value: string) => string | null;\n  /**\n   * The virtual keyboard a touch device shows for this field — `\"email\"` /\n   * `\"tel\"` / `\"url\"` bring up the matching layout. `InlineEdit` is a\n   * `contentEditable` box, not an `<input>`, so this is the only lever it has\n   * for that; unlike a real `<input type=\"email\">`, the attribute alone does\n   * not also change parsing or validation, both of which stay entirely\n   * `validate`/`liveValidate`'s job.\n   */\n  inputMode?: \"text\" | \"email\" | \"tel\" | \"url\" | \"numeric\" | \"decimal\" | \"search\" | \"none\";\n  /**\n   * The accessible name AND accessible value's label, in both states —\n   * `role=\"textbox\"` computes its accessible value from its own text content,\n   * so this is the one thing that has to be said separately. REQUIRED.\n   */\n  label: string;\n  /**\n   * What the control shows in place of a blank value, and its\n   * `aria-placeholder`.\n   *\n   * Omit for the built-in empty text.\n   */\n  placeholder?: string;\n  /** Box ramp. Matches `Input`'s names. */\n  size?: \"sm\" | \"md\" | \"lg\";\n  /**\n   * How the field wraps and how Enter behaves. Three shapes, not a boolean,\n   * because \"wraps visually\" and \"Enter inserts a newline\" are independent\n   * axes — DX-3388 needed a line that wraps but never contains \"\\n\", which a\n   * single `multiline` flag could not express without a second bolted-on\n   * prop.\n   *\n   * - `\"single\"` (default) — no wrap; scrolls horizontally while editing,\n   *   truncates at rest. Enter commits (Shift+Enter is a no-op — there is\n   *   nowhere for a second line to go).\n   * - `\"wrap\"` — wraps visually like `\"multiline\"`, but Enter still commits\n   *   exactly as `\"single\"` does. Every typed or pasted newline is normalised\n   *   to a single space by the same `beforeinput` interception that\n   *   `\"single\"` uses to strip them — the committed value can never contain\n   *   \"\\n\". For a title or summary: readable while long, never a literal\n   *   line break in something that flows into a list row, Trello, or a\n   *   commit message.\n   * - `\"multiline\"` — grows as a multi-line block. THE COMMIT KEY MOVES,\n   *   because Enter has to insert a newline instead: Enter inserts \"\\n\",\n   *   Cmd/Ctrl+Enter commits, Escape still cancels, blur still commits.\n   */\n  lineMode?: \"single\" | \"wrap\" | \"multiline\";\n  /**\n   * Save WHILE the reader types: commit this many milliseconds after the last\n   * keystroke, with the field still open. Enter (Shift+Enter is the newline in\n   * `multiline`), blur, and Cmd/Ctrl+Enter commit and exit; Escape cancels the\n   * pending debounce and reverts to the last committed value. Saves are\n   * serialised — see the module comment (\"AUTOSAVE\") for the full contract.\n   *\n   * Omit for the commit-on-blur/Enter behaviour. Must be a positive number.\n   */\n  autosaveMs?: number;\n  /**\n   * `\"close\"` closes the field the moment a commit that returns a promise is\n   * sent, instead of freezing it until the promise settles - for a screen that\n   * already shows the new value. A refusal or failure that lands afterwards\n   * reopens the field with the text that was sent and the message under it,\n   * unless the field was opened again meanwhile (a later commit wins). Not\n   * combinable with `autosaveMs`. Default `\"wait\"`.\n   */\n  commitMode?: CommitMode;\n  /**\n   * This value cannot be edited at all, AND WHY. `{ reason }`, matching\n   * `SettingRow.readOnly` — a control that refuses in silence is\n   * indistinguishable from one that is broken. Under controlled activation a\n   * request to open (`editing` true) is declined by handing the closed state\n   * straight back through `onEditingChange(false)`, so a pencil driving it\n   * returns instead of waiting on a field that will never open (DX-3372 H3).\n   */\n  readOnly?: { reason: string };\n  /**\n   * What is shown when the commit REJECTS (a thrown error or a rejected\n   * promise — never a `{ refusal }`, which renders its own text).\n   *\n   * Omit for the built-in sentence, which names the key that commits in this\n   * configuration: Enter, or Ctrl+Enter for a `multiline` field without\n   * `autosaveMs` (blur never re-attempts a failed value, DX-3372 review L1).\n   */\n  failureMessage?: string;\n  /** The rejected error, handed on so it can be logged or reported. */\n  onError?: (error: unknown) => void;\n  /** Render as a different element — see `Button`'s own `render` for the shape. */\n  render?: useRender.RenderProp;\n  /**\n   * Applied in both states, and there is only one of these on purpose — see\n   * `box` above: anything that changes the box's geometry has to reach both\n   * states or the control shifts on click, and a control cannot shift on click\n   * when both states are the same element unless a class only reaches one of\n   * them.\n   */\n  className?: string;\n  /** The refusal/failure message only — NOT the box. See 5.2.1's own doc for why it is a separate prop. */\n  messageClassName?: string;\n  ref?: Ref<HTMLElement>;\n}\n\n/**\n * SELF-ACTIVATED: omit `editing` and the control opens itself on click, Enter\n * or F2. `onEditingChange` then only observes — it fires when the control\n * starts editing and when it stops, so a caller can suspend its own\n * re-render-from-server logic for exactly as long as someone is typing.\n */\ninterface InlineEditSelfActivated {\n  editing?: undefined;\n  onEditingChange?: (editing: boolean) => void;\n}\n\n/**\n * The props. `editing` + `onEditingChange` are a discriminated pair\n * (DX-3372 review P0): either omit `editing` (self-activated, above) or pass\n * BOTH (`EditActivation` — controlled). Controlled, the control never opens\n * itself; `true` opens it focused with the caret at the end; it hands the\n * closed state back through `onEditingChange(false)` after a landed commit,\n * Escape, or a refused opening (read-only). Setting `editing` false yourself\n * ends the edit exactly as Escape does — nothing more is written. A save that\n * is already out when you do cannot be recalled: it still reaches your\n * `onCommit` promise, but its outcome no longer touches the field — no\n * message, no focus move, no second `onEditingChange(false)` — and a commit\n * from the next opening waits for it before starting (see\n * `edit/use-edit-session.ts`). At rest a controlled control leaves the tab\n * order and drops its hover affordance, so the trigger is the one stop.\n */\nexport type InlineEditProps = InlineEditFieldProps & (InlineEditSelfActivated | EditActivation);\n\n/**\n * A genuinely-empty block box collapses to its padding and border alone — NO\n * line box at all, because there is no inline content to establish one — and\n * a browser's `contentEditable=\"true\"` gives an empty editable a real line\n * box anyway, to have somewhere to draw the caret. Measured in a real browser\n * (`scripts/probe-inline-edit.mjs`, the empty \"Demand tag\" control): 10px at\n * rest, 34px the instant `contentEditable` flips true — a layout jump this\n * component exists to rule out, and happy-dom's zeroed `getBoundingClientRect`\n * cannot see it at all.\n *\n * DX-2930 REVIEW: this used to be closed by seeding a lone zero-width space\n * (U+200B) whenever the value was empty, stripped back out on every read. It\n * worked, and it was wrong — a value that legitimately CONTAINS a real\n * U+200B (typed or pasted from somewhere else) silently lost that character\n * on every read, and `readText` disagreeing with raw `textContent` made\n * \"empty\" two different rules depending on which one happened to be asked.\n * The fix does not touch text content at all: `min-h-[…]` on `box` below\n * (per size, `1lh` plus that size's own padding and border, `1lh` because a\n * fixed pixel value cannot track a consumer's own line-height / font-size\n * overrides) holds the line box open in BOTH states, at rest and editing,\n * whether or not the node has anything in it — the DOM's own emptiness is\n * never disguised, so `readText` is a plain `textContent` read and \"empty\"\n * is the one rule `value.length === 0` / `currentText().length === 0`\n * everywhere. Proven per size, per line-count variant, at rest, editing and\n * refused, by `scripts/probe-inline-edit.mjs`.\n */\nfunction readText(el: HTMLElement): string {\n  return el.textContent ?? \"\";\n}\nfunction writeText(el: HTMLElement, text: string) {\n  el.textContent = text;\n}\n\n/** Move the caret to the very end of `el`'s content. */\nfunction placeCaretAtEnd(el: HTMLElement) {\n  const selection = window.getSelection();\n  if (!selection) return;\n  const range = document.createRange();\n  /* `range.selectNodeContents(el).collapse(false)` looks like the obvious\n     spelling and is wrong: `el` is an ELEMENT, so that boundary point counts\n     CHILD NODES, not characters — it lands at \"after the last child\", which a\n     browser renders correctly for a single text child but which\n     `insertTextAtCaret` below cannot then splice into at the right offset. If\n     the last child is a text node, target it directly at its own length —\n     the one genuine character-offset boundary a text-only editable can have. */\n  const last = el.lastChild;\n  if (last && last.nodeType === Node.TEXT_NODE) {\n    const end = last.textContent?.length ?? 0;\n    range.setStart(last, end);\n    range.setEnd(last, end);\n  } else {\n    range.selectNodeContents(el);\n    range.collapse(false);\n  }\n  selection.removeAllRanges();\n  selection.addRange(range);\n}\n\n/**\n * Splice `text` in at the current caret/selection inside `el`, as ONE plain\n * text node, then collapse the caret after it and merge adjacent text nodes\n * back down to one.\n *\n * NOT `document.execCommand`. See the module comment (\"KEYBOARD, INSERTION, IME\")\n * for why: this is the one place that owns Enter's \"\\n\" and every rich-content\n * insertion route's plain text, and both need a result this component can\n * immediately `normalize()` and read back as a single reliable `textContent`.\n */\nfunction insertTextAtCaret(el: HTMLElement, text: string) {\n  const selection = window.getSelection();\n  if (!selection || selection.rangeCount === 0 || !el.contains(selection.anchorNode)) {\n    // No live caret inside the element (focus moved, or nothing selected yet)\n    // — append at the end instead of silently dropping the input.\n    el.appendChild(document.createTextNode(text));\n    placeCaretAtEnd(el);\n    return;\n  }\n  const range = selection.getRangeAt(0);\n  range.deleteContents();\n  const node = document.createTextNode(text);\n  range.insertNode(node);\n  range.setStartAfter(node);\n  range.setEndAfter(node);\n  selection.removeAllRanges();\n  selection.addRange(range);\n  el.normalize();\n}\n\n/**\n * Every `beforeinput` `inputType` that can carry rich content INTO the field\n * from somewhere else — the DX-2930 review's finding: the previous revision\n * wired `onPaste` alone, so a drag-and-drop, a spell-check correction and a\n * same-document drag \"yank\" all reached the browser's own default handling\n * (which inserts real markup) unintercepted. The native `beforeinput` listener\n * installed by the effect below (search this file for `RICH_INSERT_INPUT_TYPES`)\n * is the ONE place all four are caught, because the native event fires, with\n * the inputType already naming which one this is, ahead of every native\n * insertion route — there is no second, per-event handler (a `drop` listener,\n * a separate paste handler) left to fall out of sync with this set. Ordinary\n * typing (`insertText`, `deleteContentBackward`, …) is deliberately NOT a\n * member: it carries no dataTransfer worth intercepting, and intercepting it\n * too would fight the browser's own caret/undo handling for nothing.\n */\nconst RICH_INSERT_INPUT_TYPES = new Set([\n  \"insertFromPaste\",\n  \"insertFromPasteAsQuotation\",\n  \"insertFromDrop\",\n  \"insertReplacementText\",\n  \"insertFromYank\",\n]);\n\n/**\n * THE NATIVE `beforeinput` LISTENER, DELIBERATELY NOT THE `onBeforeInput` PROP\n * — verified against react-dom's own source rather than assumed: React's\n * `onBeforeInput` is a legacy shim registered for exactly FOUR underlying DOM\n * events (`registerTwoPhaseEvent(\"onBeforeInput\", [\"compositionend\",\n * \"keypress\", \"textInput\", \"paste\"])`), synthesizing text-input semantics from\n * a mix of old browser quirks. It never listens for the real, modern\n * `beforeinput` event at all, so it can never see `insertFromDrop`,\n * `insertReplacementText` or `insertFromYank`, and even its own `\"paste\"` case\n * returns null data — wiring `RICH_INSERT_INPUT_TYPES`'s handler through the\n * JSX prop would compile, look correct, and silently never fire for the routes\n * this exists to catch. `addEventListener(\"beforeinput\", …)` on the element\n * itself sees the DOM's OWN `InputEvent.inputType` directly, which is what that\n * set needs to read.\n */\n/**\n * `\"single\"` strips a rich-inserted newline entirely (there is nowhere for it\n * to go); `\"wrap\"` normalises it to a space instead — DX-3388's AC: the\n * committed value never contains \"\\n\", but a pasted multi-line source still\n * reads as space-separated words rather than losing the word boundary a bare\n * strip would. `\"multiline\"` keeps it verbatim.\n */\nfunction normalizeInsertedText(raw: string, lineMode: \"single\" | \"wrap\" | \"multiline\"): string {\n  if (lineMode === \"multiline\") return raw;\n  if (lineMode === \"wrap\") return raw.replace(/\\r\\n|\\r|\\n/g, \" \");\n  return raw.replace(/\\r\\n|\\r|\\n/g, \"\");\n}\n\nfunction usePlainTextInsertion(\n  elRef: RefObject<HTMLElement | null>,\n  lineMode: \"single\" | \"wrap\" | \"multiline\",\n  onMutated: () => void,\n) {\n  const mutated = useRef(onMutated);\n  mutated.current = onMutated;\n  useEffect(() => {\n    const el = elRef.current;\n    if (!el) return;\n    function onNativeBeforeInput(nativeEvent: InputEvent) {\n      if (!RICH_INSERT_INPUT_TYPES.has(nativeEvent.inputType)) return;\n      nativeEvent.preventDefault();\n      const target = elRef.current;\n      if (!target) return;\n      const raw = nativeEvent.dataTransfer?.getData(\"text/plain\") ?? nativeEvent.data ?? \"\";\n      const text = normalizeInsertedText(raw, lineMode);\n      insertTextAtCaret(target, text);\n      mutated.current();\n    }\n    el.addEventListener(\"beforeinput\", onNativeBeforeInput);\n    return () => el.removeEventListener(\"beforeinput\", onNativeBeforeInput);\n  }, [elRef, lineMode]);\n}\n\ninterface AutosaveOptions {\n  /** `autosaveMs`; `undefined` switches the whole engine off. */\n  delayMs: number | undefined;\n  session: EditSession;\n  elRef: RefObject<HTMLElement | null>;\n  /** Whether the field is open — read from timers and promise callbacks. */\n  openRef: RefObject<boolean>;\n  composingRef: RefObject<boolean>;\n  validate?: (value: string) => string | null;\n  onCommit: EditCommit;\n  onError?: (error: unknown) => void;\n  /** Close the field (the control's own `close()`). */\n  close: () => void;\n}\n\n/**\n * THE AUTOSAVE ENGINE — see the module comment (\"AUTOSAVE\"). Reads refs and\n * `latest` only, never render-scoped state, because it runs from a timer and\n * from promise callbacks. Saves go through the edit session, so a save that\n * lands after its session ended is dropped (DX-3372 review H2): before the\n * session token, a save landing after close-and-reopen saw the reopened\n * field's older text as \"newer\" and wrote it back over itself.\n */\nfunction useAutosave({ delayMs, session, elRef, openRef, composingRef, ...props }: AutosaveOptions) {\n  const enabled = delayMs !== undefined;\n  const [saving, setSaving] = useState(false);\n  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  /* The last value THIS edit has committed (the value editing began against\n     until the first save lands) — \"unchanged\" and `base` are both read here. */\n  const committedRef = useRef(\"\");\n  /* The latest text, kept outside the DOM so an unmount can still send it. */\n  const draftRef = useRef(\"\");\n  /* What to do once the save that is out lands: nothing more, save the newer\n     text a debounce asked for meanwhile, commit-and-close (Enter/blur), or\n     close without writing (Escape). */\n  const afterRef = useRef<\"none\" | \"save\" | \"commit\" | \"cancel\">(\"none\");\n  /* Set by the unmount cleanup: a save that lands afterwards is stale (the\n     session ended with the component), but its value is still the latest\n     one stored, so the unmount send below must use it as `base`. */\n  const unmountedRef = useRef(false);\n  const latest = useRef(props);\n  latest.current = props;\n\n  function clearTimer() {\n    if (timerRef.current === null) return;\n    clearTimeout(timerRef.current);\n    timerRef.current = null;\n  }\n\n  /* UNMOUNT WITH UNSAVED TEXT SENDS IT. Only text the debounce was still\n     waiting on (a live timer) counts as unsaved; an edit that was cancelled or\n     already committed has no timer. Chained after any in-flight save so the\n     two writes can never land out of order. */\n  useEffect(\n    () => () => {\n      unmountedRef.current = true;\n      if (timerRef.current === null) return;\n      clearTimer();\n      const send = () => {\n        const next = draftRef.current;\n        if (next === committedRef.current) return;\n        if (latest.current.validate?.(next) != null) return;\n        try {\n          void Promise.resolve(latest.current.onCommit(next, committedRef.current)).catch((error: unknown) =>\n            latest.current.onError?.(error),\n          );\n        } catch (error) {\n          latest.current.onError?.(error);\n        }\n      };\n      const inFlight = session.inFlight();\n      if (inFlight) void inFlight.then(send);\n      else send();\n    },\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [],\n  );\n\n  /** A new edit session began against `value`. */\n  function seed(value: string) {\n    clearTimer();\n    committedRef.current = value;\n    draftRef.current = value;\n    afterRef.current = \"none\";\n  }\n\n  /** Drop every piece of in-edit engine state. */\n  function reset() {\n    clearTimer();\n    afterRef.current = \"none\";\n    setSaving(false);\n  }\n\n  /** The text changed: restart the debounce. */\n  function noteText(text: string) {\n    draftRef.current = text;\n    if (!enabled || !openRef.current) return;\n    clearTimer();\n    timerRef.current = setTimeout(() => {\n      timerRef.current = null;\n      save(\"debounce\");\n    }, delayMs);\n  }\n\n  /** Run whatever the reader asked for while a save was out. */\n  function drainAfter() {\n    const after = afterRef.current;\n    afterRef.current = \"none\";\n    if (after === \"cancel\") latest.current.close();\n    else if (after === \"commit\") save(\"commit\");\n    else if (after === \"save\") save(\"debounce\");\n  }\n\n  /** Record what to do once the save that is out lands. */\n  function queue(next: \"save\" | \"commit\" | \"cancel\") {\n    const wasIdle = afterRef.current === \"none\";\n    if (next === \"save\" && !wasIdle) return;\n    afterRef.current = next;\n    if (next !== \"save\") session.setPending(true);\n    /* A save from a PREVIOUS session never reaches `landed` below (its\n       outcome is stale), so the queue is drained once the field is idle\n       instead; in the same session `landed` has already consumed it. */\n    if (wasIdle) session.whenIdle(drainAfter);\n  }\n\n  /**\n   * Save the live text. `\"debounce\"` is the timer firing: save and stay open.\n   * `\"commit\"` is Enter or blur: save, then close. Serialised — if a save is\n   * already out, this only records what to do once it lands.\n   */\n  function save(mode: \"debounce\" | \"commit\") {\n    clearTimer();\n    if (composingRef.current) return;\n    if (session.busy()) {\n      queue(mode === \"commit\" ? \"commit\" : \"save\");\n      return;\n    }\n    const next = elRef.current ? readText(elRef.current) : draftRef.current;\n    draftRef.current = next;\n    if (next === committedRef.current) {\n      if (mode === \"commit\") latest.current.close();\n      return;\n    }\n    const local = latest.current.validate?.(next) ?? null;\n    if (local !== null) {\n      session.refuse(local, \"validate\");\n      return;\n    }\n    const token = session.token();\n    let outcome: EditOutcome | Promise<EditOutcome>;\n    try {\n      outcome = latest.current.onCommit(next, committedRef.current);\n    } catch (error) {\n      session.fail(error);\n      return;\n    }\n    if (!isPromise(outcome)) {\n      landed(next, mode, { outcome });\n      return;\n    }\n    if (mode === \"commit\") session.setPending(true);\n    else setSaving(true);\n    session.track(\n      outcome,\n      token,\n      (result) => landed(next, mode, result),\n      (result) => {\n        if (unmountedRef.current && \"outcome\" in result && !isRefusal(result.outcome)) committedRef.current = next;\n      },\n    );\n  }\n\n  /** One save of `sent`, from the CURRENT session, settled. */\n  function landed(sent: string, mode: \"debounce\" | \"commit\", result: SaveResult) {\n    setSaving(false);\n    const accepted = \"outcome\" in result && !isRefusal(result.outcome);\n    if (accepted) committedRef.current = sent;\n\n    const after = afterRef.current;\n    afterRef.current = \"none\";\n    if (after === \"cancel\") {\n      /* The reader already chose to discard; a failure of the save that was\n         out is still reported, never swallowed by the close. */\n      if (\"error\" in result) latest.current.onError?.(result.error);\n      latest.current.close();\n      return;\n    }\n\n    /* A refusal/failure about text the reader has since replaced is STALE:\n       drop it and save the newer text instead of pinning an old message on\n       it. See \"IN-FLIGHT OVERLAP\". */\n    const superseded = draftRef.current !== sent;\n    if (!accepted && !superseded) {\n      if (\"error\" in result) session.fail(result.error);\n      else if (isRefusal(result.outcome)) session.refuse(result.outcome.refusal, \"onCommit\");\n      return;\n    }\n\n    if (mode === \"commit\" || after === \"commit\") {\n      save(\"commit\");\n      return;\n    }\n    /* Newer text is waiting. If the reader is still typing, their own live\n       timer will save it; otherwise (a debounce already fired while this save\n       was out) save it now. */\n    if (superseded && timerRef.current === null) save(\"debounce\");\n  }\n\n  /**\n   * Escape. Drops the pending debounce; a save already out is let land (it\n   * cannot be recalled) and the field closes once it has, writing nothing\n   * further. Returns false when there is nothing in flight and the caller\n   * should close now.\n   */\n  function cancel(): boolean {\n    clearTimer();\n    if (!session.busy()) return false;\n    queue(\"cancel\");\n    return true;\n  }\n\n  return { enabled, saving, seed, reset, noteText, save, cancel };\n}\n\nexport function InlineEdit(props: InlineEditProps) {\n  const {\n    value,\n    onCommit,\n    validate,\n    liveValidate,\n    label,\n    placeholder: placeholderProp,\n    size = \"md\",\n    lineMode = \"single\",\n    autosaveMs,\n    commitMode,\n    readOnly,\n    onError,\n    editing: editingProp,\n    onEditingChange,\n    render,\n    className,\n    messageClassName,\n    inputMode,\n    ref,\n  } = props;\n  if (autosaveMs !== undefined && !(Number.isFinite(autosaveMs) && autosaveMs > 0)) {\n    throw new Error(\n      `InlineEdit: autosaveMs must be a positive number of milliseconds, got ${String(autosaveMs)}. ` +\n        \"Omit it to commit only on blur or Enter.\",\n    );\n  }\n  if (commitMode === \"close\" && autosaveMs !== undefined) {\n    throw new Error(\n      'InlineEdit: commitMode \"close\" cannot be combined with autosaveMs. An autosaving field saves while it ' +\n        \"stays open, so there is no commit to close on. Drop one of them.\",\n    );\n  }\n  assertActivationPair(\"InlineEdit\", editingProp, onEditingChange);\n  const { inlineEdit: strings, keyNames } = useUiStrings();\n  const placeholder = placeholderProp ?? strings.empty;\n  /* Only `\"multiline\"` moves the commit key — `\"wrap\"` commits on a bare\n     Enter exactly like `\"single\"` does (its whole point is to behave like a\n     single-line field that happens to wrap). */\n  const growsMultiline = lineMode === \"multiline\";\n  /* L1: the retry hint names the key that actually commits here. */\n  const failureMessage =\n    props.failureMessage ??\n    // I18N-ALLOW: key ids of the retry chord, named by the catalog through chordLabel\n    strings.failure(chordLabel(growsMultiline && autosaveMs === undefined ? \"ctrl+enter\" : \"enter\", keyNames));\n  const s = inlineEdit({ size });\n  /* DX-3372: `editing` is controllable — see `InlineEditProps`.\n     `useControllable` fires `onEditingChange` for every change the control\n     itself makes, and never for one the caller made through the prop. */\n  const controlled = editingProp !== undefined;\n  const [editingRequested, setEditing] = useControllable(editingProp, false, onEditingChange);\n  const [empty, setEmpty] = useState(value.length === 0);\n\n  const elRef = useRef<HTMLElement | null>(null);\n  /* Whether the field is currently open, read inside handlers that may fire\n     from a teardown (blur during unmount) where the `editing` closure could be\n     stale. */\n  const openRef = useRef(false);\n  /* True for exactly the span between `compositionstart` and `compositionend`\n     — see the module comment (\"KEYBOARD, INSERTION, IME\"). A ref, not state: a\n     render mid-composition is the DOM disturbance this component otherwise\n     goes out of its way to avoid. */\n  const composingRef = useRef(false);\n  /* Distinguishes \"just started editing\" from \"still editing\" across\n     `editing`/`value` re-renders, so the seed-and-place-caret work below runs\n     exactly once per edit — see the effect. */\n  const wasEditingRef = useRef(false);\n\n  const session = useEditSession({\n    component: \"InlineEdit\",\n    value,\n    onCommit,\n    onError,\n    failureMessage,\n    close,\n    refocus: () => elRef.current?.focus(),\n    commitMode,\n    reopen: () => setEditing(true),\n  });\n  const autosave = useAutosave({\n    delayMs: autosaveMs,\n    session,\n    elRef,\n    openRef,\n    composingRef,\n    validate,\n    onCommit,\n    onError,\n    close,\n  });\n  const { pending, refusal, blocked } = session;\n\n  const reasonId = useId();\n  const messageId = useId();\n\n  const unavailable = readOnly !== undefined;\n  /* A read-only control stays shut even when a controlling caller asks it to\n     open — the lock outranks the trigger. */\n  const editing = editingRequested && !unavailable;\n\n  /* H3: a controlling caller asked a read-only control to open. It will not,\n     so the closed state is handed straight back — otherwise the caller (a\n     pencil) waits forever on a field that never opens. */\n  useEffect(() => {\n    if (controlled && editingRequested && unavailable) setEditing(false);\n  }, [controlled, editingRequested, unavailable, setEditing]);\n\n  function mergeRef(node: HTMLElement | null) {\n    elRef.current = node;\n    if (typeof ref === \"function\") ref(node);\n    else if (ref) (ref as { current: HTMLElement | null }).current = node;\n  }\n\n  /* THE ONLY PLACE `textContent` IS WRITTEN FROM REACT. Runs when editing\n     BEGINS (seed from `value`, caret to the end — the AC, deliberately not the\n     5.2.1 select-all: this is a single persistent field, not a fresh one\n     replacing a display) and whenever the control is NOT editing (keeps the\n     shown text in step with `value`, including the instant after a commit or a\n     cancel resolves it). While editing continues, this effect's dependencies\n     do not change merely because `pending` or a refusal flipped, so it never\n     runs mid-edit and never fights the browser's own mutation of the node. */\n  useEffect(() => {\n    const el = elRef.current;\n    if (!el) return;\n    const enteringEdit = editing && !wasEditingRef.current;\n    if (enteringEdit) {\n      /* THE START-OF-EDIT SNAPSHOT lives here, not in `begin()`, because under\n         controlled activation (DX-3372) editing can start without `begin()`\n         ever running — the caller flipped `editing`. One place, whichever way\n         the edit was opened. */\n      const startText = session.begin(value, liveValidate?.(value) ?? null);\n      autosave.seed(value);\n      openRef.current = true;\n      writeText(el, startText);\n      placeCaretAtEnd(el);\n      el.focus();\n      setEmpty(startText.length === 0);\n    } else if (!editing) {\n      /* A controlling caller closed it while it was still open (the control's\n         own `close()` clears `openRef` first): end the session the way Escape\n         does — nothing more is written, and a save still out is stale. */\n      if (openRef.current) reset();\n      writeText(el, value);\n      setEmpty(value.length === 0);\n    }\n    wasEditingRef.current = editing;\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [editing, value]);\n\n  function currentText(): string {\n    return elRef.current ? readText(elRef.current) : \"\";\n  }\n\n  usePlainTextInsertion(elRef, lineMode, handleTextMutated);\n\n  /** The self-opening path — a click, Enter or F2. Never under controlled activation. */\n  function begin() {\n    if (controlled || unavailable || editing || pending) return;\n    setEditing(true);\n  }\n\n  /** End the session and drop every piece of in-edit state. Does not, by itself, change `editing`. */\n  function reset() {\n    openRef.current = false;\n    session.end();\n    autosave.reset();\n  }\n\n  function close() {\n    reset();\n    setEditing(false);\n  }\n\n  function commit() {\n    if (composingRef.current) return;\n    session.commit(currentText(), validate);\n  }\n\n  function handleTextMutated() {\n    if (composingRef.current) return;\n    const text = currentText();\n    setEmpty(text.length === 0);\n    /* Live validity replaces the refusal slot on every keystroke — see\n       `liveValidate`'s own doc. `null` when there is no live check, or the\n       text currently reads as fine, clears whatever was shown before. */\n    session.setRefusal(liveValidate?.(text) ?? null);\n    session.clearFailure();\n    autosave.noteText(text);\n  }\n\n  function handleCompositionStart() {\n    composingRef.current = true;\n  }\n\n  function handleCompositionEnd() {\n    composingRef.current = false;\n    handleTextMutated();\n  }\n\n  function handleKeyDown(event: React.KeyboardEvent<HTMLElement>) {\n    if (!editing) {\n      if (unavailable || controlled) return;\n      if (event.key === \"Enter\" || event.key === \"F2\") {\n        event.preventDefault();\n        begin();\n      }\n      return;\n    }\n    if (composingRef.current || event.nativeEvent.isComposing) return;\n    if (event.key === \"Escape\") handleEscape(event);\n    else if (event.key === \"Enter\") handleEnter(event);\n  }\n\n  function handleEscape(event: React.KeyboardEvent<HTMLElement>) {\n    /* Escape during a save is a no-op, not a cancel — the write is already\n       in flight. */\n    if (pending) return;\n    event.preventDefault();\n    if (autosave.enabled && autosave.cancel()) return;\n    close();\n  }\n\n  function handleEnter(event: React.KeyboardEvent<HTMLElement>) {\n    /* EVERY Enter is owned here — never the browser's own paragraph-insertion.\n       See the module comment (\"KEYBOARD, INSERTION, IME\"). */\n    event.preventDefault();\n    /* A frozen autosave field is already on its way out (commit or cancel);\n       a second Enter must not turn a pending cancel into a commit. */\n    if (autosave.enabled && pending) return;\n    const finish = autosave.enabled ? () => autosave.save(\"commit\") : commit;\n    if (!growsMultiline) {\n      if (!event.shiftKey) finish();\n      return;\n    }\n    /* Autosave moves multiline's commit key to plain Enter; Shift+Enter is\n       the newline. See \"AUTOSAVE\" above. */\n    if (event.metaKey || event.ctrlKey || (autosave.enabled && !event.shiftKey)) {\n      finish();\n      return;\n    }\n    const el = elRef.current;\n    if (el) insertTextAtCaret(el, \"\\n\");\n    handleTextMutated();\n  }\n\n  function handleBlur() {\n    if (!openRef.current || pending || composingRef.current) return;\n    /* BLUR DOES NOT RE-ATTEMPT A VALUE THAT WAS JUST REFUSED OR FAILED — it\n       would refuse identically and the field could never be left. */\n    if (blocked !== null) return;\n    if (autosave.enabled) autosave.save(\"commit\");\n    else commit();\n  }\n\n  const describedBy =\n    [blocked !== null ? messageId : null, unavailable ? reasonId : null].filter(Boolean).join(\" \") ||\n    undefined;\n\n  const control = useRender({\n    render,\n    ref: mergeRef,\n    // I18N-ALLOW: DOM tag name handed to the Base UI render slot\n    defaultTagName: \"div\",\n    props: {\n      role: \"textbox\",\n      \"aria-label\": label,\n      /* Not for `\"wrap\"` — ARIA's `aria-multiline` tells assistive tech Enter\n         inserts a line break, which is exactly what `\"wrap\"` does NOT do\n         (its Enter commits, same as `\"single\"`). Only `\"multiline\"` changes\n         that key, so only `\"multiline\"` earns the attribute. */\n      \"aria-multiline\": growsMultiline || undefined,\n      \"aria-describedby\": describedBy,\n      \"aria-disabled\": unavailable || undefined,\n      \"aria-invalid\": refusal !== null || undefined,\n      \"aria-busy\": pending || undefined,\n      \"aria-placeholder\": placeholder,\n      \"aria-readonly\": !editing || pending || undefined,\n      /* Controlled and at rest, the trigger is the one tab stop (DX-3372). */\n      tabIndex: controlled && !editing ? -1 : 0,\n      contentEditable: editing && !pending,\n      suppressContentEditableWarning: true,\n      spellCheck: editing,\n      inputMode,\n      \"data-slot\": \"inline-edit\",\n      \"data-editing\": editing || undefined,\n      className: cn(\n        s.box(),\n        stateClass({ editing, controlled, unavailable, pending, refused: refusal !== null }),\n        overflowClass(lineMode, editing),\n        className,\n      ),\n      onClick: begin,\n      onKeyDown: handleKeyDown,\n      onBlur: handleBlur,\n      onInput: handleTextMutated,\n      onCompositionStart: handleCompositionStart,\n      onCompositionEnd: handleCompositionEnd,\n      children: undefined,\n    },\n  });\n\n  const withPlaceholder = (\n    <div className=\"relative w-full min-w-0\">\n      {control}\n      {empty && (\n        <span aria-hidden=\"true\" className={cn(s.box(), s.placeholder())}>\n          {placeholder}\n        </span>\n      )}\n      {(pending || autosave.saving) && (\n        <span className={s.spinner()} data-slot=\"inline-edit-saving\">\n          <Spinner size=\"sm\" />\n        </span>\n      )}\n      {autosave.enabled && (\n        /* A background save changes nothing a screen reader can see — the\n           text is where it was — so it is announced instead. */\n        <span role=\"status\" className=\"sr-only\">\n          {autosave.saving || pending ? strings.saving : \"\"}\n        </span>\n      )}\n      {unavailable && (\n        <span id={reasonId} className=\"sr-only\">\n          {readOnly.reason}\n        </span>\n      )}\n      {blocked !== null && (\n        <OutcomeMessage id={messageId} className={messageClassName}>\n          {blocked}\n        </OutcomeMessage>\n      )}\n    </div>\n  );\n\n  if (!unavailable) return withPlaceholder;\n\n  /* The tooltip is the visual twin of the `sr-only` reason above, never the\n     accessibility story — same call 5.2.1 made. */\n  return <Tooltip content={readOnly.reason}>{withPlaceholder}</Tooltip>;\n}\n\nfunction stateClass({\n  editing,\n  controlled,\n  unavailable,\n  pending,\n  refused,\n}: {\n  editing: boolean;\n  controlled: boolean;\n  unavailable: boolean;\n  pending: boolean;\n  refused: boolean;\n}): string {\n  if (editing) {\n    return cn(\n      \"border-field-border bg-field text-primary\",\n      \"focus:outline-none focus:shadow-[0_0_0_3px_var(--control-focus-halo)]\",\n      pending && \"cursor-wait bg-surface-sunken\",\n      refused && \"border-danger\",\n    );\n  }\n  return cn(\n    \"border-transparent bg-transparent text-primary\",\n    /* Under controlled activation the text at rest is READ-ONLY and says so:\n       no hover fill, no text cursor, because clicking it does nothing — the\n       trigger beside it is the way in (DX-3372). */\n    controlled ? \"cursor-auto\" : \"hover:border-field-border hover:bg-surface-active\",\n    \"focus-visible:border-control focus-visible:bg-field focus-visible:outline-none\",\n    \"focus-visible:shadow-[0_0_0_3px_var(--control-focus-halo)]\",\n    unavailable && [\"cursor-not-allowed\", \"hover:border-transparent hover:bg-transparent\"],\n  );\n}\n\n/* `\"single\"` TRUNCATES at rest (a value wrapping to a second line would make\n   the display taller than a one-line field, so the no-shift guarantee would\n   only hold for values short enough to fit) and, while editing, never wraps\n   but scrolls instead — the browser keeps the caret in view. `\"multiline\"`\n   wraps in both states, growing together, and its `pre-wrap` also preserves\n   the \"\\n\" characters it can contain. `\"wrap\"` wraps in both states exactly\n   like `\"multiline\"` — that is its entire purpose — but plain `whitespace-\n   normal` rather than `pre-wrap`: DX-3388's contract is that its committed\n   value never contains \"\\n\" in the first place, so there is nothing for\n   `pre-wrap` to need to preserve, and `normal` collapses any incidental\n   run of spaces (e.g. two newlines normalised to two spaces) the way a\n   reader expects a single line of prose to. */\nfunction overflowClass(lineMode: \"single\" | \"wrap\" | \"multiline\", editing: boolean): string {\n  if (lineMode === \"multiline\") return \"whitespace-pre-wrap break-words\";\n  if (lineMode === \"wrap\") return \"whitespace-normal break-words\";\n  // I18N-ALLOW: CSS utility classes chosen by the edit state\n  return editing ? \"whitespace-nowrap overflow-x-auto\" : \"truncate\";\n}\n"],"names":["inlineEdit","tv","readText","el","writeText","text","placeCaretAtEnd","selection","range","last","end","insertTextAtCaret","node","RICH_INSERT_INPUT_TYPES","normalizeInsertedText","raw","lineMode","usePlainTextInsertion","elRef","onMutated","mutated","useRef","useEffect","onNativeBeforeInput","nativeEvent","target","useAutosave","delayMs","session","openRef","composingRef","props","enabled","saving","setSaving","useState","timerRef","committedRef","draftRef","afterRef","unmountedRef","latest","clearTimer","send","next","error","inFlight","seed","value","reset","noteText","save","drainAfter","after","queue","wasIdle","mode","local","token","outcome","isPromise","landed","result","isRefusal","sent","accepted","superseded","cancel","InlineEdit","onCommit","validate","liveValidate","label","placeholderProp","size","autosaveMs","commitMode","readOnly","onError","editingProp","onEditingChange","render","className","messageClassName","inputMode","ref","assertActivationPair","strings","keyNames","useUiStrings","placeholder","growsMultiline","failureMessage","chordLabel","s","controlled","editingRequested","setEditing","useControllable","empty","setEmpty","wasEditingRef","useEditSession","close","autosave","pending","refusal","blocked","reasonId","useId","messageId","unavailable","editing","mergeRef","startText","currentText","handleTextMutated","begin","commit","handleCompositionStart","handleCompositionEnd","handleKeyDown","event","handleEscape","handleEnter","finish","handleBlur","describedBy","control","useRender","cn","stateClass","overflowClass","withPlaceholder","jsxs","jsx","Spinner","OutcomeMessage","Tooltip","refused"],"mappings":";;;;;;;;;;;;;AA4RA,MAAMA,KAAaC,GAAG;AAAA,EACpB,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,IAKL,KAAK;AAAA,MACH;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMF,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOT,aAAa;AAAA,EAAA;AAAA,EAEf,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAiBR,MAAM;AAAA,MACJ,IAAI,EAAE,KAAK,8CAAA;AAAA,MACX,IAAI,EAAE,KAAK,yCAAA;AAAA,MACX,IAAI,EAAE,KAAK,yDAAA;AAAA,IAAyD;AAAA,EACtE;AAAA,EAEF,iBAAiB,EAAE,MAAM,KAAA;AAC3B,CAAC;AA6MD,SAASC,GAASC,GAAyB;AACzC,SAAOA,EAAG,eAAe;AAC3B;AACA,SAASC,GAAUD,GAAiBE,GAAc;AAChD,EAAAF,EAAG,cAAcE;AACnB;AAGA,SAASC,GAAgBH,GAAiB;AACxC,QAAMI,IAAY,OAAO,aAAA;AACzB,MAAI,CAACA,EAAW;AAChB,QAAMC,IAAQ,SAAS,YAAA,GAQjBC,IAAON,EAAG;AAChB,MAAIM,KAAQA,EAAK,aAAa,KAAK,WAAW;AAC5C,UAAMC,IAAMD,EAAK,aAAa,UAAU;AACxC,IAAAD,EAAM,SAASC,GAAMC,CAAG,GACxBF,EAAM,OAAOC,GAAMC,CAAG;AAAA,EACxB;AACE,IAAAF,EAAM,mBAAmBL,CAAE,GAC3BK,EAAM,SAAS,EAAK;AAEtB,EAAAD,EAAU,gBAAA,GACVA,EAAU,SAASC,CAAK;AAC1B;AAYA,SAASG,GAAkBR,GAAiBE,GAAc;AACxD,QAAME,IAAY,OAAO,aAAA;AACzB,MAAI,CAACA,KAAaA,EAAU,eAAe,KAAK,CAACJ,EAAG,SAASI,EAAU,UAAU,GAAG;AAGlF,IAAAJ,EAAG,YAAY,SAAS,eAAeE,CAAI,CAAC,GAC5CC,GAAgBH,CAAE;AAClB;AAAA,EACF;AACA,QAAMK,IAAQD,EAAU,WAAW,CAAC;AACpC,EAAAC,EAAM,eAAA;AACN,QAAMI,IAAO,SAAS,eAAeP,CAAI;AACzC,EAAAG,EAAM,WAAWI,CAAI,GACrBJ,EAAM,cAAcI,CAAI,GACxBJ,EAAM,YAAYI,CAAI,GACtBL,EAAU,gBAAA,GACVA,EAAU,SAASC,CAAK,GACxBL,EAAG,UAAA;AACL;AAiBA,MAAMU,yBAA8B,IAAI;AAAA,EACtC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAwBD,SAASC,GAAsBC,GAAaC,GAAmD;AAC7F,SAAIA,MAAa,cAAoBD,IACjCC,MAAa,SAAeD,EAAI,QAAQ,eAAe,GAAG,IACvDA,EAAI,QAAQ,eAAe,EAAE;AACtC;AAEA,SAASE,GACPC,GACAF,GACAG,GACA;AACA,QAAMC,IAAUC,EAAOF,CAAS;AAChC,EAAAC,EAAQ,UAAUD,GAClBG,EAAU,MAAM;AACd,UAAMnB,IAAKe,EAAM;AACjB,QAAI,CAACf,EAAI;AACT,aAASoB,EAAoBC,GAAyB;AACpD,UAAI,CAACX,GAAwB,IAAIW,EAAY,SAAS,EAAG;AACzD,MAAAA,EAAY,eAAA;AACZ,YAAMC,IAASP,EAAM;AACrB,UAAI,CAACO,EAAQ;AACb,YAAMV,IAAMS,EAAY,cAAc,QAAQ,YAAY,KAAKA,EAAY,QAAQ,IAC7EnB,IAAOS,GAAsBC,GAAKC,CAAQ;AAChD,MAAAL,GAAkBc,GAAQpB,CAAI,GAC9Be,EAAQ,QAAA;AAAA,IACV;AACA,WAAAjB,EAAG,iBAAiB,eAAeoB,CAAmB,GAC/C,MAAMpB,EAAG,oBAAoB,eAAeoB,CAAmB;AAAA,EACxE,GAAG,CAACL,GAAOF,CAAQ,CAAC;AACtB;AAyBA,SAASU,GAAY,EAAE,SAAAC,GAAS,SAAAC,GAAS,OAAAV,GAAO,SAAAW,GAAS,cAAAC,GAAc,GAAGC,KAA0B;AAClG,QAAMC,IAAUL,MAAY,QACtB,CAACM,GAAQC,CAAS,IAAIC,GAAS,EAAK,GACpCC,IAAWf,EAA6C,IAAI,GAG5DgB,IAAehB,EAAO,EAAE,GAExBiB,IAAWjB,EAAO,EAAE,GAIpBkB,IAAWlB,EAA8C,MAAM,GAI/DmB,IAAenB,EAAO,EAAK,GAC3BoB,IAASpB,EAAOU,CAAK;AAC3B,EAAAU,EAAO,UAAUV;AAEjB,WAASW,IAAa;AACpB,IAAIN,EAAS,YAAY,SACzB,aAAaA,EAAS,OAAO,GAC7BA,EAAS,UAAU;AAAA,EACrB;AAMA,EAAAd;AAAA,IACE,MAAM,MAAM;AAEV,UADAkB,EAAa,UAAU,IACnBJ,EAAS,YAAY,KAAM;AAC/B,MAAAM,EAAA;AACA,YAAMC,IAAO,MAAM;AACjB,cAAMC,IAAON,EAAS;AACtB,YAAIM,MAASP,EAAa,WACtBI,EAAO,QAAQ,WAAWG,CAAI,KAAK;AACvC,cAAI;AACF,YAAK,QAAQ,QAAQH,EAAO,QAAQ,SAASG,GAAMP,EAAa,OAAO,CAAC,EAAE;AAAA,cAAM,CAACQ,MAC/EJ,EAAO,QAAQ,UAAUI,CAAK;AAAA,YAAA;AAAA,UAElC,SAASA,GAAO;AACd,YAAAJ,EAAO,QAAQ,UAAUI,CAAK;AAAA,UAChC;AAAA,MACF,GACMC,IAAWlB,EAAQ,SAAA;AACzB,MAAIkB,IAAeA,EAAS,KAAKH,CAAI,IAChCA,EAAA;AAAA,IACP;AAAA;AAAA,IAEA,CAAA;AAAA,EAAC;AAIH,WAASI,EAAKC,GAAe;AAC3B,IAAAN,EAAA,GACAL,EAAa,UAAUW,GACvBV,EAAS,UAAUU,GACnBT,EAAS,UAAU;AAAA,EACrB;AAGA,WAASU,IAAQ;AACf,IAAAP,EAAA,GACAH,EAAS,UAAU,QACnBL,EAAU,EAAK;AAAA,EACjB;AAGA,WAASgB,EAAS7C,GAAc;AAE9B,IADAiC,EAAS,UAAUjC,GACf,GAAC2B,KAAW,CAACH,EAAQ,aACzBa,EAAA,GACAN,EAAS,UAAU,WAAW,MAAM;AAClC,MAAAA,EAAS,UAAU,MACnBe,EAAK,UAAU;AAAA,IACjB,GAAGxB,CAAO;AAAA,EACZ;AAGA,WAASyB,IAAa;AACpB,UAAMC,IAAQd,EAAS;AACvB,IAAAA,EAAS,UAAU,QACfc,MAAU,WAAUZ,EAAO,QAAQ,MAAA,IAC9BY,MAAU,WAAUF,EAAK,QAAQ,IACjCE,MAAU,UAAQF,EAAK,UAAU;AAAA,EAC5C;AAGA,WAASG,EAAMV,GAAoC;AACjD,UAAMW,IAAUhB,EAAS,YAAY;AACrC,IAAIK,MAAS,UAAU,CAACW,MACxBhB,EAAS,UAAUK,GACfA,MAAS,UAAQhB,EAAQ,WAAW,EAAI,GAIxC2B,KAAS3B,EAAQ,SAASwB,CAAU;AAAA,EAC1C;AAOA,WAASD,EAAKK,GAA6B;AAEzC,QADAd,EAAA,GACIZ,EAAa,QAAS;AAC1B,QAAIF,EAAQ,QAAQ;AAClB,MAAA0B,EAAME,MAAS,WAAW,WAAW,MAAM;AAC3C;AAAA,IACF;AACA,UAAMZ,IAAO1B,EAAM,UAAUhB,GAASgB,EAAM,OAAO,IAAIoB,EAAS;AAEhE,QADAA,EAAS,UAAUM,GACfA,MAASP,EAAa,SAAS;AACjC,MAAImB,MAAS,YAAUf,EAAO,QAAQ,MAAA;AACtC;AAAA,IACF;AACA,UAAMgB,IAAQhB,EAAO,QAAQ,WAAWG,CAAI,KAAK;AACjD,QAAIa,MAAU,MAAM;AAClB,MAAA7B,EAAQ,OAAO6B,GAAO,UAAU;AAChC;AAAA,IACF;AACA,UAAMC,IAAQ9B,EAAQ,MAAA;AACtB,QAAI+B;AACJ,QAAI;AACF,MAAAA,IAAUlB,EAAO,QAAQ,SAASG,GAAMP,EAAa,OAAO;AAAA,IAC9D,SAASQ,GAAO;AACd,MAAAjB,EAAQ,KAAKiB,CAAK;AAClB;AAAA,IACF;AACA,QAAI,CAACe,GAAUD,CAAO,GAAG;AACvB,MAAAE,EAAOjB,GAAMY,GAAM,EAAE,SAAAG,EAAA,CAAS;AAC9B;AAAA,IACF;AACA,IAAIH,MAAS,WAAU5B,EAAQ,WAAW,EAAI,MAC/B,EAAI,GACnBA,EAAQ;AAAA,MACN+B;AAAA,MACAD;AAAA,MACA,CAACI,MAAWD,EAAOjB,GAAMY,GAAMM,CAAM;AAAA,MACrC,CAACA,MAAW;AACV,QAAItB,EAAa,WAAW,aAAasB,KAAU,CAACC,EAAUD,EAAO,OAAO,MAAGzB,EAAa,UAAUO;AAAA,MACxG;AAAA,IAAA;AAAA,EAEJ;AAGA,WAASiB,EAAOG,GAAcR,GAA6BM,GAAoB;AAC7E,IAAA5B,EAAU,EAAK;AACf,UAAM+B,IAAW,aAAaH,KAAU,CAACC,EAAUD,EAAO,OAAO;AACjE,IAAIG,QAAuB,UAAUD;AAErC,UAAMX,IAAQd,EAAS;AAEvB,QADAA,EAAS,UAAU,QACfc,MAAU,UAAU;AAGtB,MAAI,WAAWS,KAAQrB,EAAO,QAAQ,UAAUqB,EAAO,KAAK,GAC5DrB,EAAO,QAAQ,MAAA;AACf;AAAA,IACF;AAKA,UAAMyB,IAAa5B,EAAS,YAAY0B;AACxC,QAAI,CAACC,KAAY,CAACC,GAAY;AAC5B,MAAI,WAAWJ,IAAQlC,EAAQ,KAAKkC,EAAO,KAAK,IACvCC,EAAUD,EAAO,OAAO,OAAW,OAAOA,EAAO,QAAQ,SAAS,UAAU;AACrF;AAAA,IACF;AAEA,QAAIN,MAAS,YAAYH,MAAU,UAAU;AAC3C,MAAAF,EAAK,QAAQ;AACb;AAAA,IACF;AAIA,IAAIe,KAAc9B,EAAS,YAAY,UAAW,UAAU;AAAA,EAC9D;AAQA,WAAS+B,IAAkB;AAEzB,WADAzB,EAAA,GACKd,EAAQ,KAAA,KACb0B,EAAM,QAAQ,GACP,MAFqB;AAAA,EAG9B;AAEA,SAAO,EAAE,SAAAtB,GAAS,QAAAC,GAAQ,MAAAc,GAAM,OAAAE,GAAO,UAAAC,GAAU,MAAAC,GAAM,QAAAgB,EAAA;AACzD;AAEO,SAASC,GAAWrC,GAAwB;AACjD,QAAM;AAAA,IACJ,OAAAiB;AAAA,IACA,UAAAqB;AAAA,IACA,UAAAC;AAAA,IACA,cAAAC;AAAA,IACA,OAAAC;AAAA,IACA,aAAaC;AAAA,IACb,MAAAC,IAAO;AAAA,IACP,UAAA1D,IAAW;AAAA,IACX,YAAA2D;AAAA,IACA,YAAAC;AAAA,IACA,UAAAC;AAAA,IACA,SAAAC;AAAA,IACA,SAASC;AAAA,IACT,iBAAAC;AAAA,IACA,QAAAC;AAAA,IACA,WAAAC;AAAA,IACA,kBAAAC;AAAA,IACA,WAAAC;AAAA,IACA,KAAAC;AAAA,EAAA,IACEtD;AACJ,MAAI4C,MAAe,UAAa,EAAE,OAAO,SAASA,CAAU,KAAKA,IAAa;AAC5E,UAAM,IAAI;AAAA,MACR,yEAAyE,OAAOA,CAAU,CAAC;AAAA,IAAA;AAI/F,MAAIC,MAAe,WAAWD,MAAe;AAC3C,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAIJ,EAAAW,GAAqB,cAAcP,GAAaC,CAAe;AAC/D,QAAM,EAAE,YAAYO,GAAS,UAAAC,EAAA,IAAaC,GAAA,GACpCC,IAAcjB,KAAmBc,EAAQ,OAIzCI,IAAiB3E,MAAa,aAE9B4E,IACJ7D,EAAM;AAAA,EAENwD,EAAQ,QAAQM,GAAWF,KAAkBhB,MAAe,SAAY,eAAe,SAASa,CAAQ,CAAC,GACrGM,IAAI9F,GAAW,EAAE,MAAA0E,GAAM,GAIvBqB,IAAahB,MAAgB,QAC7B,CAACiB,GAAkBC,CAAU,IAAIC,GAAgBnB,GAAa,IAAOC,CAAe,GACpF,CAACmB,GAAOC,CAAQ,IAAIjE,GAASa,EAAM,WAAW,CAAC,GAE/C9B,IAAQG,EAA2B,IAAI,GAIvCQ,IAAUR,EAAO,EAAK,GAKtBS,IAAeT,EAAO,EAAK,GAI3BgF,IAAgBhF,EAAO,EAAK,GAE5BO,IAAU0E,GAAe;AAAA,IAC7B,WAAW;AAAA,IACX,OAAAtD;AAAA,IACA,UAAAqB;AAAA,IACA,SAAAS;AAAA,IACA,gBAAAc;AAAA,IACA,OAAAW;AAAA,IACA,SAAS,MAAMrF,EAAM,SAAS,MAAA;AAAA,IAC9B,YAAA0D;AAAA,IACA,QAAQ,MAAMqB,EAAW,EAAI;AAAA,EAAA,CAC9B,GACKO,IAAW9E,GAAY;AAAA,IAC3B,SAASiD;AAAA,IACT,SAAA/C;AAAA,IACA,OAAAV;AAAA,IACA,SAAAW;AAAA,IACA,cAAAC;AAAA,IACA,UAAAwC;AAAA,IACA,UAAAD;AAAA,IACA,SAAAS;AAAA,IACA,OAAAyB;AAAA,EAAA,CACD,GACK,EAAE,SAAAE,GAAS,SAAAC,GAAS,SAAAC,EAAA,IAAY/E,GAEhCgF,IAAWC,GAAA,GACXC,IAAYD,GAAA,GAEZE,IAAclC,MAAa,QAG3BmC,IAAUhB,KAAoB,CAACe;AAKrC,EAAAzF,EAAU,MAAM;AACd,IAAIyE,KAAcC,KAAoBe,KAAad,EAAW,EAAK;AAAA,EACrE,GAAG,CAACF,GAAYC,GAAkBe,GAAad,CAAU,CAAC;AAE1D,WAASgB,GAASrG,GAA0B;AAC1C,IAAAM,EAAM,UAAUN,GACZ,OAAOyE,KAAQ,aAAYA,EAAIzE,CAAI,IAC9ByE,MAAMA,EAAwC,UAAUzE;AAAA,EACnE;AAUA,EAAAU,EAAU,MAAM;AACd,UAAMnB,IAAKe,EAAM;AACjB,QAAI,CAACf,EAAI;AAET,QADqB6G,KAAW,CAACX,EAAc,SAC7B;AAKhB,YAAMa,IAAYtF,EAAQ,MAAMoB,GAAOuB,IAAevB,CAAK,KAAK,IAAI;AACpE,MAAAwD,EAAS,KAAKxD,CAAK,GACnBnB,EAAQ,UAAU,IAClBzB,GAAUD,GAAI+G,CAAS,GACvB5G,GAAgBH,CAAE,GAClBA,EAAG,MAAA,GACHiG,EAASc,EAAU,WAAW,CAAC;AAAA,IACjC,MAAA,CAAYF,MAINnF,EAAQ,WAASoB,GAAA,GACrB7C,GAAUD,GAAI6C,CAAK,GACnBoD,EAASpD,EAAM,WAAW,CAAC;AAE7B,IAAAqD,EAAc,UAAUW;AAAA,EAE1B,GAAG,CAACA,GAAShE,CAAK,CAAC;AAEnB,WAASmE,KAAsB;AAC7B,WAAOjG,EAAM,UAAUhB,GAASgB,EAAM,OAAO,IAAI;AAAA,EACnD;AAEA,EAAAD,GAAsBC,GAAOF,GAAUoG,CAAiB;AAGxD,WAASC,KAAQ;AACf,IAAItB,KAAcgB,KAAeC,KAAWP,KAC5CR,EAAW,EAAI;AAAA,EACjB;AAGA,WAAShD,KAAQ;AACf,IAAApB,EAAQ,UAAU,IAClBD,EAAQ,IAAA,GACR4E,EAAS,MAAA;AAAA,EACX;AAEA,WAASD,IAAQ;AACf,IAAAtD,GAAA,GACAgD,EAAW,EAAK;AAAA,EAClB;AAEA,WAASqB,KAAS;AAChB,IAAIxF,EAAa,WACjBF,EAAQ,OAAOuF,GAAA,GAAe7C,CAAQ;AAAA,EACxC;AAEA,WAAS8C,IAAoB;AAC3B,QAAItF,EAAa,QAAS;AAC1B,UAAMzB,IAAO8G,GAAA;AACb,IAAAf,EAAS/F,EAAK,WAAW,CAAC,GAI1BuB,EAAQ,WAAW2C,IAAelE,CAAI,KAAK,IAAI,GAC/CuB,EAAQ,aAAA,GACR4E,EAAS,SAASnG,CAAI;AAAA,EACxB;AAEA,WAASkH,KAAyB;AAChC,IAAAzF,EAAa,UAAU;AAAA,EACzB;AAEA,WAAS0F,KAAuB;AAC9B,IAAA1F,EAAa,UAAU,IACvBsF,EAAA;AAAA,EACF;AAEA,WAASK,GAAcC,GAAyC;AAC9D,QAAI,CAACV,GAAS;AACZ,UAAID,KAAehB,EAAY;AAC/B,OAAI2B,EAAM,QAAQ,WAAWA,EAAM,QAAQ,UACzCA,EAAM,eAAA,GACNL,GAAA;AAEF;AAAA,IACF;AACA,IAAIvF,EAAa,WAAW4F,EAAM,YAAY,gBAC1CA,EAAM,QAAQ,WAAUC,GAAaD,CAAK,IACrCA,EAAM,QAAQ,WAASE,GAAYF,CAAK;AAAA,EACnD;AAEA,WAASC,GAAaD,GAAyC;AAG7D,IAAIjB,MACJiB,EAAM,eAAA,GACF,EAAAlB,EAAS,WAAWA,EAAS,OAAA,MACjCD,EAAA;AAAA,EACF;AAEA,WAASqB,GAAYF,GAAyC;AAM5D,QAHAA,EAAM,eAAA,GAGFlB,EAAS,WAAWC,EAAS;AACjC,UAAMoB,IAASrB,EAAS,UAAU,MAAMA,EAAS,KAAK,QAAQ,IAAIc;AAClE,QAAI,CAAC3B,GAAgB;AACnB,MAAK+B,EAAM,YAAUG,EAAA;AACrB;AAAA,IACF;AAGA,QAAIH,EAAM,WAAWA,EAAM,WAAYlB,EAAS,WAAW,CAACkB,EAAM,UAAW;AAC3E,MAAAG,EAAA;AACA;AAAA,IACF;AACA,UAAM1H,IAAKe,EAAM;AACjB,IAAIf,KAAIQ,GAAkBR,GAAI;AAAA,CAAI,GAClCiH,EAAA;AAAA,EACF;AAEA,WAASU,KAAa;AACpB,IAAI,CAACjG,EAAQ,WAAW4E,KAAW3E,EAAa,WAG5C6E,MAAY,SACZH,EAAS,UAASA,EAAS,KAAK,QAAQ,IACvCc,GAAA;AAAA,EACP;AAEA,QAAMS,KACJ,CAACpB,MAAY,OAAOG,IAAY,MAAMC,IAAcH,IAAW,IAAI,EAAE,OAAO,OAAO,EAAE,KAAK,GAAG,KAC7F,QAEIoB,KAAUC,GAAU;AAAA,IACxB,QAAAhD;AAAA,IACA,KAAKgC;AAAA;AAAA,IAEL,gBAAgB;AAAA,IAChB,OAAO;AAAA,MACL,MAAM;AAAA,MACN,cAAczC;AAAA;AAAA;AAAA;AAAA;AAAA,MAKd,kBAAkBmB,KAAkB;AAAA,MACpC,oBAAoBoC;AAAA,MACpB,iBAAiBhB,KAAe;AAAA,MAChC,gBAAgBL,MAAY,QAAQ;AAAA,MACpC,aAAaD,KAAW;AAAA,MACxB,oBAAoBf;AAAA,MACpB,iBAAiB,CAACsB,KAAWP,KAAW;AAAA;AAAA,MAExC,UAAUV,KAAc,CAACiB,IAAU,KAAK;AAAA,MACxC,iBAAiBA,KAAW,CAACP;AAAA,MAC7B,gCAAgC;AAAA,MAChC,YAAYO;AAAA,MACZ,WAAA5B;AAAA,MACA,aAAa;AAAA,MACb,gBAAgB4B,KAAW;AAAA,MAC3B,WAAWkB;AAAA,QACTpC,EAAE,IAAA;AAAA,QACFqC,GAAW,EAAE,SAAAnB,GAAS,YAAAjB,GAAY,aAAAgB,GAAa,SAAAN,GAAS,SAASC,MAAY,MAAM;AAAA,QACnF0B,GAAcpH,GAAUgG,CAAO;AAAA,QAC/B9B;AAAA,MAAA;AAAA,MAEF,SAASmC;AAAA,MACT,WAAWI;AAAA,MACX,QAAQK;AAAA,MACR,SAASV;AAAA,MACT,oBAAoBG;AAAA,MACpB,kBAAkBC;AAAA,MAClB,UAAU;AAAA,IAAA;AAAA,EACZ,CACD,GAEKa,KACJ,gBAAAC,GAAC,OAAA,EAAI,WAAU,2BACZ,UAAA;AAAA,IAAAN;AAAA,IACA7B,KACC,gBAAAoC,EAAC,QAAA,EAAK,eAAY,QAAO,WAAWL,EAAGpC,EAAE,IAAA,GAAOA,EAAE,YAAA,CAAa,GAC5D,UAAAJ,GACH;AAAA,KAEAe,KAAWD,EAAS,WACpB,gBAAA+B,EAAC,UAAK,WAAWzC,EAAE,QAAA,GAAW,aAAU,sBACtC,UAAA,gBAAAyC,EAACC,IAAA,EAAQ,MAAK,MAAK,GACrB;AAAA,IAEDhC,EAAS;AAAA;AAAA,IAGR,gBAAA+B,EAAC,QAAA,EAAK,MAAK,UAAS,WAAU,WAC3B,UAAA/B,EAAS,UAAUC,IAAUlB,EAAQ,SAAS,GAAA,CACjD;AAAA,IAEDwB,uBACE,QAAA,EAAK,IAAIH,GAAU,WAAU,WAC3B,YAAS,OAAA,CACZ;AAAA,IAEDD,MAAY,QACX,gBAAA4B,EAACE,IAAA,EAAe,IAAI3B,GAAW,WAAW3B,GACvC,UAAAwB,EAAA,CACH;AAAA,EAAA,GAEJ;AAGF,SAAKI,IAIE,gBAAAwB,EAACG,IAAA,EAAQ,SAAS7D,EAAS,QAAS,UAAAwD,IAAgB,IAJlCA;AAK3B;AAEA,SAASF,GAAW;AAAA,EAClB,SAAAnB;AAAA,EACA,YAAAjB;AAAA,EACA,aAAAgB;AAAA,EACA,SAAAN;AAAA,EACA,SAAAkC;AACF,GAMW;AACT,SAAI3B,IACKkB;AAAA,IACL;AAAA,IACA;AAAA,IACAzB,KAAW;AAAA,IACXkC,KAAW;AAAA,EAAA,IAGRT;AAAA,IACL;AAAA;AAAA;AAAA;AAAA,IAIAnC,IAAa,gBAAgB;AAAA,IAC7B;AAAA,IACA;AAAA,IACAgB,KAAe,CAAC,sBAAsB,+CAA+C;AAAA,EAAA;AAEzF;AAcA,SAASqB,GAAcpH,GAA2CgG,GAA0B;AAC1F,SAAIhG,MAAa,cAAoB,oCACjCA,MAAa,SAAe,kCAEzBgG,IAAU,sCAAsC;AACzD;"}