{"version":3,"file":"web-pKMqmAwe.mjs","names":["createContext","PortalForwardedAttrs","ActionForm","ShrinkLadder","BarItemEntry","id","container","HTMLDivElement","ladder","Required","declaredRungs","holds","popupOpen","pointerPinned","immovable","BarRegistry","register","declare","hold","setPopupOpen","open","contentChanged","claimYield","cell","HTMLElement","yieldContentChanged","BarRegistryContext","NO_FORMS","ReadonlyMap","Map","BarFormsContext","NO_ATTRS","BarRegionAttrsContext","useCallback","useContext","useEffect","useLayoutEffect","useMemo","useRef","useState","ReactElement","ReactNode","createPortal","ActionFormProvider","ItemFormChannel","cn","useRegionForwardedAttrs","rigidClass","PopupOpenScope","renderMode","BarFormsContext","BarRegionAttrsContext","BarRegistryContext","BarRegistry","AdaptiveBarItemProps","id","className","children","AdaptiveBarItem","t0","$","_c","registry","t1","occupantClass","StaticBarItem","t2","PortaledBarItem","container","_temp","setAttribute","region","barAttrs","t3","Object","fromEntries","entries","filter","t4","key","value","forwarded","forms","get","form","t5","Symbol","for","stampedRef","t6","t7","key_0","current","removeAttribute","key_1","value_0","keys","t8","t9","observer","MutationObserver","contentChanged","observe","childList","subtree","characterData","release","register","disconnect","remove","t10","ladder","declare","declareLadder","t11","hold","t12","channel","t13","t14","popupOpen","t15","t16","t17","el","document","createElement","PopupPin","open","setPopupOpen","_c","_Fragment","_temp","defineReportSink","ConvergenceEvidence","AdaptiveBarOverflow","AdaptiveBarFaultKind","AdaptiveBarFault","kind","label","origin","originPath","overflow","message","item","id","rung","form","evidence","adaptiveBarReportSink","reportFault","fault","emit","failLoudly","import","meta","env","DEV","Error","WIDTH_EPSILON_PX","TRACE_ROUNDS","MAX_PREMISE_SHIFTS","HARD_ROUND_CEILING","MAX_SURRENDERS","MAX_SLACK_PROBES","MAX_ZERO_RECOVERIES","HYSTERESIS_PX","ActionForm","ShrinkLadder","YieldEagerness","DEFAULT_LADDER","Required","shrinksTo","yields","YIELD_RANK","Record","never","late","normal","early","yieldRankOf","ladder","inlineRungsOf","includes","formFor","rung","rungs","Math","min","max","length","createContext","useContext","useMemo","ReactElement","ReactNode","MeasureWidth","el","Element","domMeasureWidth","getBoundingClientRect","width","IsRendered","domIsRendered","getClientRects","length","MeasureBundle","measure","isRendered","DOM_MEASURE","alwaysRendered","MeasureContext","useMeasureBundle","useLayoutMeasured","AdaptiveBarMeasure","t0","$","_c","t1","children","undefined","t2","bundle","t3","RowMetrics","gapPx","insetPx","readRowMetrics","style","getComputedStyle","lengthPx","columnGap","paddingLeft","paddingRight","borderLeftWidth","borderRightWidth","raw","px","Number","parseFloat","isFinite","foreignCellCount","root","own","count","walk","parent","child","display","position","some","contains","useEffect","useState","ReactElement","autoUpdate","flip","offset","shift","useFloating","OverlayPanel","ViewportOverlay","PortalForwardedAttrs","Stack","OverflowPanelProps","open","anchor","HTMLElement","label","dockRef","el","regionAttrs","hasOpenChildPopup","onDismiss","OverflowPanel","t0","$","_c","floatingEl","setFloatingEl","t1","undefined","t2","t3","reference","floating","t4","Symbol","for","padding","t5","strategy","placement","whileElementsMounted","elements","middleware","floatingStyles","isPositioned","t6","t7","onKeyDown","e","key","onPointerDown","e_0","target","Node","contains","document","addEventListener","removeEventListener","t8","t9","t10","display","t11","t12","t13","t14","t15","t16","_c","planMoves","focusElement","MoveBeforeCapable","moveBefore","node","Node","child","asMoveBeforeCapable","parent","Element","candidate","Partial","undefined","supportsStatePreservingMove","prototype","holdsIframe","container","querySelector","ScrollShot","el","top","left","snapshotFragileState","active","document","activeElement","focused","HTMLElement","contains","scrolls","walk","scrollTop","scrollLeft","push","children","shot","reveal","relocateNode","before","capable","isConnected","restore","insertBefore","isDockedInline","anchor","nextSibling","dockInline","parentElement","Error","dockGroup","dock","wantIds","containerOf","id","want","Set","currentIds","getAttribute","has","moves","move","beforeId","length","useContext","useLayoutEffect","useRef","ReactElement","ReactNode","cn","yieldClass","fillClasses","BarRegistryContext","rendersNothing","YIELD_FLOOR_EM","MEDIUM_FONT_PX","yieldFloorPx","el","HTMLElement","fontPx","Number","parseFloat","getComputedStyle","fontSize","isFinite","YIELD_TO_SLACK_CLAIM","AdaptiveBarYieldProps","grow","children","className","AdaptiveBarYield","t0","$","_c","t1","undefined","registry","cellRef","t2","t3","cell","current","observer","MutationObserver","yieldContentChanged","observe","childList","release","claimYield","disconnect","t4","t5","cellClass","t6","_c","useCallback","useContext","useLayoutEffect","useMemo","useRef","useState","PointerEvent","ReactPointerEvent","ReactElement","ReactNode","assign","barRung","clearAbsentRungs","describeEvidence","dropItem","emptyBlockedRungs","emptyWidthCache","estimate","inlineWidthsFor","isAbsentRung","isShifted","markAbsentRung","noAbsentRungs","offeredRungCount","overflowPx","passBudget","premiseShift","pushRound","recordMoves","staleOthers","summarizeRounds","sweepBarred","unbarItem","write","AbsentRungs","BlockedRungs","FitItem","MovedWidth","Round","RoundItem","Span","WidthCache","formatLineageNode","formatLineagePath","collectLineage","ActionForm","ShrinkLadder","cn","SingleLineProvider","useRegionForwardedAttrs","SpaceStep","Stack","useRequestGrow","rigidClass","SlotItemLayout","useResizeObserver","IconButton","AdaptiveBarItem","failLoudly","reportFault","HARD_ROUND_CEILING","HYSTERESIS_PX","MAX_PREMISE_SHIFTS","MAX_SLACK_PROBES","MAX_SURRENDERS","MAX_ZERO_RECOVERIES","TRACE_ROUNDS","WIDTH_EPSILON_PX","DEFAULT_LADDER","formFor","inlineRungsOf","yieldRankOf","foreignCellCount","readRowMetrics","useLayoutMeasured","useMeasureBundle","OverflowPanel","BarFormsContext","BarRegionAttrsContext","BarRegistryContext","BarItemEntry","BarRegistry","dockGroup","dockInline","holdsIframe","isDockedInline","supportsStatePreservingMove","AdaptiveBarYield","yieldFloorPx","symbol","rendersNothing","moreHorizIcon","AdaptiveBarOverflow","AdaptiveBarAlign","AdaptiveBarBaseProps","gap","label","align","spill","children","className","AdaptiveBarProps","overflow","BAR_ROOT","BAR_CLIP","BAR_SCROLL","BAR_SPILL","BAR_COLLAPSED_ROOT","BAR_ALIGN_END","AdaptiveBar","props","$","_c","t0","t1","t2","t3","t4","undefined","t5","AdaptiveBarCollapsedProps","AdaptiveBarCollapsed","Item","Collapsed","Yield","relayNote","relays","String","Placement","ReadonlyMap","Surrender","surrendered","current","at","count","Episode","rounds","total","shifts","premise","trace","moved","Map","best","placement","available","promoted","rung","atWidth","newEpisode","EMPTY_PLACEMENT","rungOf","id","has","get","collapsedRungOf","AdaptiveBarShell","collapsed","measure","isRendered","layoutMeasured","parentBar","nestedInBar","grow","root","setRoot","trigger","setTrigger","panelDock","setPanelDock","parkingDock","setParkingDock","regionAttrs","setPlacement","panelOpen","setPanelOpen","degraded","setDegraded","effective","Symbol","for","entriesRef","version","setVersion","_temp","bump","yieldCellRef","yieldReservedRef","ladders","setLadders","_temp2","ladder","prev","next","delete","next_0","set","putLadder","cacheRef","blockedRef","absentRef","episodeRef","triggerWidthRef","slackVerifiedAtRef","slackProbesRef","zeroRecoveriesRef","overFullReportedRef","surrenderedRef","surrenderedAtRef","surrenderCountRef","surrender","t6","register","id_0","container","entry","declaredRungs","holds","popupOpen","pointerPinned","immovable","declare","id_1","ladder_0","entry_0","_temp3","rungs","join","live","hold","id_2","entry_1","_temp4","setPopupOpen","id_3","open","entry_2","contentChanged","id_4","entry_3","absent","hidden","claimYield","cell","Error","yieldContentChanged","cell_0","registry","map","id_5","ladder_1","forms","n","values","evictedCount","showTrigger","t7","granted","entries","anchors","querySelectorAll","order","anchor","id_6","getAttribute","entry_4","push","evicted","id_7","anchor_0","entry_5","absent_0","rung_0","evictionDock","id_8","length","present","filter","_temp5","lone","next_1","id_9","samePlacement","metrics","rowPx","insetPx","gestured","some","_temp6","Math","min","clear","kind","originOf","message","yieldFloor","foreignGapsPx","_temp7","_temp8","gapPx","budget","max","verifiedAt","unverified","inline","_temp9","_temp0","widthFollowsContent","surrenderedAt","resized","abs","startEpisode","triggerPx","measureTrigger","measured","id_10","anchor_3","entry_12","rung_1","form","item","px","known","rendersAgain","result","dockedInline","ok","cache","episode","round","shape","_temp1","items","previous","shift","id_12","entry_14","declaredRungs_0","rungCount","inlineWidths","evictable","yieldRank","pinned","currentRung","result_0","hysteresisPx","blocked","decided","placementKey","id_13","promotion","now","fits","usedEstimate","overflowingBy","measureRowOverflow","commitFloor","stopped","evidence","remedy","commitSurrender","id_14","from","to","reconcile","t8","observed","entry_15","t9","deps","t10","e","target","Node","entry_16","contains","release","document","removeEventListener","addEventListener","onPointerDownCapture","nestedReportedRef","t11","t12","t13","entry_17","t14","t15","rootClass","t16","t17","t18","t19","_temp10","t20","t21","t22","t23","t24","entry_18","t25","t26","t27","t28","open_0","id_11","entry_13","entry_11","anchor_2","entry_10","entry_9","anchor_1","entry_8","entry_7","entry_6","v","HTMLElement","el","Element","withContent","wasHidden","withoutContent","forEach","i","floor","sort","origin","originPath","nodes","innermost","path","pluginId","regionKind","a","b","size","value","Number","parseFloat","isFinite","rect","getBoundingClientRect","style","getComputedStyle","box","left","paddingLeft","borderLeftWidth","right","paddingRight","borderRightWidth","spans","addIfLaidOut","getClientRects","r","parentNode","_c","evictedCount","BarRegistryContext","createContext","BarFormsContext","BarRegionAttrsContext","$","c","t0","registry","useContext","t1","children","Fragment","renderMode","className","id","cn","rigidClass","t2","container","useState","useLayoutEffect","region","useRegionForwardedAttrs","barAttrs","t3","key","value","t4","forwarded","forms","form","t5","stampedRef","useRef","t7","key_0","key_1","value_0","t9","observer","release","ladder","declareLadder","hold","t12","channel","t13","t14","PopupOpenScope","popupOpen","t15","ActionFormProvider","t16","createPortal","t17","el","open","useEffect","adaptiveBarReportSink","defineReportSink","fault","WIDTH_EPSILON_PX","DEFAULT_LADDER","YIELD_RANK","rung","rungs","DOM_MEASURE","MeasureContext","style","px","raw","count","child","parent","own","root","floatingEl","setFloatingEl","autoUpdate","anchor","offset","flip","shift","useFloating","hasOpenChildPopup","onDismiss","onKeyDown","onPointerDown","target","e_0","t8","t10","floatingStyles","t11","isPositioned","dockRef","Stack","label","OverlayPanel","regionAttrs","ViewportOverlay","candidate","active","focused","scrolls","shot","capable","node","before","restore","want","wantIds","currentIds","dock","moves","planMoves","move","containerOf","YIELD_FLOOR_EM","MEDIUM_FONT_PX","fontPx","YIELD_TO_SLACK_CLAIM","grow","cellRef","cell","cellClass","fillClasses","yieldClass","t6","moreHorizIcon","symbol","BAR_ROOT","BAR_CLIP","BAR_SCROLL","BAR_SPILL","BAR_COLLAPSED_ROOT","BAR_ALIGN_END","props","gap","overflow","align","spill","relays","EMPTY_PLACEMENT","placement","layoutMeasured","parentBar","nestedInBar","collapsed","useRequestGrow","setRoot","trigger","setTrigger","panelDock","setPanelDock","parkingDock","setParkingDock","setPlacement","panelOpen","setPanelOpen","degraded","setDegraded","effective","entriesRef","version","setVersion","bump","yieldCellRef","yieldReservedRef","ladders","setLadders","prev","next","next_0","putLadder","cacheRef","emptyWidthCache","blockedRef","emptyBlockedRungs","absentRef","noAbsentRungs","episodeRef","triggerWidthRef","slackVerifiedAtRef","slackProbesRef","zeroRecoveriesRef","overFullReportedRef","surrenderedRef","surrenderedAtRef","surrenderCountRef","surrender","entry","id_0","dropItem","unbarItem","clearAbsentRungs","entry_0","id_1","ladder_0","live","entry_1","id_2","entry_2","id_3","entry_3","id_4","cell_0","map","id_5","ladder_1","n","showTrigger","isRendered","measure","entries","anchors","order","id_6","entry_4","evicted","id_7","anchor_0","entry_5","absent_0","evictionDock","id_8","present","lone","next_1","id_9","metrics","rowPx","available","yieldFloor","foreignGapsPx","budget","verifiedAt","inline","surrenderedAt","gapPx","triggerPx","measured","id_10","anchor_3","entry_12","rung_1","isAbsentRung","markAbsentRung","known","estimate","staleOthers","result","write","episode","round","previous","pushRound","premiseShift","isShifted","recordMoves","sweepBarred","items","id_12","entry_14","declaredRungs_0","rungCount","offeredRungCount","inlineWidthsFor","result_0","assign","id_13","promotion","now","barRung","overflowingBy","stopped","passBudget","evidence","summarizeRounds","remedy","describeEvidence","id_14","from","to","reconcile","observed","entry_15","useResizeObserver","entry_16","onPointerDownCapture","nestedReportedRef","entry_17","rootClass","SlotItemLayout","t18","t20","IconButton","t21","t22","t23","SingleLineProvider","entry_18","t26","t27","t28","open_0","id_11","entry_13","entry_11","anchor_2","entry_10","entry_9","anchor_1","entry_8","entry_7","entry_6","v","cache","wasHidden","withoutContent","i","withContent","atWidth","floor","item","evictable","best","nodes","collectLineage","innermost","path","formatLineagePath","formatLineageNode","a","b","rect","box","spans","r","overflowPx","web_default"],"sources":["../../../../../__A__/dev/singularity/.claude/worktrees/att-1794515063-e6dm4h/plugins/primitives/plugins/adaptive-bar/web/internal/registry.ts","../../../../../__A__/dev/singularity/.claude/worktrees/att-1794515063-e6dm4h/plugins/primitives/plugins/adaptive-bar/web/internal/bar-item.tsx","../../../../../__A__/dev/singularity/.claude/worktrees/att-1794515063-e6dm4h/plugins/primitives/plugins/adaptive-bar/web/internal/diagnostics.ts","../../../../../__A__/dev/singularity/.claude/worktrees/att-1794515063-e6dm4h/plugins/primitives/plugins/adaptive-bar/web/internal/ladder.ts","../../../../../__A__/dev/singularity/.claude/worktrees/att-1794515063-e6dm4h/plugins/primitives/plugins/adaptive-bar/web/internal/measure.tsx","../../../../../__A__/dev/singularity/.claude/worktrees/att-1794515063-e6dm4h/plugins/primitives/plugins/adaptive-bar/web/internal/overflow-panel.tsx","../../../../../__A__/dev/singularity/.claude/worktrees/att-1794515063-e6dm4h/plugins/primitives/plugins/adaptive-bar/web/internal/relocate.ts","../../../../../__A__/dev/singularity/.claude/worktrees/att-1794515063-e6dm4h/plugins/primitives/plugins/adaptive-bar/web/internal/presence.ts","../../../../../__A__/dev/singularity/.claude/worktrees/att-1794515063-e6dm4h/plugins/primitives/plugins/adaptive-bar/web/internal/bar-yield.tsx","../../../../../__A__/dev/singularity/.claude/worktrees/att-1794515063-e6dm4h/plugins/primitives/plugins/adaptive-bar/web/internal/adaptive-bar.tsx","../../../../../__A__/dev/singularity/.claude/worktrees/att-1794515063-e6dm4h/plugins/primitives/plugins/adaptive-bar/web/index.ts"],"sourcesContent":["import { createContext } from \"react\";\nimport type { PortalForwardedAttrs } from \"@plugins/primitives/plugins/css/plugins/ui-kit/web\";\nimport type {\n  ActionForm,\n  ShrinkLadder,\n} from \"@plugins/primitives/plugins/action-presentation/web\";\n\n/**\n * Everything the bar knows about one occupant, held OUTSIDE React state on\n * purpose.\n *\n * The bar's React state is the placement — the one thing a widget must\n * re-render to honour. Ladders, holds, popups and pointer locks are inputs to\n * the next decision, not outputs anyone renders, so routing them through\n * `useState` would re-render every occupant for a pointer-down that changes\n * nothing on screen.\n */\nexport interface BarItemEntry {\n  readonly id: string;\n  /** The item's one stable portal target, created once and owned for its whole life. */\n  readonly container: HTMLDivElement;\n  ladder: Required<ShrinkLadder>;\n  /**\n   * The inline rungs this item last DECLARED, as one comparable string — what\n   * a rung index means for this item.\n   *\n   * Distinct from {@link BarItemEntry.ladder}, and it has to be: a declaration's\n   * own release resets `ladder` to the default, and that release runs on every\n   * FORM change, because the item's channel identity carries its assigned form.\n   * So `ladder` cannot answer \"did the ladder actually change?\" — it reads as\n   * changed every time the bar moves the item a rung.\n   *\n   * Anything invalidated by a ladder change (H2's bars, whose rung indices only\n   * mean anything against one ladder) has to key on this instead. Keyed on\n   * inline rungs alone rather than the whole ladder, because that is exactly\n   * what a rung index names; `yields` changes the demotion ORDER, not what any\n   * index means.\n   */\n  declaredRungs: string | null;\n  /** Live `useHoldShrink` holds — what survives the pointer release (a fling's coast). */\n  holds: number;\n  /** A popover of this item's own is open, so its top-layer content must not move. */\n  popupOpen: boolean;\n  /** A pointer went down inside this item and has not come up. */\n  pointerPinned: boolean;\n  /**\n   * This container holds an `<iframe>` and the browser cannot move it without\n   * reloading it. Set once, reported once: the bar then refuses to relocate it\n   * at all rather than silently destroying the frame's state.\n   */\n  immovable: boolean;\n}\n\n/**\n * The imperative half of the item↔bar channel: stable for the bar's whole life,\n * so an item's registration effects never re-run because the bar re-rendered.\n */\nexport interface BarRegistry {\n  register(id: string, container: HTMLDivElement): () => void;\n  declare(id: string, ladder: Required<ShrinkLadder>): () => void;\n  hold(id: string): () => void;\n  setPopupOpen(id: string, open: boolean): void;\n  /**\n   * This item's contribution started or stopped rendering anything.\n   *\n   * The shared `ResizeObserver` cannot carry this signal in both directions: an\n   * occupant that renders nothing is `hidden` (so it costs no gap), and a\n   * `display: none` element reports no resize when content appears inside it.\n   * So the item watches its own container's child list and says so.\n   */\n  contentChanged(id: string): void;\n  /**\n   * Claim this bar's ONE yielding child, and throw if it is already taken.\n   *\n   * A yielding child is the row's give: it is excluded from the fit ledger and\n   * is the only occupant allowed below its own content width, so it absorbs\n   * whatever the measured occupants leave. Two of them share that leftover\n   * arbitrarily — each ends up narrower than the row could have given it, both\n   * ellipsize, and which one loses depends on their content rather than on\n   * anything the author wrote. There is no honest answer, so there is no second\n   * one: this throws rather than picking.\n   *\n   * The claim carries the cell's element because the claim IS the registration:\n   * the bar holds back a floor for this cell out of the fit's budget\n   * (`yieldFloorPx`), and that number is read off the element — its font size,\n   * and whether it is rendering anything at all.\n   */\n  claimYield(cell: HTMLElement): () => void;\n  /**\n   * The yielding cell started or stopped rendering anything.\n   *\n   * An empty cell reserves no floor — there is no title to keep legible — so\n   * this is the edge that changes the budget, and the same signal an occupant\n   * sends through {@link BarRegistry.contentChanged} for the same reason: a\n   * `display: none` element reports no resize when content appears inside it,\n   * and the row's own width does not move when a title arrives.\n   */\n  yieldContentChanged(): void;\n}\n\n/** `null` — no bar above — is a legitimate state: `AdaptiveBar.Item` is then transparent. */\nexport const BarRegistryContext = createContext<BarRegistry | null>(null);\n\nconst NO_FORMS: ReadonlyMap<string, ActionForm> = new Map();\n\n/**\n * The reactive half: the form each item was assigned on the last committed\n * pass. Separate from the registry because THIS is what must re-render the\n * occupants, and the registry is what must not.\n */\nexport const BarFormsContext =\n  createContext<ReadonlyMap<string, ActionForm>>(NO_FORMS);\n\nconst NO_ATTRS: PortalForwardedAttrs = {};\n\n/**\n * The region attributes (theme scope, pane id, lineage, …) of the BAR itself —\n * what its row inherits from the DOM, and what the bar stamps on its panel's\n * dock. An occupant stamps only the attributes where its own bag differs from\n * these: re-stamping the same `data-theme-scope` on its container would make\n * that container a fresh theme-scope root, which re-declares the inherited\n * defaults (`color: var(--foreground)`, `--hover-fill`, …) and so throws away\n * whatever the row set (a bar's muted `toolbar-foreground`).\n */\nexport const BarRegionAttrsContext =\n  createContext<PortalForwardedAttrs>(NO_ATTRS);\n","import {\n  useCallback,\n  useContext,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  useState,\n  type ReactElement,\n  type ReactNode,\n} from \"react\";\nimport { createPortal } from \"react-dom\";\nimport {\n  ActionFormProvider,\n  type ItemFormChannel,\n} from \"@plugins/primitives/plugins/action-presentation/web\";\nimport {\n  cn,\n  useRegionForwardedAttrs,\n} from \"@plugins/primitives/plugins/css/plugins/ui-kit/web\";\nimport { rigidClass } from \"@plugins/primitives/plugins/css/plugins/rigid/web\";\nimport { PopupOpenScope } from \"@plugins/primitives/plugins/overlay/plugins/popup-open/web\";\nimport { renderMode } from \"@plugins/primitives/plugins/dom/plugins/render-mode/core\";\nimport {\n  BarFormsContext,\n  BarRegionAttrsContext,\n  BarRegistryContext,\n  type BarRegistry,\n} from \"./registry\";\n\nexport interface AdaptiveBarItemProps {\n  /**\n   * Stable across the item's whole life. It keys the width ledger, so an id\n   * that churns per render throws the measurements away every frame; a\n   * DUPLICATE id makes \"where is this node\" unanswerable and `planMoves` throws\n   * rather than silently moving the wrong element.\n   */\n  id: string;\n  /**\n   * Classes on the occupant's own container, which travels with it — docked in\n   * the row, parked in the panel. For a trait of the occupant as a whole that\n   * a wrapper inside it cannot carry, because a wrapper is an element even when\n   * the widget renders nothing, and an empty occupant is judged by its\n   * container having no child element. Merged after the container's rigidity,\n   * which it cannot remove.\n   */\n  className?: string;\n  children: ReactNode;\n}\n\n/**\n * One occupant of an adaptive bar.\n *\n * Three states, and the branch is at the top so each is its own component and\n * the hook order inside is fixed:\n *\n * - **no bar above** — transparent. A primitive that only works in one place is\n *   a primitive nobody composes, and a host that wraps its actions in\n *   `AdaptiveBar.Item` unconditionally (a pane header does) must render the\n *   same thing outside a bar.\n * - **a static render** (`dom/render-mode`: HTML for robots, never hydrated) —\n *   the occupant's container rendered IN PLACE, at its natural (slot) order, at\n *   full form. Nothing will ever measure or relocate it, so there is nothing to\n *   portal for — and a static render has no DOM to mint the container in.\n * - **otherwise** — the portalled host below.\n *\n * Crossing between transparent and portalled remounts the widget. That is not\n * avoidable and not hidden: the portal IS the identity-preserving mechanism, so\n * there is no version of \"stop portalling\" that keeps the instance. It only\n * happens when the bar above appears or goes.\n */\nexport function AdaptiveBarItem({\n  id,\n  className,\n  children,\n}: AdaptiveBarItemProps): ReactElement {\n  const registry = useContext(BarRegistryContext);\n  if (registry === null) return <>{children}</>;\n  if (renderMode() === \"static\") {\n    return (\n      <StaticBarItem id={id} className={className}>\n        {children}\n      </StaticBarItem>\n    );\n  }\n  return (\n    <PortaledBarItem registry={registry} id={id} className={className}>\n      {children}\n    </PortaledBarItem>\n  );\n}\n\n/**\n * The item's DOM home: one plain `<div>`, created once, portalled into forever,\n * and MOVED between docks by the bar.\n *\n * This is the whole trick. React renders the widget through\n * `createPortal(children, container)`, so the portal target never changes\n * identity and the portal fiber is never torn down; placement then becomes a\n * DOM operation on a node React does not own. React never sees the move, so the\n * widget is never unmounted, never re-instantiated, and never rendered a second\n * time to be measured.\n *\n * The `createPortal` route is load-bearing in a way that is easy to get wrong:\n * React reconciles a portal by CONTAINER IDENTITY. Swapping a plain host\n * element for a portal at the same position — or changing a portal's container\n * — deletes the subtree and builds a new one. So the container must be minted\n * once and never replaced.\n */\n/**\n * The occupant container's own layout: rigid (see below), and a flex column so\n * the occupant is laid out as a flex item, never on a line box. A block\n * container puts an inline-level occupant on a line with the inherited font's\n * strut, and an occupant with no text baseline (an icon-only `<button>`, an\n * SVG) sits ON that baseline — the strut's descent then pads the container\n * below it, and the row centres the padded box, drawing the control a few\n * pixels high. A column, not a row, so the occupant still spans the container's\n * width the way a block child does (the panel's full-width rows rely on it).\n */\nfunction occupantClass(): string {\n  // eslint-disable-next-line layout/no-adhoc-layout -- the portal container is a raw DOM node (no React element to host a layout primitive); its flex column is what keeps an occupant off a line box\n  return cn(rigidClass(), \"flex flex-col\");\n}\n\n/**\n * The occupant in a static render: the same container the live item portals\n * into (same classes, same `data-adaptive-bar-item`), written where the live\n * bar would dock it — before its anchor, in the host's own order. No action-form\n * channel, so every widget renders `\"full\"`: there is no width to fit.\n */\nfunction StaticBarItem({\n  id,\n  className,\n  children,\n}: {\n  id: string;\n  className: string | undefined;\n  children: ReactNode;\n}): ReactElement {\n  return (\n    <div className={cn(occupantClass(), className)} data-adaptive-bar-item={id}>\n      {children}\n    </div>\n  );\n}\n\nfunction PortaledBarItem({\n  registry,\n  id,\n  className,\n  children,\n}: {\n  registry: BarRegistry;\n  id: string;\n  className: string | undefined;\n  children: ReactNode;\n}): ReactElement {\n  const [container] = useState(() => {\n    const el = document.createElement(\"div\");\n    // **An occupant's width is its own** — the axiom the whole width ledger\n    // rests on (`core/width-cache.ts`), and the container is where it has to be\n    // declared. An ordinary flex item is squeezed whenever its row is over-full,\n    // which is exactly the state a pass measures in, and the squeezed number is\n    // then stored as `exact` while `measureRowOverflow` goes blind.\n    //\n    // Not on the row as `[&>*]:shrink-0`, which is where it used to live: a\n    // parent selector reaches DIRECT children, and this container is docked at\n    // its own anchor — through `.Render` that is two or three `display: contents`\n    // wrappers below the row. Still a flex item of the row, no longer a child of\n    // it. On the node itself the declaration travels with it.\n    //\n    // It travels into the panel's column too, where `flex-shrink` is about\n    // height rather than width. That is harmless and, if anything, right: the\n    // panel is content-height, so there is no deficit for a shrink to take, and\n    // a parked row that could be squashed vertically is not something anyone\n    // wants either.\n    el.className = occupantClass();\n    return el;\n  });\n  useLayoutEffect(() => {\n    // Stamped like the forwarded attributes below: the container is not a\n    // React element, so nothing else can carry the occupant's own classes.\n    container.setAttribute(\"class\", cn(occupantClass(), className));\n  }, [container, className]);\n  // The REGION bag, not the popup one: this container is still part of the\n  // region it was rendered in, whether docked in the row or parked in the\n  // panel, so it keeps a region-only value (a theme sub-theme) a popup drops.\n  // Only what differs from the bar's own region: the row (docked) and the\n  // panel's overlay root (parked) already carry the rest, and re-stamping an equal\n  // `data-theme-scope` would make this container a new scope root that resets\n  // the inherited text colour the row set (see `BarRegionAttrsContext`).\n  const region = useRegionForwardedAttrs();\n  const barAttrs = useContext(BarRegionAttrsContext);\n  const forwarded = useMemo(\n    () =>\n      Object.fromEntries(\n        Object.entries(region).filter(\n          ([key, value]) => barAttrs[key] !== value,\n        ),\n      ),\n    [region, barAttrs],\n  );\n  const forms = useContext(BarFormsContext);\n  const form = forms.get(id) ?? \"full\";\n\n  // Which forwarded keys are currently stamped, so a key that DISAPPEARS from\n  // the bag (a pane id that is no longer in scope) is removed rather than left\n  // behind as a stale lineage claim.\n  const stampedRef = useRef<string[]>([]);\n\n  useLayoutEffect(() => {\n    // Stamped IMPERATIVELY and ALWAYS — not only when the item relocates.\n    //\n    // The container is not a React element, so nothing else can carry the\n    // ancestry-derived signals (theme scope, plugin lineage, pane id) that a\n    // portal severs. Doing it unconditionally is the point: a move-time branch\n    // is a branch that can be wrong, and the symptom would be a widget that\n    // renders in the wrong palette only after it has been relocated once.\n    container.setAttribute(\"data-adaptive-bar-item\", id);\n    for (const key of stampedRef.current) {\n      if (!(key in forwarded)) container.removeAttribute(key);\n    }\n    for (const [key, value] of Object.entries(forwarded)) {\n      container.setAttribute(key, value);\n    }\n    stampedRef.current = Object.keys(forwarded);\n  }, [container, id, forwarded]);\n\n  useLayoutEffect(() => {\n    // An occupant that renders nothing is hidden, and a hidden element reports\n    // no resize when content appears inside it — so DOM mutations are the one\n    // signal that survives in both directions. Push-based and scoped to this\n    // one node: no polling, and no walk of anyone else's DOM.\n    //\n    // The whole SUBTREE, not the container's own child list: \"renders nothing\"\n    // (`rendersNothing`) looks through `display: contents` boxes, so content can\n    // appear without the container's children changing — a slot's wrappers are\n    // already there, or the occupant is an empty `contents` span another tree\n    // portals into later. Watching only\n    // the child list left such an occupant hidden for good. Text counts too\n    // (`characterData`): a text node going from \"\" to a label is content.\n    const observer = new MutationObserver(() => registry.contentChanged(id));\n    observer.observe(container, {\n      childList: true,\n      subtree: true,\n      characterData: true,\n    });\n    const release = registry.register(id, container);\n    return () => {\n      observer.disconnect();\n      release();\n      // Undock, never destroy. The container is this component's own node; the\n      // widget inside it is being unmounted by React on the same commit.\n      container.remove();\n    };\n  }, [registry, id, container]);\n\n  // Named `declareLadder`, not `declare`: Bun's TS transform parses a statement\n  // beginning with `declare` as an ambient declaration and erases it, leaving\n  // `undefined` at runtime with no error anywhere (bun-safety/no-declare-identifier).\n  const declareLadder = useCallback(\n    (ladder: Parameters<BarRegistry[\"declare\"]>[1]) =>\n      registry.declare(id, ladder),\n    [registry, id],\n  );\n  const hold = useCallback(() => registry.hold(id), [registry, id]);\n  const channel = useMemo<ItemFormChannel>(\n    () => ({ form, declare: declareLadder, hold }),\n    [form, declareLadder, hold],\n  );\n\n  return (\n    <>\n      {/*\n        The anchor: a zero-size marker React renders at the item's NATURAL\n        position in the host's own children.\n\n        It is what makes order an input rather than something the mechanics has\n        to discover. The host may render its items through a slot whose reorder\n        middleware sorts them, wrapped in whatever containers it likes; document\n        order of the anchors is the order the author actually produced, and the\n        bar docks each container immediately before its own anchor. A registry\n        keyed on mount order would get an item inserted in the middle wrong, and\n        a consumer-supplied order list would be a second source of truth.\n\n        `hidden` (`display: none`) means it is not a flex item at all: no width,\n        and — the part that is easy to miss — no gap either.\n      */}\n      <span hidden data-adaptive-bar-anchor={id} />\n      {createPortal(\n        <ActionFormProvider channel={channel}>\n          <PopupOpenScope>\n            {(popupOpen) => (\n              <PopupPin registry={registry} id={id} open={popupOpen}>\n                {children}\n              </PopupPin>\n            )}\n          </PopupOpenScope>\n        </ActionFormProvider>,\n        container,\n      )}\n    </>\n  );\n}\n\n/**\n * Pins the item while a popover of its own is open — with zero contributor\n * change, because `PopupOpenScope` is already how every ui-kit popup announces\n * itself.\n *\n * Mandatory, not polite: an open popover lives in the top layer, and a plain\n * re-parent drops it out of it. The popover would close (or worse, paint\n * underneath) the instant the row resized.\n */\nfunction PopupPin({\n  registry,\n  id,\n  open,\n  children,\n}: {\n  registry: BarRegistry;\n  id: string;\n  open: boolean;\n  children: ReactNode;\n}): ReactElement {\n  useEffect(() => {\n    registry.setPopupOpen(id, open);\n    // The release runs on close AND on unmount, so an item that leaves the tree\n    // with its menu open cannot strand itself pinned in the bar's ledger.\n    return () => registry.setPopupOpen(id, false);\n  }, [registry, id, open]);\n  return <>{children}</>;\n}\n","import { defineReportSink } from \"@plugins/primitives/plugins/report-sink/core\";\nimport type { ConvergenceEvidence } from \"@plugins/primitives/plugins/adaptive-bar/core\";\n// Type-only, and therefore not a runtime cycle: the fault body names the bar's\n// overflow mode, and the mode is declared where the props that carry it are.\nimport type { AdaptiveBarOverflow } from \"./adaptive-bar\";\n\n/**\n * The ways an adaptive bar is *wrong*, as opposed to merely cramped.\n *\n * Running out of room is the normal case and is never a fault — it is what the\n * whole primitive is for. These six are the states where an assumption has been\n * violated, and living with them silently is how a layout bug becomes permanent.\n */\nexport type AdaptiveBarFaultKind =\n  /** The bar was not given slack: some ancestor is shrink-to-content, or a sibling took the grow slot. */\n  | \"no-slack\"\n  /**\n   * A MEASURING bar was mounted inside another bar's occupant.\n   *\n   * \"One adaptive bar per row\" used to be prose, and prose is the weakest way to\n   * state a rule this cheap to check: a bar reads `BarRegistryContext` and\n   * a non-null one means a bar is already above it. Two measuring bars in one\n   * row cannot both be right — each declares itself `min-w-0 flex-1` and asks\n   * the chain above it to grow, so the inner one takes the row's whole slack and\n   * the outer one is left measuring its own content. The outer bar then reports\n   * `no-slack` and stops deciding, which is a true statement about a defect\n   * somewhere else entirely — this kind names the actual offender.\n   *\n   * `AdaptiveBar.Collapsed` nested in a bar is NOT this and must never fire it:\n   * it is one `shrink-0` `⋯` sitting among the row's occupants, it takes no\n   * slack, it measures nothing, and it is how `reorder`'s `overflow` node type\n   * renders an authored bucket inside a pane header — a legitimate composition\n   * that ships today. Only a bar that MEASURES is a second claimant.\n   */\n  | \"nested-bar\"\n  /** The fit said \"everything fits\" and the rendered row still overflows the box the bar was given. */\n  | \"row-overflow\"\n  /** The round budget ran out and the answer was still changing. */\n  | \"no-convergence\"\n  /** A container holds an `<iframe>` and this browser has no `moveBefore`, so relocating it would reload it. */\n  | \"iframe-relocation\"\n  /**\n   * A widget declared a smaller form and then rendered NOTHING as it.\n   *\n   * The one fault about the *contributor* rather than the host or the browser:\n   * `useActionForm({ shrinksTo: [\"compact\"] })` is a promise to render something\n   * as compact, and vanishing is the one transformation this primitive exists to\n   * prevent. The bar recovers on its own — it stops offering that form and the\n   * widget leaves the row instead — which is exactly why it has to say so, or\n   * the widget silently loses a form nobody knows it lost.\n   *\n   * Rung 0 is not this: a contribution that renders nothing at all is ordinary,\n   * supported, and reported nowhere.\n   */\n  | \"empty-rung\";\n\nexport interface AdaptiveBarFault {\n  kind: AdaptiveBarFaultKind;\n  /** The bar's accessible label — the name its own consumer gave it. */\n  label: string;\n  /**\n   * Which composition this bar belongs to.\n   *\n   * The label alone is not an identity. It defaults to `\"More\"`, and two\n   * unrelated bars on one route take that default today (the app tab strip and\n   * the pinned prompt-template chips), so a fault fingerprinted on the label\n   * collapses them onto one row and hides the second behind the first's count.\n   *\n   * Read from the DOM at fault time as the innermost UI-context node above the\n   * bar's root — `apps-core.tab-bar@apps.tab-bar` for one of those two,\n   * `conversations.conversation-view.prompt-templates@prompt-editor.floating-action`\n   * for the other. Absent where nothing carries lineage: a fixture, a story, a\n   * bare test render.\n   */\n  origin?: string;\n  /** The full lineage path, for the reader who needs more than one name. */\n  originPath?: string;\n  /**\n   * The bar's overflow mode.\n   *\n   * Carried, and fingerprinted, because it is the one discriminator that costs\n   * nothing and already separates today's two colliding `\"More\"` bars — the tab\n   * strip is `scroll`, the prompt-template chips are `clip`. It also decides\n   * what a fault's remedy is allowed to do, so a reader needs it.\n   */\n  overflow?: AdaptiveBarOverflow;\n  message: string;\n  /**\n   * Which occupant a fault is about, where it is about one.\n   *\n   * `empty-rung` is the only kind whose subject is a specific CONTRIBUTOR rather\n   * than the bar's host, and the id is the field a reader filters on, so it is a\n   * typed field and not only a phrase inside {@link AdaptiveBarFault.message}.\n   * Fingerprinted, because one bar holding three vanishing widgets is three\n   * findings with three different owners, not one row with a count of three.\n   */\n  item?: { id: string; rung: number; form: string };\n  /**\n   * What the bar established about a `no-convergence`, so nobody has to\n   * reproduce a transient. Absent for the other kinds, which have no rounds.\n   */\n  evidence?: ConvergenceEvidence;\n}\n\n/**\n * Where a fault goes in production. `reports/adaptive-bar` registers the mapping\n * to a filed report; with nothing registered, `emit` only holds a bounded backlog — which is\n * correct for a primitive that must stay usable in a test harness, a fixture\n * page and a standalone story, and is exactly why the app composition MUST\n * carry a collector. It did not, so every fault below was silently dropped in\n * prod until the Layout Lab pane started dying of one.\n */\nexport const adaptiveBarReportSink = defineReportSink<AdaptiveBarFault>();\n\n/**\n * Report and keep going. For a fault the bar has already handled correctly:\n * refusing to relocate an iframe, or declining to offer a form a widget does not\n * render. Both are the right behaviour rather than a bug to take a pane down\n * over — and `empty-rung` in particular must never throw in dev, because a\n * widget that renders nothing for one frame while its data loads would take the\n * pane with it.\n */\nexport function reportFault(fault: AdaptiveBarFault): void {\n  adaptiveBarReportSink.emit(fault);\n}\n\n/**\n * Report, then throw in dev.\n *\n * For the faults that mean the bar's own contract is broken — it was given no\n * slack, it was written inside another bar, or its fit math disagrees with the\n * layout engine. Those must not be\n * lived with: in dev the throw is the fastest possible feedback, and in prod we\n * file the alert and take a cramped-but-usable layout instead, because taking\n * down a pane header over a layout disagreement is worse than a cramped row\n * plus a report.\n *\n * The caller commits that layout BEFORE calling this, so the two orders are not\n * interchangeable: throwing first would leave the row in the state that was\n * already known to be wrong. Committing it also SURRENDERS the bar (see\n * `commitSurrender`) — without that, \"file and keep going\" was a render loop,\n * and the prod outcome was the dead pane the throw was meant to avoid.\n */\nexport function failLoudly(fault: AdaptiveBarFault): void {\n  reportFault(fault);\n  if (import.meta.env.DEV) {\n    throw new Error(`adaptive-bar (${fault.label}): ${fault.message}`);\n  }\n}\n\n/**\n * How far apart two widths have to be before they are different widths.\n *\n * Rects are fractional, and a fraction of a pixel is layout rounding rather\n * than a widget resizing itself or a row being given more room. Without this\n * tolerance every round on a real page reads as a changed premise — the same\n * mistake as counting a changed premise as a failed round, inverted.\n *\n * Must stay strictly below {@link HYSTERESIS_PX}, which is the width change a\n * surrendered bar needs before it re-arms. If the two ever crossed, a width\n * could be \"a new premise, start counting again\" and \"not a resize, stay\n * surrendered\" at the same time.\n */\nexport const WIDTH_EPSILON_PX = 0.5;\n\n/**\n * How many rounds of evidence a fault carries.\n *\n * Enough to show a cycle (which needs a repeat) and the widths either side of a\n * move; not a log. The ring is kept for every bar on every pass, so it is\n * numbers only and it is short.\n */\nexport const TRACE_ROUNDS = 6;\n\n/**\n * How many times the premise may move without the bar ever reaching a settled\n * answer.\n *\n * Tolerating a moving premise — a font landing, a late icon, a ladder arriving\n * on a passive effect one round after the item it belongs to — is the whole\n * point of scoping the round counter to it. But a bar whose widths never stop\n * moving is a real pathology, distinct from a search that will not settle, and\n * it deserves to be said in those words rather than blamed on the fit.\n */\nexport const MAX_PREMISE_SHIFTS = 6;\n\n/**\n * The round counter nothing resets, and the reason a resettable one is safe.\n *\n * `reconcile` re-enters itself **synchronously** through its layout effect\n * after every commit — there is no frame boundary anywhere in the chain — so a\n * bar whose occupants resize themselves on each of those commits would reset\n * the per-premise counter forever. Not hypothetically: `:hover` is recomputed\n * when a container is re-parented out from under the pointer, and a widget with\n * its own measuring layout effect re-measures whenever its parent re-renders.\n * Neither is expressible as \"the search failed\"; both are unbounded without\n * this.\n *\n * Well under React's own nested-update limit (50), because every round costs at\n * least one nested synchronous update and some cost more. That margin is the\n * difference between a warning in Debug → Reports and a dead pane.\n */\nexport const HARD_ROUND_CEILING = 20;\n\n/**\n * How many times one bar may give up and try again before it stays given up.\n *\n * A fault commits the floor and stops the bar deciding — otherwise the floor\n * re-runs the pass, the fit recomputes the same answer, and the same fault\n * fires forever (React's \"maximum update depth exceeded\", a dead pane).\n *\n * But \"stopped\" must be scoped to the width it happened at, not to the mount.\n * `no-convergence` is frequently a TRANSIENT — a font arriving mid-pass, a\n * late icon, a widget re-rendering between measure and decide — and it is\n * observed on ordinary healthy surfaces, not just broken ones. Parking such a\n * bar at its floor forever means every action sits in the `⋯` panel until the\n * user reopens the pane, which is a worse outcome than the fault.\n *\n * So the bar re-arms when its own width genuinely changes (the premise it\n * failed under is gone), and this caps how often. The re-arm cannot feed\n * itself: the bar is the grow cell, so its width comes from its row and not\n * from its own content, and committing the floor therefore cannot change the\n * number that would re-arm it. The cap is the backstop for the one shape where\n * that reasoning fails — a shrink-to-content ancestor, which is `no-slack`'s\n * business — so termination never rests on the argument alone.\n */\nexport const MAX_SURRENDERS = 3;\n\n/**\n * How many times one bar may ask the layout engine whether its width follows\n * its own content.\n *\n * The probe hides the row's occupants, re-reads the row and puts them back, so\n * it costs a forced reflow — and the premise it verifies belongs to the HOST,\n * which can change after the bar mounts: a framing variant swaps, a wrapper's\n * class flips, contributions arrive in a later plugin wave, or a shrink-to-\n * content ancestor whose width was floored by a wider sibling stops being\n * floored once the bar's own content grows past it. Asking once at mount spends\n * the guard before any of that happens.\n *\n * So it is re-asked when the row NARROWS, which is the ratchet's own direction:\n * an eviction can only ever reduce what the row holds, so a content-following\n * row can only be dragged narrower by the bar's own decisions, and a masked\n * shrink-wrap reveals itself on the first eviction that takes the content below\n * its floor. A widening pane costs nothing.\n *\n * The budget is what keeps that from being one forced reflow per frame of a\n * narrowing drag. Six rather than two or three, because a legitimate width\n * SWEEP spends one on every step: the layout-geometry gate renders one bar\n * across a range of widths, and any surface that steps through several widths\n * in quick succession does the same — a budget tuned for \"one or two host\n * changes\" is gone before a later onset could ever be observed. Six is the\n * mount verification plus enough re-verifications to survive such a sweep, and\n * still a handful of reflows rather than one per frame of a sustained drag.\n * The trade, stated rather than hidden — after a long drag the bar is back to\n * trusting its last verification, which is exactly today's behaviour and\n * strictly better than it. Soundness is untouched either way: the probe is\n * definitive, so the schedule changes only WHEN a true answer is obtained,\n * never whether the answer is true.\n */\nexport const MAX_SLACK_PROBES = 6;\n\n/**\n * How many times one bar may re-admit its occupants to re-ask a zero width,\n * before it stops asking and takes the ceiling for good.\n *\n * A RENDERED row that measures nothing with occupants parked outside it can mean\n * two different things, and the width alone cannot tell them apart. Either the\n * ratchet has reached its end — the host shrink-wraps to the bar, so every\n * eviction shrank the width that decided the next one, and the row has emptied\n * itself — or the row is merely OVER-FULL: `flex-1` is `flex: 1 1 0%`, so when\n * the row's other items over-fill their container, free space is negative and\n * the bar's cell resolves to exactly 0px while fully laid out. Nothing is wrong\n * with the host there; the bar simply has no room at this width.\n *\n * The differential probe ({@link MAX_SLACK_PROBES}) is the guard that CAN tell\n * them apart, and it is correctly silent in the second case — hiding the\n * occupants cannot change a width that comes from negative free space. But it\n * needs occupants in the row to hide, which is exactly what the first case has\n * run out of. So the bar re-admits everything and re-asks, instead of guessing\n * from a number that carries no answer.\n *\n * **This is not what makes the recovery terminate**, and believing it is would\n * be the way to break it. A recovery's follow-up pass runs at a real width and\n * commits a different placement, so it costs one `episode.total` like any other\n * — which means {@link HARD_ROUND_CEILING} already bounds a recovery loop, and\n * already ends it with a `no-convergence` surrender. What this number decides is\n * the **diagnosis**: whether a bar that cannot get an answer says `no-slack`\n * (true — the width reading is the problem) or `no-convergence` (a\n * misdiagnosis, blaming the fit for a host's arithmetic).\n *\n * So it is cleared at exactly the instant `episode.total` is — a pass that\n * converges without faulting — rather than on any looser signal. Tying the two\n * together means this introduces no new termination claim: it inherits one that\n * is already proven and already tested (`web/__tests__/termination.test.tsx`).\n * A monotonic per-mount cap was the obvious alternative and is wrong: a single\n * drag oscillating around the collapse point burns one per crossing, so it\n * reinstates the permanent latch, conditioned on gesture history.\n *\n * Three, and the ceiling is React's margin rather than a UX budget. Each\n * recovery costs about two nested synchronous updates on top of an episode\n * already allowed to run to {@link HARD_ROUND_CEILING}, which is itself chosen\n * to stay well under React's nested-update limit of 50. One recovery is all a\n * healthy answer needs; the other two are the spare for an occupant that mounts\n * mid-chain.\n */\nexport const MAX_ZERO_RECOVERIES = 3;\n\n/**\n * The promote band, in px — one `gap-sm`. A demotion is accepted the moment the\n * row overflows; a promotion needs this much headroom on top. The two\n * predicates are disjoint, so no single width both demands a demote and permits\n * the matching promote, which is what stops a one-pixel resize from flickering\n * the row back and forth.\n */\nexport const HYSTERESIS_PX = 8;\n","import type {\n  ActionForm,\n  ShrinkLadder,\n  YieldEagerness,\n} from \"@plugins/primitives/plugins/action-presentation/web\";\n\n/**\n * What a widget that never declared anything gets: one rung, normal eagerness.\n * The bar may leave it alone or relocate it as itself, and nothing else — a\n * strict superset of the behaviours that were safe before this primitive\n * existed, which is why a contributor who never heard of the seam is safe.\n */\nexport const DEFAULT_LADDER: Required<ShrinkLadder> = {\n  shrinksTo: [],\n  yields: \"normal\",\n};\n\n/**\n * Eagerness → the rank `assign` sorts on. **Higher yields sooner.**\n *\n * `\"never\"` is the LOWEST rank, not a hard pin: it means \"the last thing this\n * bar touches\". A hard pin would be unrepresentable-by-construction only if\n * every bar could always satisfy it, and a row narrower than one occupant\n * cannot. So the eager widgets give first and a `\"never\"` widget still yields\n * before the row breaks — which is what the focused tab wants.\n */\nconst YIELD_RANK: Record<YieldEagerness, number> = {\n  never: 0,\n  late: 1,\n  normal: 2,\n  early: 3,\n};\n\nexport function yieldRankOf(ladder: Required<ShrinkLadder>): number {\n  return YIELD_RANK[ladder.yields];\n}\n\n/**\n * The forms this widget can render **while still in the row**, widest first.\n *\n * `\"row\"` is deliberately not one of them. A rung names a form, never a place —\n * but `\"row\"` is the form a menu-safe widget renders *once it has left the\n * row*, so counting it as an inline rung would let the fit math \"shrink\" an\n * item to a width it never occupies inline.\n */\nexport function inlineRungsOf(ladder: Required<ShrinkLadder>): ActionForm[] {\n  return ladder.shrinksTo.includes(\"compact\") ? [\"full\", \"compact\"] : [\"full\"];\n}\n\n/**\n * The form to hand a widget for one placement.\n *\n * Evicted (`rung === null`) means \"you are no longer in the row\": a widget that\n * offered `\"row\"` renders as a labelled row in the panel, and everything else\n * renders as ITSELF — which is the entire point of relocation over\n * transformation.\n *\n * `useActionForm` filters this again on the widget's side. The duplication is\n * deliberate: the hook's filter is the structural guarantee (no region, present\n * or future, can transform a widget), and this one keeps the channel's value\n * honest so a debugger reading it is not looking at a lie the hook happens to\n * correct.\n */\nexport function formFor(\n  ladder: Required<ShrinkLadder>,\n  rung: number | null,\n): ActionForm {\n  if (rung === null) return ladder.shrinksTo.includes(\"row\") ? \"row\" : \"full\";\n  const rungs = inlineRungsOf(ladder);\n  return rungs[Math.min(Math.max(rung, 0), rungs.length - 1)] ?? \"full\";\n}\n","import {\n  createContext,\n  useContext,\n  useMemo,\n  type ReactElement,\n  type ReactNode,\n} from \"react\";\n\n/**\n * How the bar reads a width.\n *\n * `getBoundingClientRect().width`, never `offsetWidth`: the integer-rounding\n * loops this primitive replaces under-reported by up to 1px per item, which is\n * exactly how a row ends up permanently one pixel too wide and one item too\n * narrow.\n */\nexport type MeasureWidth = (el: Element) => number;\n\nconst domMeasureWidth: MeasureWidth = (el) => el.getBoundingClientRect().width;\n\n/**\n * Does this element generate a box at all?\n *\n * NOT \"is it visible\", and the difference is the whole point. An element in a\n * `display: none` subtree generates no boxes, so it was never given a width and\n * there is no reading to have — which is a different fact from a rendered box\n * that measures zero, and the two are what the `no-slack` 0px branch has to\n * tell apart.\n *\n * `getClientRects()` because it is already this file's neighbour's spelling for\n * the same question: `measureRowOverflow` in `adaptive-bar.tsx` filters out\n * elements generating NO boxes with the identical predicate, and a second\n * spelling for one question is precisely the drift this primitive's docs spend\n * paragraphs preventing. It also beats every alternative. `offsetParent` is an\n * ancestor comparison the bar bans elsewhere and is `null` for the\n * `fixed`-positioned solo placement. `isConnected` answers about the document,\n * not about layout. `checkVisibility()` is newer than the WebKit `tauri/` ships\n * and folds in `content-visibility`, whose skipped subtree still has a real\n * width from its host.\n *\n * `visibility: hidden` deliberately still counts as rendered, and so still\n * faults: it changes nothing about layout, so the width the row reads there is\n * a width its host genuinely gave it.\n */\nexport type IsRendered = (el: Element) => boolean;\n\nconst domIsRendered: IsRendered = (el) => el.getClientRects().length > 0;\n\n/** Everything the bar asks the layout engine, read for one decision. */\nexport interface MeasureBundle {\n  measure: MeasureWidth;\n  isRendered: IsRendered;\n}\n\n/**\n * The production bundle, frozen at module level so `useLayoutMeasured` can\n * identify it by reference — the same trick as before, one level up.\n */\nconst DOM_MEASURE: MeasureBundle = {\n  measure: domMeasureWidth,\n  isRendered: domIsRendered,\n};\n\n/**\n * Module level, NOT an inline default: the provider memoises its bundle on\n * `[measure, isRendered]`, and a fresh `() => true` per render would move that\n * dep on every render of every test that does not pass one.\n */\nconst alwaysRendered: IsRendered = () => true;\n\n/**\n * The measurement seam.\n *\n * There is one legitimate reason to replace it and it is not configurability:\n * **jsdom has no layout engine**, so every rect is zero and the shared\n * `ResizeObserver` stub is inert. Without a seam the fit math — the part with\n * the interesting failure modes — would be reachable only through a real\n * browser, and the browser suite is a geometry gate, not a place to assert that\n * a widget kept its React identity across a re-parent.\n *\n * So a test supplies widths and drives the same code path the browser drives.\n * Nothing else may use this: a consumer that \"adjusts\" measurement is lying to\n * the layout engine about a number the layout engine owns.\n */\nconst MeasureContext = createContext<MeasureBundle>(DOM_MEASURE);\n\n/**\n * One context read for both answers, because they are read at the same instant\n * for the same decision — the argument {@link readRowMetrics} makes for reading\n * gap and inset together.\n */\nexport function useMeasureBundle(): MeasureBundle {\n  return useContext(MeasureContext);\n}\n\n/**\n * Are the widths coming from a real layout engine?\n *\n * The bar's two placement guards — \"you were given no slack\" and \"you\n * overshot\" — are assertions ABOUT the layout engine: they compare what the fit\n * math believed against what the engine actually did. With the seam replaced\n * there is no engine to contradict, and jsdom happily reports `flex-grow: 0` for\n * every element because nothing applied a stylesheet — so running the guards\n * there would fail every test on a fact about jsdom rather than about the bar.\n */\nexport function useLayoutMeasured(): boolean {\n  return useContext(MeasureContext) === DOM_MEASURE;\n}\n\n/**\n * Test-only. See {@link MeasureWidth}.\n *\n * `isRendered` defaults to `() => true` precisely so the `no-slack` 0px branch\n * stays drivable from jsdom: jsdom returns `[]` from `getClientRects()` for\n * every element, so the real predicate would answer \"not rendered\" everywhere\n * and quietly make that branch dead code in the one suite that can reach it.\n * A supplied width is by definition a width something gave the row, so a test\n * that says nothing about rendered-ness means \"rendered\".\n */\nexport function AdaptiveBarMeasure({\n  measure,\n  isRendered = alwaysRendered,\n  children,\n}: {\n  measure: MeasureWidth;\n  isRendered?: IsRendered;\n  children: ReactNode;\n}): ReactElement {\n  const bundle = useMemo(\n    () => ({ measure, isRendered }),\n    [measure, isRendered],\n  );\n  return (\n    <MeasureContext.Provider value={bundle}>{children}</MeasureContext.Provider>\n  );\n}\n\n/** What the row's own computed style says about the space it has to give. */\nexport interface RowMetrics {\n  /**\n   * The gap between two adjacent occupants, read from the RENDERED element\n   * rather than from the `gap` prop it was built from.\n   *\n   * The prop names a role on the density ramp; the pixels it resolves to depend\n   * on the active density preset, which changes at runtime. Re-deriving the\n   * number from the role would be a second source of truth that silently\n   * desyncs the moment a preset changes — the `MORE_BTN_W = 32` mistake in a\n   * different costume.\n   */\n  gapPx: number;\n  /**\n   * Horizontal padding + border: the part of the row's border box that its\n   * occupants are NOT laid out in.\n   *\n   * The fit's budget has to be the CONTENT box, because that is the box the\n   * occupants are laid out in and the box `measureRowOverflow` compares them\n   * against. Reading `getBoundingClientRect().width` and stopping there gave the\n   * fit a budget one padding wider than the room that exists, so a consumer\n   * adding padding to a bar root would produce a row the fit blessed and the\n   * engine overflowed — a `row-overflow` fault caused by the guard's own\n   * arithmetic rather than by the layout.\n   *\n   * That was invisible while occupants could be squeezed: flex absorbed the\n   * difference, the spans summed to the content box, and the guard measured no\n   * overflow however much padding the root carried.\n   */\n  insetPx: number;\n}\n\n/**\n * The row's gap and its horizontal inset, from ONE computed-style read.\n *\n * Together rather than separately because they are read at the same instant for\n * the same decision, and a second `getComputedStyle` is a second chance for the\n * two to describe different layouts.\n *\n * A non-numeric answer (`\"normal\"`, or jsdom's empty string) is not a length, so\n * it contributes nothing rather than a `NaN` that would poison every sum.\n */\nexport function readRowMetrics(el: Element): RowMetrics {\n  const style = getComputedStyle(el);\n  return {\n    gapPx: lengthPx(style.columnGap),\n    insetPx:\n      lengthPx(style.paddingLeft) +\n      lengthPx(style.paddingRight) +\n      lengthPx(style.borderLeftWidth) +\n      lengthPx(style.borderRightWidth),\n  };\n}\n\nfunction lengthPx(raw: string): number {\n  const px = Number.parseFloat(raw);\n  return Number.isFinite(px) ? px : 0;\n}\n\n/**\n * How many of the row's laid-out flex items are NOT the bar's own — a host's\n * `Fill`, the growing `AdaptiveBar.Yield` cell, a reorder spacer.\n *\n * Each one costs the row a `gap` the fit never sees. Its WIDTH is slack (every\n * such cell is `min-w-0` and gives down to nothing, the yield cell's floor\n * reserved separately), but the gap beside it is not: flex lays out one gap\n * between every pair of items, so a row holding a `Fill` between its title box\n * and its `⋯` is one gap wider at its tightest than the fit's sum. Uncounted,\n * the fit blesses a placement inside that gap, the row overflows it, and the\n * `row-overflow` guard floors the whole bar over a few pixels (a canvas frame\n * header lost its title box into the `⋯` that way).\n *\n * `own` is what the fit already prices: the docked occupant containers and the\n * trigger. A flex item holding one of them (a host wrapper the anchor sits in)\n * is theirs, not foreign. `display: contents` boxes are walked through, since\n * their children are the row's flex items; out-of-flow children take no gap.\n *\n * Asks the real layout engine (`getClientRects`, computed style), so it is only\n * called where {@link useLayoutMeasured} holds — the same gate as the guard it\n * keeps honest.\n */\nexport function foreignCellCount(\n  root: Element,\n  own: readonly Element[],\n): number {\n  let count = 0;\n  const walk = (parent: Element): void => {\n    for (const child of parent.children) {\n      const style = getComputedStyle(child);\n      if (style.display === \"contents\") {\n        walk(child);\n        continue;\n      }\n      if (child.getClientRects().length === 0) continue;\n      if (style.position === \"absolute\" || style.position === \"fixed\") {\n        continue;\n      }\n      if (own.some((el) => child === el || child.contains(el))) continue;\n      count += 1;\n    }\n  };\n  walk(root);\n  return count;\n}\n","import { useEffect, useState, type ReactElement } from \"react\";\nimport {\n  autoUpdate,\n  flip,\n  offset,\n  shift,\n  useFloating,\n} from \"@floating-ui/react-dom\";\nimport { OverlayPanel } from \"@plugins/primitives/plugins/css/plugins/ui-kit/web\";\nimport { ViewportOverlay } from \"@plugins/primitives/plugins/css/plugins/viewport-overlay/web\";\nimport type { PortalForwardedAttrs } from \"@plugins/primitives/plugins/css/plugins/ui-kit/web\";\nimport { Stack } from \"@plugins/primitives/plugins/css/plugins/spacing/web\";\n\nexport interface OverflowPanelProps {\n  open: boolean;\n  /** The `⋯` trigger the panel positions against. */\n  anchor: HTMLElement | null;\n  /** Accessible name for the panel — the bar's own label. */\n  label: string;\n  /** Receives the dock: the one element relocated containers are moved into. */\n  dockRef: (el: HTMLElement | null) => void;\n  /**\n   * The bar's REGION attributes (theme scope, sub-theme included). The panel is\n   * body-portaled and its overlay would carry only the popup bag, but a parked\n   * occupant is still part of the bar's region — and it stamps only what\n   * differs from these, so the panel must carry the rest.\n   *\n   * Stamped on the overlay ROOT, outside the panel — never on the dock inside\n   * it. A theme-scope root resets every surface colour role to the canvas's,\n   * so a scope stamped inside the panel undid the panel's own: in Mist every\n   * parked row hovered to `--muted`, which IS the popover's colour. Scope\n   * outside, surface inside — the order every other popup has.\n   */\n  regionAttrs: PortalForwardedAttrs;\n  /**\n   * Whether an occupant parked in the panel has a popup of its own open (a\n   * popover its button opened). That popup is the innermost layer: it owns Esc\n   * and outside presses until it closes, so the panel never dismisses under it\n   * — dismissing would hide the popup's trigger and strand it unanchored.\n   */\n  hasOpenChildPopup: () => boolean;\n  onDismiss: () => void;\n}\n\n/**\n * The overflow panel — **always mounted, never unmounted, closed only in CSS**.\n *\n * This is the constraint everything else in the file bends to. The panel holds\n * the LIVE DOM of relocated widgets: a Web Audio volume control, a jog wheel\n * mid-fling, a slider whose `aria-valuenow` is the user's actual setting.\n * `Popover` and `DropdownMenu` both unmount their content on close, which would\n * destroy the dock and orphan every container hanging off it — the single\n * instance this primitive exists to preserve would die every time the panel\n * closed. So \"closed\" is `display: none` + `inert` + `aria-hidden`, and the\n * dock's identity outlives every open/close cycle.\n *\n * `inert` is not decoration either: without it a parked `role=\"slider\"` stays\n * focusable and Tab drops the user into an invisible control.\n *\n * The surface is a plain **dialog** and nothing about it is derived from its\n * occupants. A `role=\"menu\"` was the obvious-looking alternative and is wrong\n * twice over: menu content unmounts on close (above), and inside a menu the\n * roving tabindex and typeahead own the arrow keys a relocated slider needs.\n * Here Tab reaches the widget, arrows reach the slider, Esc closes — and\n * because it is the same instance, the drag physics come along untouched. The\n * honest cost is that the panel has no typeahead and no arrow-key roving.\n *\n * It composes the same three pieces `floating-surface` does — `ViewportOverlay`\n * + `OverlayPanel` + Floating UI — rather than reusing `FloatingSurface`\n * itself, which returns `null` when closed and would therefore reintroduce\n * exactly the unmount this design cannot have.\n */\nexport function OverflowPanel({\n  open,\n  anchor,\n  label,\n  dockRef,\n  regionAttrs,\n  hasOpenChildPopup,\n  onDismiss,\n}: OverflowPanelProps): ReactElement {\n  const [floatingEl, setFloatingEl] = useState<HTMLElement | null>(null);\n\n  const { floatingStyles, isPositioned } = useFloating({\n    open,\n    strategy: \"fixed\",\n    placement: \"bottom-end\",\n    // `autoUpdate` keeps the panel on its trigger through scroll and resize.\n    // A resize NEVER closes the panel — the user opened it, and the bar\n    // re-fitting underneath is not a reason to take it away.\n    //\n    // Only while OPEN: the panel is always mounted (above), so an unconditional\n    // `autoUpdate` would watch the anchor and reposition a `display: none`\n    // panel on every layout shift of the page for as long as the bar lives.\n    // Opening flips this on, which re-runs Floating UI's mount effect and\n    // `autoUpdate` positions the panel at once.\n    whileElementsMounted: open ? autoUpdate : undefined,\n    // The anchor is handed over only while open, for the same reason: with\n    // both elements set and no `whileElementsMounted`, Floating UI still\n    // positions once on mount — one async state update, so one commit, per\n    // closed panel. A sidebar of collapsed rows is one panel per row.\n    elements: { reference: open ? anchor : null, floating: floatingEl },\n    middleware: [offset(4), flip({ padding: 9 }), shift({ padding: 8 })],\n  });\n\n  // Esc and outside-press close. Both are document-level and capture-phase so\n  // they still fire for a press that lands inside a relocated widget's own\n  // popover, which lives in the top layer above everything — and that is why\n  // both first defer to an open child popup: it is the innermost layer, so the\n  // press or Esc is its to handle (it closes itself), and the panel only\n  // dismisses on the NEXT one. Read at event time: the popup's open state lives\n  // in the bar's ledger, not in React state this effect could depend on.\n  useEffect(() => {\n    if (!open) return;\n    function onKeyDown(e: KeyboardEvent): void {\n      if (e.key === \"Escape\" && !hasOpenChildPopup()) onDismiss();\n    }\n    function onPointerDown(e: PointerEvent): void {\n      const target = e.target as Node | null;\n      if (target === null) return;\n      if (hasOpenChildPopup()) return;\n      if (floatingEl?.contains(target) === true) return;\n      if (anchor?.contains(target) === true) return;\n      onDismiss();\n    }\n    // eslint-disable-next-line shortcuts/no-window-key-listener -- listens only while this panel is open; capture-phase on the document so Escape still reaches it from a relocated widget's own top-layer popover, and any outside press closes it.\n    document.addEventListener(\"keydown\", onKeyDown, true);\n    document.addEventListener(\"pointerdown\", onPointerDown, true);\n    return () => {\n      document.removeEventListener(\"keydown\", onKeyDown, true);\n      document.removeEventListener(\"pointerdown\", onPointerDown, true);\n    };\n  }, [open, onDismiss, hasOpenChildPopup, floatingEl, anchor]);\n\n  return (\n    <ViewportOverlay\n      layer=\"popover\"\n      // The overlay itself is always painted and always click-through; only the\n      // panel inside it takes pointers, and only while open.\n      className=\"pointer-events-none\"\n      aria-hidden={!open}\n      {...regionAttrs}\n    >\n      <OverlayPanel\n        ref={setFloatingEl}\n        role=\"dialog\"\n        aria-label={label}\n        // Positioning is an inline style, so it is the only `fixed` in the tree\n        // and invisible to `layout/no-adhoc-layout` (which scans classNames).\n        // `display: none` rides along for the same reason — and because a\n        // className toggle would be a second thing that could disagree with\n        // `inert`.\n        style={{ ...floatingStyles, display: open ? undefined : \"none\" }}\n        inert={!open}\n        aria-hidden={!open}\n        padding=\"xs\"\n        // Invisible until placed. Closed, the panel has no reference, so its\n        // styles sit at the viewport origin; opening shows it in that same\n        // commit, and Floating UI's first measurement lands a commit later —\n        // the panel would flash top-left for a frame. Same guard as\n        // `floating-surface`: hidden until positioned, and it fades in.\n        data-positioned={isPositioned ? \"\" : undefined}\n        className=\"pointer-events-auto transition-opacity not-data-[positioned]:opacity-0\"\n      >\n        <Stack ref={dockRef} gap=\"2xs\" align=\"stretch\" />\n      </OverlayPanel>\n    </ViewportOverlay>\n  );\n}\n","import { planMoves } from \"@plugins/primitives/plugins/adaptive-bar/core\";\nimport { focusElement } from \"@plugins/primitives/plugins/dom/plugins/scroll-reveal/web\";\n\n/**\n * Moving one DOM node without destroying what lives inside it.\n *\n * Every re-parent is destructive in ways React cannot see and cannot restore:\n * it releases pointer capture, drops an open popover out of the top layer,\n * resets inner scroll offsets, restarts CSS transitions, blows away focus, and\n * — the one genuinely unrecoverable case — reloads an `<iframe>`.\n *\n * `moveBefore` (the state-preserving move) fixes all of that at once. It is not\n * everywhere yet, and `tauri/` ships WebKit on macOS, so everything below is\n * written twice: the cheap correct path, and the fallback that repairs by hand\n * what it can and REFUSES the case it cannot.\n */\n\n/** The state-preserving move, as a capability of one parent element. */\ninterface MoveBeforeCapable {\n  moveBefore(node: Node, child: Node | null): void;\n}\n\nfunction asMoveBeforeCapable(parent: Element): MoveBeforeCapable | undefined {\n  const candidate = parent as Element & Partial<MoveBeforeCapable>;\n  return typeof candidate.moveBefore === \"function\"\n    ? (candidate as MoveBeforeCapable)\n    : undefined;\n}\n\n/**\n * Does this document support state-preserving moves at all?\n *\n * Probed on the prototype, not on a live parent, because the answer decides\n * whether an iframe-bearing item is relocatable — a question the bar must\n * answer BEFORE it plans a move, not while performing one.\n */\nexport function supportsStatePreservingMove(): boolean {\n  return (\n    typeof Element !== \"undefined\" &&\n    typeof (Element.prototype as Partial<MoveBeforeCapable>).moveBefore ===\n      \"function\"\n  );\n}\n\n/** Does this container hold something a plain re-parent would destroy outright? */\nexport function holdsIframe(container: Element): boolean {\n  return container.querySelector(\"iframe\") !== null;\n}\n\n/** One element's scroll position, and how to put it back. */\ninterface ScrollShot {\n  el: Element;\n  top: number;\n  left: number;\n}\n\n/**\n * Snapshot everything a plain `insertBefore` is about to lose and hand back the\n * repair.\n *\n * Only focus and scroll offsets are recoverable. Pointer capture, the top\n * layer, `:hover` and running transitions are not — which is why the locks that\n * keep an item still during a drag or an open popover are mandatory rather than\n * a nicety, and why nothing inside a bar item may be `position: sticky`.\n */\nfunction snapshotFragileState(container: Element): () => void {\n  const active = document.activeElement;\n  const focused =\n    active instanceof HTMLElement && container.contains(active) ? active : null;\n\n  // Only NON-ZERO offsets are worth restoring: a zero is where a reset lands\n  // anyway, so recording it would just be work.\n  const scrolls: ScrollShot[] = [];\n  const walk = (el: Element): void => {\n    if (el.scrollTop !== 0 || el.scrollLeft !== 0) {\n      scrolls.push({ el, top: el.scrollTop, left: el.scrollLeft });\n    }\n    for (const child of el.children) walk(child);\n  };\n  walk(container);\n\n  return () => {\n    for (const shot of scrolls) {\n      // Not a scroll GESTURE — the auto-scroll / scroll-reveal primitives own\n      // those, and neither models this: the offset is not being changed, it is\n      // being put back where the browser just threw it away. There is nothing to\n      // animate, nothing to stick to, and no element to reveal.\n      // eslint-disable-next-line scroll-safety/no-adhoc-scroll-write -- restoring an offset a re-parent destroyed, not driving a scroll; `moveBefore` makes this whole branch dead where it exists\n      shot.el.scrollTop = shot.top;\n      // eslint-disable-next-line scroll-safety/no-adhoc-scroll-write -- see above\n      shot.el.scrollLeft = shot.left;\n    }\n    // `preventScroll` because the refocus is repair, not navigation: scrolling\n    // an ancestor to reveal the node would move the page under a user who never\n    // asked for it.\n    focusElement(focused, { reveal: false });\n  };\n}\n\n/**\n * Put `node` immediately before `before` inside `parent` (append when `before`\n * is `null`), preserving as much as this browser allows.\n *\n * `moveBefore` throws a `HierarchyRequestError` when either end is disconnected,\n * which is exactly the state a container is in on the very first pass — it was\n * created in a `useState` initializer and has never had a parent. That case\n * loses nothing (there is no live state in a node that has never been\n * displayed), so it takes the plain path.\n */\nexport function relocateNode(\n  parent: Element,\n  node: Element,\n  before: Node | null,\n): void {\n  const capable =\n    node.isConnected && parent.isConnected\n      ? asMoveBeforeCapable(parent)\n      : undefined;\n  if (capable !== undefined) {\n    capable.moveBefore(node, before);\n    return;\n  }\n  const restore = snapshotFragileState(node);\n  parent.insertBefore(node, before);\n  restore();\n}\n\n/**\n * Is this container docked at its own anchor right now?\n *\n * **The one statement of \"in the row\"**, and it names the anchor rather than the\n * bar root on purpose. The root was an assumption — that the anchor is a direct\n * child of it — and the assumption is false for every host that renders its\n * items through a slot: between the bar and a contribution sit `slot-render`'s\n * box and reorder's two wrappers, all three `display: contents` outside edit\n * mode. `display: contents` removes a box from LAYOUT but not from the DOM\n * TREE, so the anchor is two or three levels down while its container is still,\n * correctly, a flex item of the bar root.\n *\n * `nextSibling === anchor` already implies the two share a parent, so this is\n * the whole invariant and there is nothing else to compare.\n */\nexport function isDockedInline(container: Element, anchor: Element): boolean {\n  return container.nextSibling === anchor;\n}\n\n/**\n * Place a still-in-the-row container immediately before its own anchor.\n *\n * The anchor is the zero-size marker React renders at the item's natural\n * position, so \"before my anchor\" IS the item's place in the author's order —\n * including whatever non-item children the host interleaved. That makes the\n * inline dock's ordering rule a per-item local check rather than a whole-row\n * diff, and the guard below is the property that matters: **a node already in\n * the right place is never touched**, so a resize that moves one widget leaves\n * the other six — their focus, their transitions, their scroll offsets — alone.\n *\n * **The anchor's own parent decides where the container goes** — see\n * {@link isDockedInline}. Docking into the bar root instead would throw the\n * moment a host put anything at all between itself and its items, which is what\n * `.Render` does for every one of them.\n */\nexport function dockInline(container: Element, anchor: Element): boolean {\n  if (isDockedInline(container, anchor)) return false;\n  const parent = anchor.parentElement;\n  if (parent === null) {\n    // Never reached from the bar, which finds its anchors by querying its own\n    // subtree — so an anchor with no parent means a caller invented one, and a\n    // silent skip would leave the occupant wherever it happened to be.\n    throw new Error(\n      \"adaptive-bar: cannot dock an occupant against an anchor that has no parent\",\n    );\n  }\n  relocateNode(parent, container, anchor);\n  return true;\n}\n\n/**\n * Reconcile a dock's children to exactly `wantIds`, in that order, with the\n * fewest moves.\n *\n * Used for the panel (and the parked bucket), where there are no anchors to\n * key off — the dock's whole content is the bar's to arrange. `planMoves` is an\n * LIS diff, so an unchanged order plans zero moves.\n *\n * **CALLER CONTRACT: strays must already be gone.** `planMoves` reads\n * `beforeId: null` as *append*, which is only the right place once every node\n * absent from `wantIds` has left this dock. The bar discharges that by running\n * the INLINE pass first: an occupant returning from the panel to the row is\n * pulled out by its own `dockInline`, so by the time this runs the dock holds\n * nothing it should not. Reversing the two passes would break the precondition,\n * not satisfy it.\n *\n * The `want.has(id)` filter below is therefore belt-and-braces rather than the\n * mechanism — it covers the one case the inline pass cannot, a host flipping\n * `overflow` at runtime so the eviction dock itself changes identity. It never\n * removes a stray here: every registered container appears in exactly one dock's\n * want list, so the pass that claims it pulls it out, and evicting it twice\n * would be a second pointless re-parent — a free way to lose focus.\n */\nexport function dockGroup(\n  dock: Element,\n  wantIds: readonly string[],\n  containerOf: (id: string) => Element | undefined,\n): number {\n  const want = new Set(wantIds);\n  const currentIds: string[] = [];\n  for (const child of dock.children) {\n    const id = child.getAttribute(\"data-adaptive-bar-item\");\n    if (id !== null && want.has(id)) currentIds.push(id);\n  }\n\n  const moves = planMoves(currentIds, [...wantIds]);\n  for (const move of moves) {\n    const node = containerOf(move.id);\n    if (node === undefined) continue;\n    const before = move.beforeId === null ? null : containerOf(move.beforeId);\n    relocateNode(dock, node, before ?? null);\n  }\n  return moves.length;\n}\n","/**\n * Does this box draw nothing at all?\n *\n * **The one statement of \"absent\"** for an occupant's container and for the\n * yielding cell. Absent means no text and no element that makes a box: every\n * element inside is `display: contents`.\n *\n * Not `childElementCount === 0`, which is what this replaced. A widget rendered\n * straight into the bar has no wrapper, so the two agree — but a contribution\n * rendered through a slot arrives inside reorder's list span, `slot-render`'s\n * box and reorder's two item wrappers, all `display: contents` outside edit\n * mode, and they are there whether or not the contribution inside them returned\n * `null`. Counting children saw those four and called every slot occupant\n * present, so an authored `⋯` bucket whose members all declined a row still\n * painted its trigger, and one with a single applicable member could not tell.\n * A `contents` box is exactly a box that draws nothing, so the wrappers need no\n * naming here: any future wrapper of that kind is transparent to this for free.\n */\nexport function rendersNothing(el: Element): boolean {\n  if ((el.textContent ?? \"\").trim() !== \"\") return false;\n  for (const child of el.querySelectorAll(\"*\")) {\n    if (getComputedStyle(child).display !== \"contents\") return false;\n  }\n  return true;\n}\n","import {\n  useContext,\n  useLayoutEffect,\n  useRef,\n  type ReactElement,\n  type ReactNode,\n} from \"react\";\nimport { cn } from \"@plugins/primitives/plugins/css/plugins/ui-kit/web\";\nimport { yieldClass } from \"@plugins/primitives/plugins/css/plugins/yield/web\";\nimport { fillClasses } from \"@plugins/primitives/plugins/css/plugins/fill/web\";\nimport { BarRegistryContext } from \"./registry\";\nimport { rendersNothing } from \"./presence\";\n\n/**\n * The yielding cell's floor, in multiples of its own font size: the width below\n * which it stops giving and the row is judged to have overflowed.\n *\n * **Why there is a floor at all.** Without one this cell gives until it is\n * nothing, and it gives FIRST — the occupants are rigid, so flex takes the whole\n * deficit out of the one child that can shrink. The row therefore never\n * overflows, the fit is never asked to demote or relocate anybody, and the pane\n * title is the first and total casualty of a busy header: \"Une Sorcière Comme\n * Les Autres\" renders as \"Une\" at 1400px and disappears entirely at 900px while\n * every display option stays inline. A cell that can always give is a cell that\n * pays for everyone.\n *\n * **The unit is the cell's own font size, not pixels.** The floor is about\n * LEGIBILITY — how many characters survive — and characters scale with the\n * active typography and density presets, which change at runtime. A px constant\n * would mean sixteen characters under one preset and ten under another: the same\n * mistake as the `MORE_BTN_W = 32` this primitive replaced, in a different\n * costume, and the same reason `readRowMetrics` reads the row's gap off the\n * rendered element rather than re-deriving it from the `gap` prop.\n *\n * `ch` — the width of the \"0\" glyph — is the more literal unit for \"how many\n * characters\", but reading one costs a measured glyph: an element to insert, a\n * reflow to read it, per pass. `em` is in the computed style already, scales\n * with the ambient font identically, and differs from `ch` by a constant factor\n * that this number is chosen in anyway.\n *\n * **8em** is ~112px at the pane header's 14px, and a proportional UI sans\n * averages about half an em per glyph — so roughly 16 characters, which is where\n * a truncated title still tells two panes apart (\"Une Sorcière Com…\",\n * \"conversation-det…\"). Below that it is a stub, and a stub is not worth the\n * room the actions gave up for it.\n *\n * One number in the primitive rather than a prop at every call site: what makes\n * a title legible is a property of text, not of the surface hosting it, and a\n * knob here would be a knob every consumer has to have an opinion about.\n */\nconst YIELD_FLOOR_EM = 8;\n\n/**\n * What the CSS-wide initial `medium` font size resolves to, used only where the\n * computed style answers with a keyword instead of a length — which is jsdom,\n * whose `getComputedStyle` returns `\"medium\"` for an unset font size. A real\n * engine always answers in `px`.\n *\n * Not a silent absorb of a bad read: the alternative is a floor of 0, which is\n * this feature switched off, and a suite that cannot drive the floor is a suite\n * that pins nothing about it. A test that cares sets an inline `font-size`,\n * which jsdom resolves faithfully.\n */\nconst MEDIUM_FONT_PX = 16;\n\n/**\n * The room this bar must hold back from its occupants for the yielding cell.\n *\n * Zero when there is no yielding child, and zero when it is rendering nothing.\n * Otherwise {@link YIELD_FLOOR_EM} times the cell's OWN computed font size —\n * the cell's, not the row's, because the title may set its own type scale and\n * the floor is about that text.\n */\nexport function yieldFloorPx(el: HTMLElement | null): number {\n  if (el === null || rendersNothing(el)) return 0;\n  const fontPx = Number.parseFloat(getComputedStyle(el).fontSize);\n  return YIELD_FLOOR_EM * (Number.isFinite(fontPx) ? fontPx : MEDIUM_FONT_PX);\n}\n\n/**\n * Drops a growing yield cell's grow while its bar holds an explicit slack\n * claimant (`data-slack-claim`, a reorder spacer) OUTSIDE the cell, so the two\n * never split the row's slack. `flex-initial` (0 1 auto), not `grow-0`: the\n * grow cell's basis is 0, so dropping only the grow would collapse the title to\n * nothing — it has to go back to its own content width, still free to shrink\n * below it.\n *\n * A claimant INSIDE the cell (a spacer in the title's own slot, e.g. the\n * conversation header pushing its chips right) is the opposite case: that\n * spacer can only take slack the cell has, so the cell must keep growing —\n * hence the `:not(:has(…))`, or the whole title would bunch at the row's end.\n *\n * Spelled as `[bar]:has(claim) <this cell>`, never Tailwind's\n * `group-has-*`: that compiles to `:is(.group:has(…) *)`, whose `*` makes\n * Chrome restyle the whole subtree under every `:has()`-flagged ancestor on\n * each DOM insertion or removal (a zooming map swapped seconds of restyles).\n */\nconst YIELD_TO_SLACK_CLAIM =\n  \"[[data-adaptive-bar-root]:has([data-slack-claim])_&:not(:has([data-slack-claim]))]:flex-initial\";\n\nexport interface AdaptiveBarYieldProps {\n  /**\n   * Also take the row's leftover, making this cell a `Fill` — it gives AND\n   * grows.\n   *\n   * Which is what a LEADING yielding child needs in an `align=\"end\"` row: with\n   * no growing cell the row's free space collects in front of everything, so a\n   * title would be packed against the actions on the far edge instead of\n   * sitting at the row's start. Growing here puts the slack between the two,\n   * where a header's slack belongs, and a cell holding no content still holds\n   * the slack — so a title-less header keeps its actions in exactly the same\n   * place as a titled one.\n   *\n   * Unless the row holds a reorder `spacer`: the author then placed the slack\n   * themselves, so this cell stops growing and whatever follows it sits right\n   * against it instead of halfway across the row.\n   *\n   * It stays invisible to the fit either way: `flex: 1 1 0%` contributes no\n   * width of its own to the row, and `min-w-0` means the grow is surrendered\n   * first when the occupants need the room. Default false — a yielding child\n   * that merely sits among its neighbours (a trailing status strip) wants the\n   * bar to hand out the slack, not this cell.\n   */\n  grow?: boolean;\n  children: ReactNode;\n  className?: string;\n}\n\n/**\n * The bar's one **yielding** child: the row's give.\n *\n * Everything else in a bar is an occupant — measured, laddered, demoted, and\n * relocated when the row runs out of room — and rigid, because the width ledger\n * rests on an occupant's width being its own. This is the opposite of all of\n * that, and it is the pane title's shape:\n *\n * - **Excluded from the fit ledger.** It never registers, and the bar's math\n *   reads registered containers' rects, so it is invisible to the fit by\n *   construction rather than by a flag the fit has to remember to skip. It is\n *   never measured, never demoted, never relocated.\n * - **{@link yieldClass} rather than rigid.** `min-w-0` lets it fall below its\n *   own content width, so it absorbs whatever the occupants leave and the\n *   `<Text>` inside it ellipsizes — instead of pushing the actions out of the\n *   row, which is what a rigid title does.\n * - **Down to a floor, and no further.** It reserves {@link YIELD_FLOOR_EM} of\n *   its own font size out of the fit's budget, so pressure past that width is\n *   the row overflowing and the bar relocates an occupant instead of taking the\n *   last of the title. Without it this cell gives first and gives everything,\n *   the row never overflows, and nothing else is ever asked to move.\n *\n * It takes no slack by default (`flex-grow` stays 0): a yielding child sits\n * against its neighbours, and the row's slack is the bar's to hand out. Pass\n * {@link AdaptiveBarYieldProps.grow} when this cell should hold that slack\n * itself, which is what a LEADING title in an `align=\"end\"` row needs. The\n * other child that grows is the\n * reorder `spacer` node — the other half of `Fill`\n * ([`grow`](../../../css/plugins/grow/CLAUDE.md) to this one's\n * [`yield`](../../../css/plugins/yield/CLAUDE.md)) — which needs nothing from\n * this primitive: `flex: 1 1 0%` with no content contributes no width to the\n * row, so the fit's sum-of-occupants is untouched either way.\n *\n * **At most one per bar, enforced loudly.** See `BarRegistry.claimYield`: two\n * of them would split the leftover between themselves, both ellipsize, and\n * which one loses would be decided by their content rather than by the author.\n *\n * Outside a bar it is still an ordinary yielding cell — a primitive that only\n * works in one place is a primitive nobody composes, the same reason\n * `AdaptiveBar.Item` is transparent there.\n */\nexport function AdaptiveBarYield({\n  grow = false,\n  children,\n  className,\n}: AdaptiveBarYieldProps): ReactElement {\n  const registry = useContext(BarRegistryContext);\n  const cellRef = useRef<HTMLDivElement>(null);\n\n  // In an effect rather than in render: render is re-entrant and (under\n  // StrictMode) double-invoked, so a claim taken there would accuse a bar of\n  // holding two yielding children when it holds one. The commit phase is where\n  // \"these two are mounted at the same time\" is a fact — and where the cell has\n  // a node, which the claim now hands over: the floor is read off this element,\n  // so the bar has to know which one it is.\n  useLayoutEffect(() => {\n    const cell = cellRef.current;\n    if (registry === null || cell === null) return;\n    // Whether this cell renders anything decides whether it reserves anything,\n    // and the child list is the one signal that survives in both directions —\n    // the same reason an occupant watches its own container (`bar-item.tsx`).\n    // A title arriving after its data loads must start reserving room, and one\n    // that goes away must stop.\n    const observer = new MutationObserver(() => {\n      registry.yieldContentChanged();\n    });\n    observer.observe(cell, { childList: true });\n    const release = registry.claimYield(cell);\n    return () => {\n      observer.disconnect();\n      release();\n    };\n  }, [registry]);\n\n  // Growing, this cell IS a `Fill` — so it says so with `fillClasses`, the one\n  // sanctioned home for the `min-w-0 flex-1` pair, rather than re-deriving it\n  // from the two halves here. The grow is only the DEFAULT home of the slack:\n  // when the row holds an explicit claimant (a reorder spacer, marked\n  // `data-slack-claim`), the author has said where the slack goes, and a second\n  // claimant would split it — stranding whatever sits between this cell and the\n  // spacer in the middle of the row.\n  const cellClass = grow\n    ? // eslint-disable-next-line layout/no-adhoc-layout -- a grow withdrawn only while a sibling spacer claims the slack; no primitive expresses conditional slack\n      cn(fillClasses(\"x\"), YIELD_TO_SLACK_CLAIM)\n    : yieldClass(\"x\");\n\n  return (\n    <div ref={cellRef} className={cn(cellClass, className)}>\n      {children}\n    </div>\n  );\n}\n","import {\n  useCallback,\n  useContext,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  useState,\n  type PointerEvent as ReactPointerEvent,\n  type ReactElement,\n  type ReactNode,\n} from \"react\";\nimport {\n  assign,\n  barRung,\n  clearAbsentRungs,\n  describeEvidence,\n  dropItem,\n  emptyBlockedRungs,\n  emptyWidthCache,\n  estimate,\n  inlineWidthsFor,\n  isAbsentRung,\n  isShifted,\n  markAbsentRung,\n  noAbsentRungs,\n  offeredRungCount,\n  overflowPx,\n  passBudget,\n  premiseShift,\n  pushRound,\n  recordMoves,\n  staleOthers,\n  summarizeRounds,\n  sweepBarred,\n  unbarItem,\n  write,\n  type AbsentRungs,\n  type BlockedRungs,\n  type FitItem,\n  type MovedWidth,\n  type Round,\n  type RoundItem,\n  type Span,\n  type WidthCache,\n} from \"@plugins/primitives/plugins/adaptive-bar/core\";\nimport {\n  formatLineageNode,\n  formatLineagePath,\n} from \"@plugins/primitives/plugins/ui-context/core\";\nimport { collectLineage } from \"@plugins/primitives/plugins/ui-context/web\";\nimport type {\n  ActionForm,\n  ShrinkLadder,\n} from \"@plugins/primitives/plugins/action-presentation/web\";\nimport {\n  cn,\n  SingleLineProvider,\n  useRegionForwardedAttrs,\n} from \"@plugins/primitives/plugins/css/plugins/ui-kit/web\";\nimport { type SpaceStep } from \"@plugins/primitives/plugins/css/plugins/space-ramp/core\";\nimport { Stack } from \"@plugins/primitives/plugins/css/plugins/spacing/web\";\nimport { useRequestGrow } from \"@plugins/primitives/plugins/css/plugins/grow-relay/web\";\nimport { rigidClass } from \"@plugins/primitives/plugins/css/plugins/rigid/web\";\nimport { SlotItemLayout } from \"@plugins/primitives/plugins/slot-render/web\";\nimport { useResizeObserver } from \"@plugins/primitives/plugins/dom/plugins/element-size/web\";\nimport { IconButton } from \"@plugins/primitives/plugins/icon-button/web\";\nimport { AdaptiveBarItem } from \"./bar-item\";\nimport {\n  failLoudly,\n  reportFault,\n  HARD_ROUND_CEILING,\n  HYSTERESIS_PX,\n  MAX_PREMISE_SHIFTS,\n  MAX_SLACK_PROBES,\n  MAX_SURRENDERS,\n  MAX_ZERO_RECOVERIES,\n  TRACE_ROUNDS,\n  WIDTH_EPSILON_PX,\n} from \"./diagnostics\";\nimport { DEFAULT_LADDER, formFor, inlineRungsOf, yieldRankOf } from \"./ladder\";\nimport {\n  foreignCellCount,\n  readRowMetrics,\n  useLayoutMeasured,\n  useMeasureBundle,\n} from \"./measure\";\nimport { OverflowPanel } from \"./overflow-panel\";\nimport {\n  BarFormsContext,\n  BarRegionAttrsContext,\n  BarRegistryContext,\n  type BarItemEntry,\n  type BarRegistry,\n} from \"./registry\";\nimport {\n  dockGroup,\n  dockInline,\n  holdsIframe,\n  isDockedInline,\n  supportsStatePreservingMove,\n} from \"./relocate\";\nimport { AdaptiveBarYield, yieldFloorPx } from \"./bar-yield\";\nimport { symbol } from \"@plugins/ui/plugins/icons/core\";\nimport { rendersNothing } from \"./presence\";\n\nconst moreHorizIcon = symbol(\"more-horiz\");\n\n/** What happens to an occupant the row cannot fit. */\nexport type AdaptiveBarOverflow =\n  /** Relocate it into the always-mounted panel behind a `⋯` trigger. */\n  | \"panel\"\n  /** Keep everything in the row and let the row scroll horizontally. */\n  | \"scroll\"\n  /** Drop it. Only legitimate when the host has a SECOND route to the content. */\n  | \"clip\";\n\n/** Which end of its own slack the row's occupants sit against. */\nexport type AdaptiveBarAlign = \"start\" | \"end\";\n\ninterface AdaptiveBarBaseProps {\n  /** Gap between occupants, from the closed density ramp. Default `\"xs\"`. */\n  gap?: SpaceStep;\n  /** Accessible name of the `⋯` trigger and its panel. Default `\"More\"`. */\n  label?: string;\n  /**\n   * Where the occupants sit inside the bar. Default `\"start\"`; `\"end\"` packs\n   * them against the far edge — a trailing action cluster with the row's slack\n   * in front of it, which is what a pane/toolbar header wants.\n   *\n   * A prop rather than a `className`, because the bar taking ALL the slack is\n   * its one contract: a consumer cannot answer \"where in the slack\" with a\n   * competing `Fill` sibling, so the bar has to answer it.\n   */\n  align?: AdaptiveBarAlign;\n  /**\n   * The occupants may paint OUTSIDE this bar's box, so the bar stops clipping\n   * (`overflow-visible` in place of {@link BAR_CLIP}). For a row holding\n   * something that legitimately reveals itself beyond the strip — a pane\n   * header whose title is a `CollapsibleWrap` expanding downward over the\n   * content below.\n   *\n   * It changes nothing about the fit: the clip was never the mechanism, only\n   * the backstop for a row with no room left, and an over-full row already\n   * reports its own fault. What it does change is what that backstop looks\n   * like — an over-full `spill` row paints past its edge instead of hiding the\n   * excess — which is the trade a host makes deliberately by passing this.\n   *\n   * A prop and not a `className`, for the same reason as {@link align}: the\n   * overflow is one of the mechanics this primitive owns, so reaching in with a\n   * raw `overflow-*` would fight it rather than ask it. Both axes go visible\n   * together because CSS gives no choice — `visible` on one axis with `hidden`\n   * on the other computes to `auto`, i.e. a scroll container, which is neither\n   * of the two things a caller could mean.\n   *\n   * Two of this primitive's own docs below assume the clip, and under `spill`\n   * they read differently: the `no-slack` ceiling (\"everything inline, CSS\n   * clips\") no longer has the clip to bound a row whose width it has stopped\n   * trusting, and the over-full 0px report's \"every occupant AND the `⋯` are\n   * clipped to invisibility\" becomes \"painted outside the row\" instead. Both\n   * are still reported; only what they look like changes.\n   */\n  spill?: boolean;\n  children: ReactNode;\n  className?: string;\n}\n\n/**\n * `spill` and `overflow: \"scroll\"` are the SAME question answered twice — a row\n * cannot both scroll its own excess and let that excess paint outside it\n * (`BAR_SCROLL` is `overflow-x-auto`, and one axis being non-`visible` is\n * exactly what makes the other compute to `auto`). So the two are not\n * combinable rather than merely discouraged: a `scroll` bar has no `spill` to\n * pass.\n */\nexport type AdaptiveBarProps = AdaptiveBarBaseProps &\n  (\n    | {\n        /** Default `\"panel\"`. */\n        overflow?: \"panel\" | \"clip\";\n        spill?: boolean;\n      }\n    | { overflow: \"scroll\"; spill?: never }\n  );\n\n/**\n * The bar DEFINES itself as the grow cell of its row, and that is a contract,\n * not a style choice: `barRoot.getBoundingClientRect().width` is the width the\n * bar was GIVEN, read with no ancestor-walking, no mutate-reflow-restore, and no\n * forced recalculation per sibling. (The fit's budget is that minus the root's\n * own padding and border — `readRowMetrics`'s `insetPx` — because the occupants\n * are laid out in the content box and `measureRowOverflow` judges them against\n * that same box, and minus whatever a yielding child reserved as its floor\n * (`yieldFloorPx`), which is room the occupants may not have. Do not \"simplify\"\n * either subtraction away: the first is the difference\n * between a budget and a budget for room that does not exist, and a consumer\n * `className` carrying padding is all it takes; the second is the difference\n * between a row that relocates an occupant and one that eats its own title.\n * Pinned in\n * `web/__tests__/row-inset.test.tsx`.) A primitive that took a content-sized container\n * would have to go looking for the width; this one is handed it by the layout\n * engine.\n *\n * Kept as a module const rather than an inline literal: the `no-adhoc-*` rules\n * harvest string literals reached from a `className` — so, exactly like\n * `viewport-overlay`'s `OVERLAY_ROOT`, the primitive that OWNS these mechanics\n * does not have to disable the rule that keeps them out of feature code.\n *\n * Rigidity — {@link rigidClass}, `shrink-0` — is the other half of that\n * contract, and it is what makes the width ledger's axiom true rather than\n * merely assumed: **this row never takes width from what it holds.** See\n * `core/width-cache.ts`. An ordinary flex item (`flex: 0 1 auto`) is squeezed\n * whenever its row is over-full — which is exactly the state a pass measures in,\n * since it measures the placement React has already committed. Two things then\n * go wrong at once: the ledger stores a placement-dependent number as `exact`,\n * and `measureRowOverflow` goes blind, because flex absorbs the whole deficit\n * and the occupants sum to exactly the content box.\n *\n * Whether an occupant can be squeezed at all is an accident of its content — a\n * container's floor is its own min-content, and under this row's\n * `whitespace-nowrap` a text run's min-content IS its natural width, which is\n * why every occupant shipping today happens to be safe and a widget with\n * reflowable content would not be.\n *\n * **It is declared by each rigid thing, not by the row**, and that is not a\n * preference: it used to be `[&>*]:shrink-0` here, and a parent selector reaches\n * DIRECT children only. An occupant's container is docked at its own anchor, and\n * the anchor is wherever the host put it — through `.Render` that is two or\n * three `display: contents` wrappers down, still a flex item of this row and no\n * longer a child of it. So the row-level selector silently stopped reaching the\n * containers, and a squeezable occupant is the proven blind-the-guard failure\n * (`exhibits/` → `adaptive-bar/squeezable-occupants`, 186px → 83px). The two\n * things that ARE direct children and must stay rigid say so themselves: the `⋯`\n * trigger (whose width `measureTrigger` caches, so one squeezed reading would\n * under-reserve it forever) and, by construction, every minted container\n * (`bar-item.tsx`).\n *\n * What the row therefore no longer declares for its non-occupant children is\n * deliberate rather than lost: a reorder `spacer` is `flex: 1 1 0%`, so with a\n * base size of 0 and no content there is nothing for a shrink to take, and\n * {@link AdaptiveBarYield} wants the opposite of rigid — it is the one child\n * allowed below its own content width, down to the floor it reserves out of the\n * budget so that it is not the one child paying for all the others.\n */\nconst BAR_ROOT = \"min-w-0 flex-1 whitespace-nowrap\";\n/** `panel`/`clip`: what does not fit leaves the row, and the row never spills. */\nconst BAR_CLIP = \"overflow-hidden\";\n/** `scroll`: nothing leaves the row; the row itself scrolls. */\nconst BAR_SCROLL = \"overflow-x-auto\";\n/** `spill`: an occupant legitimately paints outside the row (see the prop). */\nconst BAR_SPILL = \"overflow-visible\";\n/**\n * The collapsed bucket is the OPPOSITE of a grow cell: it is one `⋯` sitting\n * among the row's other occupants, so taking the slack would starve the very\n * items it sits beside. It also measures nothing, so it has no use for the width\n * it would be taking.\n */\nconst BAR_COLLAPSED_ROOT = \"shrink-0\";\n/** `align=\"end\"`: the occupants pack against the far edge of the bar's slack. */\nconst BAR_ALIGN_END = \"justify-end\";\n\n/**\n * A bar whose occupants shrink and relocate instead of being transformed or\n * dropped.\n *\n * ```tsx\n * <AdaptiveBar gap=\"xs\" label=\"More actions\">\n *   <SomeSlot.Render>\n *     {(item) => <AdaptiveBar.Item id={item.id}><Item {...item} /></AdaptiveBar.Item>}\n *   </SomeSlot.Render>\n * </AdaptiveBar>\n * ```\n *\n * The host names no contributor, declares no priority, hardcodes no width, and\n * renders no second copy of anything. Every policy comes from the widgets\n * themselves through `useActionForm`, because a bar's occupants come from\n * different plugins and it can name none of them.\n */\nexport function AdaptiveBar(props: AdaptiveBarProps): ReactElement {\n  const {\n    gap = \"xs\",\n    label = \"More\",\n    overflow = \"panel\",\n    align = \"start\",\n    spill = false,\n    children,\n    className,\n  } = props;\n  return (\n    <AdaptiveBarShell\n      gap={gap}\n      label={label}\n      overflow={overflow}\n      align={align}\n      spill={spill}\n      className={className}\n      collapsed={false}\n    >\n      {children}\n    </AdaptiveBarShell>\n  );\n}\n\nexport interface AdaptiveBarCollapsedProps {\n  /** Accessible name of the trigger and its panel. */\n  label: string;\n  children: ReactNode;\n  className?: string;\n}\n\n/**\n * The authored bucket: every occupant relocates, unconditionally, and nothing\n * is ever measured.\n *\n * For a slot whose layout config says \"these live behind a `⋯`\" — membership is\n * a decision the author already made, so width has no say in it. It is the same\n * item hosts and the same always-mounted panel as {@link AdaptiveBar}, minus the\n * fit math, which is why a rich widget parked here is still the same live\n * instance rather than a re-rendered menu row.\n */\nexport function AdaptiveBarCollapsed({\n  label,\n  children,\n  className,\n}: AdaptiveBarCollapsedProps): ReactElement {\n  return (\n    <AdaptiveBarShell\n      gap=\"xs\"\n      label={label}\n      overflow=\"panel\"\n      // The collapsed bucket is one `⋯` sitting among its row's other\n      // occupants, so it holds no slack to align anything against.\n      align=\"start\"\n      spill={false}\n      className={className}\n      collapsed\n    >\n      {children}\n    </AdaptiveBarShell>\n  );\n}\n\nAdaptiveBar.Item = AdaptiveBarItem;\nAdaptiveBar.Collapsed = AdaptiveBarCollapsed;\nAdaptiveBar.Yield = AdaptiveBarYield;\n\n/**\n * Which half of the chain a width fault should send the reader to.\n *\n * The ask travels through the boxes this primitive knows (the slot cell) and\n * is invisible to the ones it does not (a\n * hand-rolled wrapper `<div>`), so the count separates \"nobody above me can\n * give room\" from \"everyone I can see gave it and something I cannot see took\n * it back\".\n *\n * Module-level and called at the fault site, not derived in render: a fresh\n * string per render would churn `reconcile`, whose identity the resize\n * observer's layout effect keys on.\n */\nfunction relayNote(relays: number): string {\n  if (relays === 0) {\n    return \"No box above this bar relayed its grow request. Either it is not inside a slot cell at all — its row is simply not giving it room — or the nearest box above it is a Line/Row/Bar, which stops the ask because it IS the row; then the fix is that row, not the bar.\";\n  }\n  return `${String(relays)} box(es) above this bar relayed its grow request and every one of them applied it, so whatever swallows the grow is a box this primitive cannot see — a hand-rolled wrapper between the relay and the bar. Recompose it onto Fill / Line.`;\n}\n\n/** id → rung index, or `null` for \"left the row\". */\ntype Placement = ReadonlyMap<string, number | null>;\n\n/**\n * The three refs that together mean \"this bar has stopped deciding\": whether it\n * has, the width it stopped at, and how many times it has done so.\n *\n * Bundled so {@link commitFloor} takes all of them or none. Flooring and\n * stopping are one act — a caller able to do half of it is the render loop that\n * killed the Layout Lab pane.\n *\n * Distinct from `degraded`, and the two must not be merged. `degraded` answers\n * \"my width reading is a lie\", so its remedy is the CEILING and it latches for\n * good. This one answers \"my width is fine and my own search disagrees with the\n * engine at this width\", so its remedy is the floor and it re-arms on a resize.\n */\ninterface Surrender {\n  surrendered: { current: boolean };\n  at: { current: number | null };\n  count: { current: number };\n}\n\n/**\n * One search: everything scoped to \"this row, this question, until the answer\n * stops moving\".\n *\n * Bundled for the same reason {@link Surrender} is — a caller able to reset half\n * of it would file a fault describing a different episode, or reset the counter\n * that is the termination guarantee. {@link startEpisode} takes all of it or\n * none.\n *\n * The two counters are deliberately different, and merging them would give back\n * one of the two bugs this exists to fix:\n *\n * - `rounds` is **rounds of the same question**. A round that follows a resize,\n *   a contribution mounting or an occupant resizing itself is a new question,\n *   and answering it differently is not evidence that the search fails to\n *   settle. It resets whenever the premise moves. That is the fix.\n * - `total` is **rounds since the last settled answer**, and NOTHING resets it\n *   short of settling. It is the termination guarantee: `reconcile` re-enters\n *   itself synchronously after every commit, so an occupant that resizes itself\n *   on each of those commits would reset `rounds` forever and take the pane down\n *   with React's nested-update limit. See {@link HARD_ROUND_CEILING}.\n */\ninterface Episode {\n  rounds: number;\n  total: number;\n  /** How many times the premise moved without the search ever settling. */\n  shifts: number;\n  /** What the previous round decided from. */\n  premise: Round | null;\n  /** The last few rounds, kept for whatever fault ends the episode. */\n  trace: Round[];\n  /** Occupants that moved under the search, collapsed per (id, rung). */\n  moved: Map<string, MovedWidth>;\n  /**\n   * The best answer the search actually produced: the widest placement it\n   * blessed as fitting, from measurements rather than estimates, at the width\n   * recorded beside it.\n   *\n   * A search that runs out of rounds has usually produced perfectly good\n   * answers along the way. Throwing all of them away and taking the floor is\n   * what makes a transient fault cost the user their whole toolbar.\n   */\n  best: { placement: Placement; available: number } | null;\n  /*\n   * Every width an episode records — this one, and `promoted`'s `atWidth` — is\n   * the SEARCH's budget: the row's content box minus whatever the yielding cell\n   * reserved (`budget` in `reconcile`). Both are compared against a later pass's\n   * budget, so the currency is consistent; recording the row's own width instead\n   * would make the pair disagree exactly when a title appears or goes away.\n   */\n  /**\n   * Rungs the last committed pass promoted INTO, and the width it decided at —\n   * H2's evidence.\n   *\n   * Episode state rather than a free ref, because it is scoped to exactly what\n   * the counters and the premise are: this row, this question. A promotion is\n   * evidence only against the width, the item set and the widths it was decided\n   * at, and {@link Episode} is where \"a caller able to reset half of it\" has no\n   * spelling. In its own ref it survived every early return in `reconcile` — a\n   * collapsed pane, a surrendered bar, a zero-width row — and the next pass then\n   * barred a rung at a width that had never rejected anything.\n   *\n   * It carries its own width for the same reason. Where the premise held, the\n   * recorded width and the current pass's budget are the same number by\n   * construction; where a future early return is added they are not, and this is\n   * the spelling in which the wrong one cannot be named.\n   */\n  promoted: Map<string, { rung: number; atWidth: number }>;\n}\n\nfunction newEpisode(): Episode {\n  return {\n    rounds: 0,\n    total: 0,\n    shifts: 0,\n    premise: null,\n    trace: [],\n    moved: new Map(),\n    best: null,\n    promoted: new Map(),\n  };\n}\n\nconst EMPTY_PLACEMENT: Placement = new Map();\n\n/**\n * Where an occupant currently sits.\n *\n * Three states, and the first two must never be read as each other:\n *\n * - a stored **number** — the rung the last decision put it at;\n * - a stored **`null`** — the fit deliberately took it out of the row. Reaching\n *   for `?? 0` collapses this into the case below (`null ?? 0` is `0`), which\n *   silently puts every evicted occupant straight back in the row and makes the\n *   bar look as though it simply never overflows;\n * - **no entry at all** — the last decision did not place it. Either it mounted\n *   since, or it renders nothing at every form it was offered, so `assign` had\n *   nothing to place. Both want rung 0, and for the same reason: nothing has\n *   been decided about this occupant, so it renders as itself and its own\n *   output decides what happens next.\n *\n * That last default is safe only because an occupant that renders nothing at\n * rung 0 keeps rendering nothing there — the bar records what a widget renders\n * per RUNG and never offers one it vanishes on (`core/absent-rungs.ts`). Before\n * it did, this default was the other half of a cycle: an occupant blank at its\n * compact rung was dropped from the placement, read back here as rung 0,\n * rendered its full form, was demoted to compact, and vanished again — for ever.\n * Anyone who makes a blank rung offerable again brings that back.\n */\nfunction rungOf(placement: Placement, id: string): number | null {\n  return placement.has(id) ? (placement.get(id) ?? null) : 0;\n}\n\n/**\n * The rung an occupant of the AUTHORED bucket ({@link AdaptiveBarCollapsed})\n * sits at. The default flips: an occupant nothing has been decided about is\n * behind the `⋯`, because that is what the author asked for. Only the one case\n * the collapsed pass rules otherwise — a single present occupant, recorded as\n * rung 0 — comes back inline (see that pass for why).\n */\nfunction collapsedRungOf(placement: Placement, id: string): number | null {\n  return placement.get(id) === 0 ? 0 : null;\n}\n\nfunction AdaptiveBarShell({\n  gap,\n  label,\n  overflow,\n  align,\n  spill,\n  collapsed,\n  className,\n  children,\n}: {\n  gap: SpaceStep;\n  label: string;\n  overflow: AdaptiveBarOverflow;\n  align: AdaptiveBarAlign;\n  spill: boolean;\n  collapsed: boolean;\n  className?: string;\n  children: ReactNode;\n}): ReactElement {\n  const { measure, isRendered } = useMeasureBundle();\n  const layoutMeasured = useLayoutMeasured();\n\n  /**\n   * Is there already a bar above this one?\n   *\n   * A structural fact, read where every other structural fact is read: the\n   * registry a bar publishes for its own occupants is the same context a bar\n   * nested inside one of them sees. `null` — the overwhelmingly common case —\n   * is a bar in an ordinary row.\n   *\n   * `collapsed` is the whole exclusion, and it is not a special case being\n   * carved out: `.Collapsed` is one `shrink-0` `⋯`, it never measures, and it\n   * never asks for the row's grow, so it is not a second claimant on anything.\n   * `reorder`'s `overflow` node type renders exactly that inside a pane header,\n   * which is a composition that ships today and must stay silent.\n   */\n  const parentBar = useContext(BarRegistryContext);\n  const nestedInBar = !collapsed && parentBar !== null;\n\n  // The bar asks for its own room. Its whole premise is that\n  // `root.getBoundingClientRect().width` is a width it was GIVEN, which holds\n  // only if every box between it and its row relays the grow — so it says so\n  // from where it is rendered rather than relying on a `fill: true` declared on\n  // a contribution several files away, which is a thing two of two consumers\n  // forgot. `.Collapsed` is one rigid `⋯` and asks for nothing.\n  //\n  // `granted` is not decoration: relays apply the grow in a state update from\n  // this hook's layout effect, which React flushes AFTER every layout effect of\n  // the commit — including the reconcile below. Deciding on that first reading\n  // would judge the un-grown box, and `no-slack` latches.\n  const grow = useRequestGrow(!collapsed);\n\n  // Nodes are tracked as STATE via callback refs, not as refs read during\n  // render: the reconcile pass must re-run when one attaches, and a ref would\n  // give it no way to know.\n  const [root, setRoot] = useState<HTMLElement | null>(null);\n  const [trigger, setTrigger] = useState<HTMLElement | null>(null);\n  const [panelDock, setPanelDock] = useState<HTMLElement | null>(null);\n  const [parkingDock, setParkingDock] = useState<HTMLElement | null>(null);\n  // This bar's own region attributes: stamped on the overflow panel's overlay root\n  // (outside the panel surface — see `OverflowPanelProps.regionAttrs`), and the\n  // baseline each occupant stamps only its differences from.\n  const regionAttrs = useRegionForwardedAttrs();\n\n  const [placement, setPlacement] = useState<Placement>(EMPTY_PLACEMENT);\n  const [panelOpen, setPanelOpen] = useState(false);\n\n  /**\n   * The bar has stopped believing its own width, and renders every occupant\n   * inline forever.\n   *\n   * Reached only from a fault, and it is the honest floor for one: when the\n   * width reading is a lie, \"everything in the row, clipped by CSS\" is the one\n   * configuration that hides nothing and cannot be argued with. The narrow\n   * floor (`commitFloor`) is the opposite — it takes occupants OUT of the row,\n   * which is exactly the outcome a bad width reading was already producing.\n   *\n   * Latching matters as much as the layout: without it the recovery re-measures,\n   * re-decides, re-evicts, and oscillates forever against a host that cannot\n   * give it a straight answer.\n   */\n  const [degraded, setDegraded] = useState(false);\n  /**\n   * What the rest of the component reads. `EMPTY_PLACEMENT` has no entry for\n   * anyone, and `rungOf` reads a missing entry as rung 0 — so \"degraded\" IS\n   * \"everyone inline at their widest\", with no second code path to keep in step.\n   */\n  const effective = degraded ? EMPTY_PLACEMENT : placement;\n\n  // Everything the next decision reads but nobody renders. Bumping `version` is\n  // how a change here asks for a pass; the entries themselves never live in\n  // React state, so a pointer-down that changes nothing on screen re-renders\n  // nothing.\n  const entriesRef = useRef(new Map<string, BarItemEntry>());\n  const [version, setVersion] = useState(0);\n  const bump = useCallback(() => setVersion((v) => v + 1), []);\n\n  /**\n   * This bar's one yielding child, or `null` while it has none. The element IS\n   * the claim — a second `<AdaptiveBar.Yield>` is one arriving while this is\n   * already set — and it is what the floor is read off.\n   *\n   * A ref rather than state: nothing renders differently for it, and the one\n   * thing that reads it (the floor, per pass) runs in a layout effect.\n   */\n  const yieldCellRef = useRef<HTMLElement | null>(null);\n  /**\n   * Whether the last pass reserved a floor for that cell — i.e. whether it was\n   * rendering anything. What the content-changed signal compares against, so a\n   * cell re-rendering its own internals does not cost a fit pass.\n   */\n  const yieldReservedRef = useRef(false);\n\n  /**\n   * The declared ladders, mirrored into React state.\n   *\n   * The rest of an entry (container, holds, popup, pointer lock) stays in the\n   * ref: it is decision input, not something anyone renders. A ladder is\n   * different — it is what turns a rung into a FORM, and the form has to reach\n   * the widget through a render. Deriving it by reading the ref during render\n   * would also be a lie about reactivity: the ref can change without React\n   * knowing, so the derived map would silently go stale.\n   */\n  const [ladders, setLadders] = useState<\n    ReadonlyMap<string, Required<ShrinkLadder>>\n  >(() => new Map());\n  const putLadder = useCallback(\n    (id: string, ladder: Required<ShrinkLadder> | null): void => {\n      setLadders((prev) => {\n        if (ladder === null) {\n          if (!prev.has(id)) return prev;\n          const next = new Map(prev);\n          next.delete(id);\n          return next;\n        }\n        if (prev.get(id) === ladder) return prev;\n        const next = new Map(prev);\n        next.set(id, ladder);\n        return next;\n      });\n    },\n    [],\n  );\n\n  const cacheRef = useRef<WidthCache>(emptyWidthCache);\n  /** H2: rungs a committed promotion measured as not fitting, barred until the row is wider. */\n  const blockedRef = useRef<BlockedRungs>(emptyBlockedRungs);\n  /**\n   * Rungs an occupant has been observed to render NOTHING at, so the bar stops\n   * offering them. See `core/absent-rungs.ts` — this is what makes \"the fit put\n   * a widget where it vanishes, then un-placed it for having vanished\"\n   * unspellable rather than merely rare.\n   */\n  const absentRef = useRef<AbsentRungs>(noAbsentRungs);\n  const episodeRef = useRef<Episode>(newEpisode());\n  const triggerWidthRef = useRef<number | null>(null);\n  /**\n   * The width the grow-cell premise was last VERIFIED at, and the probes spent\n   * verifying it. The premise belongs to the host, so a host that changes after\n   * mount has to be caught — see {@link MAX_SLACK_PROBES} for why the re-ask\n   * follows the row narrowing and why it is budgeted.\n   */\n  const slackVerifiedAtRef = useRef<number | null>(null);\n  const slackProbesRef = useRef(0);\n  /**\n   * How many times this bar has re-admitted its occupants to re-ask a zero\n   * width, since the last time it reached a settled answer.\n   *\n   * See {@link MAX_ZERO_RECOVERIES} for what the recovery is and why the bound\n   * is scoped to \"since the last convergence\" rather than to the mount.\n   */\n  const zeroRecoveriesRef = useRef(0);\n  /**\n   * Whether this bar has already said that its row is over-full — the answer a\n   * recovery comes back with when the zero was never the bar's own doing. Said\n   * once per mount: the state is recoverable and self-healing, so it is worth\n   * knowing about and not worth repeating.\n   */\n  const overFullReportedRef = useRef(false);\n  /**\n   * This bar has stopped deciding, and the width it stopped at. See\n   * {@link commitFloor}: a fault-forced floor is the last placement computed\n   * for THIS width, and the bar re-arms only when the row genuinely resizes.\n   */\n  const surrenderedRef = useRef(false);\n  const surrenderedAtRef = useRef<number | null>(null);\n  const surrenderCountRef = useRef(0);\n  const surrender = useMemo<Surrender>(\n    () => ({\n      surrendered: surrenderedRef,\n      at: surrenderedAtRef,\n      count: surrenderCountRef,\n    }),\n    [],\n  );\n\n  const registry = useMemo<BarRegistry>(\n    () => ({\n      register(id, container) {\n        const entry: BarItemEntry = {\n          id,\n          container,\n          ladder: entriesRef.current.get(id)?.ladder ?? DEFAULT_LADDER,\n          declaredRungs: null,\n          holds: 0,\n          popupOpen: false,\n          pointerPinned: false,\n          immovable: false,\n        };\n        entriesRef.current.set(id, entry);\n        putLadder(id, entry.ladder);\n        bump();\n        return () => {\n          if (entriesRef.current.get(id) === entry)\n            entriesRef.current.delete(id);\n          // The item left for good, so its measurements are not an estimate of\n          // anything — unlike a rung the item merely is not sitting at, which is\n          // deliberately kept.\n          cacheRef.current = dropItem(cacheRef.current, id);\n          blockedRef.current = unbarItem(blockedRef.current, id);\n          absentRef.current = clearAbsentRungs(absentRef.current, id);\n          episodeRef.current.promoted.delete(id);\n          putLadder(id, null);\n          bump();\n        };\n      },\n      declare(id, ladder) {\n        const entry = entriesRef.current.get(id);\n        if (entry === undefined) return () => {};\n        entry.ladder = ladder;\n        // A ladder change can change the rung count, which changes what the\n        // cached widths mean — but only the widths for rungs that still exist\n        // survive, and `inlineWidthsFor` reads exactly that many.\n        //\n        // H2's bookkeeping is not so lucky, and both halves of it go: a rung\n        // index only means anything against a ladder, so a bar recorded against\n        // the old one names a different form entirely — worse than stale.\n        //\n        // Gated on the rungs REALLY changing, and that gate is load-bearing\n        // rather than an optimisation. This runs again on every FORM change (the\n        // item's channel carries its assigned form, so its declaration effect\n        // re-runs whenever the bar moves it a rung) — so an ungated invalidation\n        // would tear H2's bar down one passive effect after the pass that\n        // installed it, and the promote-measure-demote cycle H2 exists to stop\n        // would run forever, one converged episode at a time, with no counter\n        // able to see it.\n        const rungs = inlineRungsOf(ladder).join(\",\");\n        if (entry.declaredRungs !== rungs) {\n          entry.declaredRungs = rungs;\n          blockedRef.current = unbarItem(blockedRef.current, id);\n          // And what it renders at each of them. A rung index only means\n          // anything against a ladder, so \"renders nothing at rung 1\" recorded\n          // against the old one names a different form entirely.\n          absentRef.current = clearAbsentRungs(absentRef.current, id);\n          episodeRef.current.promoted.delete(id);\n        }\n        putLadder(id, ladder);\n        bump();\n        return () => {\n          const live = entriesRef.current.get(id);\n          if (live !== entry) return;\n          // Only the declaration still in force may withdraw itself. A second\n          // declarer on one item (a control nested inside a widget that forgot\n          // `ActionFormShield`) replaces the first; letting ITS release reset\n          // the item would wipe the ladder of a widget that is still mounted\n          // and still declaring — which is how a stepper lost its compact rung\n          // the moment its arrows unmounted.\n          if (live.ladder !== ladder) return;\n          live.ladder = DEFAULT_LADDER;\n          putLadder(id, DEFAULT_LADDER);\n          bump();\n        };\n      },\n      hold(id) {\n        const entry = entriesRef.current.get(id);\n        if (entry === undefined) return () => {};\n        entry.holds += 1;\n        // NO bump: a freeze changes nothing about the current layout. The\n        // RELEASE bumps, which is what makes \"deferred forever\" unrepresentable.\n        return () => {\n          entry.holds -= 1;\n          bump();\n        };\n      },\n      setPopupOpen(id, open) {\n        const entry = entriesRef.current.get(id);\n        if (entry === undefined || entry.popupOpen === open) return;\n        entry.popupOpen = open;\n        // Same asymmetry as `hold`: opening freezes and changes nothing on\n        // screen; closing is what releases a stored target.\n        if (!open) bump();\n      },\n      contentChanged(id) {\n        const entry = entriesRef.current.get(id);\n        if (entry === undefined) return;\n        // `hidden` is where the last pass recorded absence, so this compares\n        // the new truth against the committed one and stays quiet otherwise —\n        // a widget re-rendering its own internals must not cost a fit pass.\n        const absent = rendersNothing(entry.container);\n        if (absent !== (entry.container.hidden === true)) bump();\n      },\n      claimYield(cell) {\n        if (yieldCellRef.current !== null) {\n          throw new Error(\n            \"adaptive-bar: a bar has at most one <AdaptiveBar.Yield>. It is the row's give — the one child excluded from the fit ledger and allowed below its own content width — so two of them would split the leftover between themselves and both ellipsize, decided by their content rather than by the author. Make the second one an <AdaptiveBar.Item>, which the fit can size and relocate.\",\n          );\n        }\n        yieldCellRef.current = cell;\n        // The budget just lost this cell's floor, which is a smaller row for\n        // everyone else — so it is decided again rather than at the next resize.\n        bump();\n        return () => {\n          if (yieldCellRef.current !== cell) return;\n          yieldCellRef.current = null;\n          yieldReservedRef.current = false;\n          bump();\n        };\n      },\n      yieldContentChanged() {\n        const cell = yieldCellRef.current;\n        if (cell === null) return;\n        // `yieldReservedRef` is what the last pass decided from, so this\n        // compares the new truth against the committed one and stays quiet\n        // otherwise — the same discipline as `contentChanged` above.\n        if (yieldFloorPx(cell) > 0 !== yieldReservedRef.current) bump();\n      },\n    }),\n    [bump, putLadder],\n  );\n\n  /**\n   * The form each occupant renders at. Derived, never stored: the placement is\n   * the state, and a second stored copy of the same fact is a second thing that\n   * can be stale.\n   */\n  const forms = useMemo<ReadonlyMap<string, ActionForm>>(() => {\n    const map = new Map<string, ActionForm>();\n    for (const [id, ladder] of ladders) {\n      map.set(\n        id,\n        formFor(\n          ladder,\n          collapsed ? collapsedRungOf(effective, id) : rungOf(effective, id),\n        ),\n      );\n    }\n    return map;\n  }, [ladders, effective, collapsed]);\n\n  // An `⋯` with nothing behind it is dead chrome, so the trigger follows the\n  // placement rather than the item count — including in the collapsed bucket,\n  // where a contribution that rendered nothing is absent from the placement for\n  // exactly this reason.\n  const evictedCount = useMemo(() => {\n    let n = 0;\n    for (const rung of effective.values()) if (rung === null) n += 1;\n    return n;\n  }, [effective]);\n\n  const showTrigger = overflow === \"panel\" && evictedCount > 0;\n\n  /**\n   * One pass: apply the committed placement to the DOM, measure what is now\n   * inline, and decide the next placement.\n   *\n   * Split that way because a rung is React state — a widget only renders its\n   * compact form after a commit — so a pass cannot both decide and observe the\n   * consequence. Docking, by contrast, is pure DOM and happens here, following\n   * the placement React has already committed. The loop terminates by the\n   * placement repeating, not by a fixed number of rounds; the round budget is\n   * the assertion that it does.\n   */\n  const reconcile = useCallback((): void => {\n    if (root === null) return;\n    // Not yet the width this bar will have: a relay above it has taken the ask\n    // and has not applied the grow yet. Settles inside this same pre-paint\n    // layout phase (one sync pass per relay), and `grow.granted` is in this\n    // callback's closure, so the pass re-runs the moment it flips.\n    if (!grow.granted) return;\n    const entries = entriesRef.current;\n\n    // ── Order, straight from the DOM ──────────────────────────────────────\n    // Document order of the anchors IS the order the host produced, reorder\n    // middleware and all. Nothing else can be trusted: mount order gets a\n    // mid-list insertion wrong, and a consumer-declared order is a second\n    // source of truth for something the DOM already knows.\n    const anchors = [\n      ...root.querySelectorAll<HTMLElement>(\"[data-adaptive-bar-anchor]\"),\n    ];\n    const order: { id: string; anchor: HTMLElement; entry: BarItemEntry }[] =\n      [];\n    for (const anchor of anchors) {\n      const id = anchor.getAttribute(\"data-adaptive-bar-anchor\");\n      const entry = id === null ? undefined : entries.get(id);\n      if (id !== null && entry !== undefined) order.push({ id, anchor, entry });\n    }\n\n    // ── 1. Apply the committed placement ──────────────────────────────────\n    const evicted: string[] = [];\n    for (const { id, anchor, entry } of order) {\n      const absent = rendersNothing(entry.container);\n      // An absent occupant contributes no width AND NO GAP. A 0×0 flex item\n      // would still be paid for on both sides, so absence has to be `hidden`\n      // (not a flex item at all) rather than a zero width.\n      entry.container.hidden = absent;\n      const rung = collapsed\n        ? collapsedRungOf(effective, id)\n        : rungOf(effective, id);\n      if (rung === null && !absent) {\n        evicted.push(id);\n      } else {\n        // Against the ANCHOR's parent, not the bar root — see `dockInline`.\n        // Through a `display: contents` chain the container is still a flex item\n        // of this row, so gap and measurement are unchanged.\n        dockInline(entry.container, anchor);\n      }\n    }\n    // ORDER IS LOAD-BEARING: the inline loop above ran first, and that is what\n    // discharges `dockGroup`'s \"no strays\" precondition. An occupant coming back\n    // from the panel to the row has already been pulled out by its own\n    // `dockInline`, so the eviction dock holds nothing absent from `evicted` and\n    // `planMoves`' `beforeId: null` genuinely means \"append\". Running this pass\n    // first would leave a returning occupant sitting in the dock while the plan\n    // assumed it gone.\n    const evictionDock = overflow === \"panel\" ? panelDock : parkingDock;\n    if (evictionDock !== null) {\n      dockGroup(evictionDock, evicted, (id) => entries.get(id)?.container);\n    }\n    // A panel that has just emptied is dead chrome holding focus, so it closes.\n    // This is the ONE placement-driven close, and it lives here rather than in\n    // an effect because \"the panel became empty\" is a fact this pass computed.\n    // A resize alone never closes it.\n    if (evicted.length === 0) setPanelOpen(false);\n\n    // Degraded: the placement above IS \"everyone inline\", and there is nothing\n    // left to decide. Returning here rather than skipping the whole pass keeps\n    // a late-arriving occupant docked like the rest.\n    if (degraded) return;\n\n    // A bar written inside another bar's occupant has the same nothing to\n    // decide, and it stops here rather than only in the effect that reports it:\n    // a `setDegraded` made in an earlier layout effect of THIS commit is not\n    // visible to this pass's closure, so without this the inner bar would spend\n    // one pass measuring a `shrink-0` container's width — and file `no-slack`\n    // about it, one commit before the fault that names what is really wrong.\n    if (nestedInBar) return;\n\n    // The authored bucket has no width to consult — membership is the author's\n    // decision, so there is nothing to measure and nothing to converge.\n    //\n    // This return has to stay ABOVE the measurement, and the zero-width recovery\n    // below is why it is worth saying so. A collapsed bar puts EVERY occupant\n    // out of the row unconditionally, so it always looks like \"occupants\n    // relocated out of a row measuring nothing\" — and a recovery there would\n    // commit the ceiling only for this branch to put everything straight back\n    // out on the next pass, for ever.\n    //\n    // One exception, and it is about the `⋯`, not about width: a bucket whose\n    // members came to ONE on this row would put a single action behind a menu\n    // trigger that costs the same click and the same room as the action itself.\n    // So a lone present occupant stays inline at its full rung, and the trigger\n    // (which follows the evicted count) is not painted. Presence is per row —\n    // members that rendered nothing were recorded `hidden` above — so the same\n    // authored bucket is a `⋯` on one row and a plain button on the next.\n    if (collapsed) {\n      const present = order.filter(\n        ({ entry }) => entry.container.hidden !== true,\n      );\n      const lone = present.length === 1;\n      const next = new Map<string, number | null>();\n      for (const { id } of present) next.set(id, lone ? 0 : null);\n      if (!samePlacement(next, placement)) setPlacement(next);\n      return;\n    }\n\n    // ── 2. Measure ────────────────────────────────────────────────────────\n    // The CONTENT box, not the border box. The occupants are laid out inside\n    // the row's padding and border, and `measureRowOverflow` judges them\n    // against that same box — so a budget that included the padding would be a\n    // budget for room that does not exist, and the fault it produced would be\n    // the fit's arithmetic accusing the layout.\n    const metrics = readRowMetrics(root);\n    // Kept as read, not just as the budget: the slack probe compares the row\n    // holding its occupants against the row without them, and this IS the\n    // holding-them reading. Taking it twice would be a second forced reflow of\n    // a layout nothing has touched in between — and, in a test fake that models\n    // a pane being dragged, a second reading is a second drag step.\n    const rowPx = measure(root);\n    const available = rowPx - metrics.insetPx;\n    // Zero available width is not a width. Deciding from it would evict the\n    // whole row and then put it back, so we decide nothing and wait for one.\n    //\n    // With occupants already OUT of the row, a zero CAN be the bar's own doing —\n    // an empty row measures empty — and then waiting is waiting for a width that\n    // only re-admitting them could produce. That is the one absorbing state this\n    // primitive can reach, so it is not a pause. It is also not a verdict: see\n    // the recovery below.\n    //\n    // But only if the row generates a box at all. An element in a `display:\n    // none` subtree was never given a width: reading 0 off it is not a reading,\n    // it is the ABSENCE of one, and this app keeps whole surfaces mounted-but-\n    // not-rendered as a matter of course — an unfocused tab\n    // (`apps-core/plugins/surface/web/components/surface-body.tsx`), a minimized\n    // desktop window (`apps/plugins/desktop/plugins/windows/…`), a\n    // collapsed miller column (`layouts/plugins/miller/web/components/column.tsx`).\n    // That is a first-class state, not a broken host. Treating its 0 as a width\n    // is an absorbable failure value (root `CLAUDE.md`), and the act it triggers\n    // — `degraded` — latches for the life of the mount, so the surface pays for\n    // the mistake until it remounts. The quiet return keeps whatever placement\n    // the bar last committed, and the bar decides again from a real width the\n    // moment it is shown.\n    //\n    // `isRendered` costs nothing: it is asked only on the path that already read\n    // zero AND has evictions, after `measure(root)` flushed layout — so it\n    // forces no reflow of its own.\n    //\n    // And a row that DOES generate a box, and still measures nothing with\n    // occupants parked outside it, is two different things that this number\n    // cannot tell apart:\n    //\n    // - the ratchet at its end. The host shrink-wraps to the bar, so every\n    //   eviction shrank the width that decided the next one, and the row has\n    //   emptied itself. A real fault, and the ceiling is the right remedy.\n    // - a merely OVER-FULL row. `flex-1` is `flex: 1 1 0%`: when the row's other\n    //   items over-fill their container, free space is negative, and a cell\n    //   whose base size is 0 has no basis to absorb a share of it — so it\n    //   resolves to exactly 0px while fully laid out. Nothing is wrong with the\n    //   host and nothing is wrong with the bar. There is no room at this width,\n    //   and there will be again when the row widens. Latching here would take\n    //   the relocation behaviour away for the life of the mount over a row that\n    //   is merely cramped.\n    //\n    // So do not decide it from a number that carries no answer — restore the\n    // conditions under which the guard that CAN answer will run, and let it. The\n    // recovery re-admits everything, clears the premise watermark and refunds a\n    // probe, which splits the two cases on the very next pass: a shrink-wrapping\n    // host now measures its own content, so the probe below runs and faults in\n    // the words that name the defect; an over-full row measures nothing again\n    // but has nothing evicted any more, so this branch declines it and the pass\n    // is the ordinary \"no width yet\" pause, which recovers by itself the moment\n    // the row widens. {@link MAX_ZERO_RECOVERIES} is where the bound and its\n    // termination argument are written down.\n    if (available <= 0) {\n      if (evicted.length > 0 && isRendered(root)) {\n        // A gesture holds one of the occupants. Re-admitting would re-parent it\n        // out of the body-portaled panel mid-drag — pointer capture released,\n        // top layer dropped, transition restarted, the whole list the pointer\n        // lock exists to prevent. Deferred, never dropped: every release bumps,\n        // so the pass runs again the moment the gesture ends.\n        //\n        // `immovable` is deliberately NOT in this predicate, unlike the fit's\n        // own `pinned`: it never clears, so including it would defer for ever\n        // and leave a 0px row with nothing to say for itself. An immovable\n        // occupant is never evicted anyway, so re-admitting costs it nothing.\n        const gestured = order.some(\n          ({ entry }) =>\n            entry.holds > 0 || entry.popupOpen || entry.pointerPinned,\n        );\n        if (gestured) return;\n        if (zeroRecoveriesRef.current < MAX_ZERO_RECOVERIES) {\n          zeroRecoveriesRef.current += 1;\n          // Load-bearing, not tidiness: leaving the old watermark in place\n          // would make the WIDER re-admitted width read as already verified,\n          // the probe would not run, and the whole re-ask would fail silently.\n          slackVerifiedAtRef.current = null;\n          // Reserve a probe rather than refund one. `n - 1` would manufacture\n          // budget — spend-then-refund nets to zero, and `MAX_SLACK_PROBES`\n          // would stop bounding reflows at all. This guarantees exactly what\n          // the re-ask needs: that one probe is available to answer it.\n          slackProbesRef.current = Math.min(\n            slackProbesRef.current,\n            MAX_SLACK_PROBES - 1,\n          );\n          // H2's evidence goes with the placement it was evidence ABOUT. This\n          // branch returns above the premise block, so a promotion recorded\n          // before the collapse would otherwise survive the re-admission and\n          // bar a rung on the strength of a search that no longer exists —\n          // exactly what `startEpisode` clears it for.\n          episodeRef.current.promoted.clear();\n          // The ceiling as a PLACEMENT, not as `degraded`: the same layout —\n          // `rungOf` reads a missing entry as rung 0, so this is everyone inline\n          // at their widest — but one the next pass is free to leave again.\n          //\n          // Never a no-op commit, and the invariant is worth stating because a\n          // silent bail-out here would tick the counter without ever re-admitting\n          // anything: `evicted` requires `rungOf` to have returned `null`, which\n          // requires `placement.has(id)`, which an empty map cannot satisfy. So\n          // `placement` is never `EMPTY_PLACEMENT` on this path.\n          //\n          // It can also re-arm a surrendered bar, since the re-admitted width\n          // differs from the width it surrendered at. That is the right outcome\n          // — the floor evidently did not help — and `MAX_SURRENDERS` bounds it.\n          setPlacement(EMPTY_PLACEMENT);\n        } else {\n          setDegraded(true);\n          failLoudly({\n            kind: \"no-slack\",\n            label,\n            overflow,\n            ...originOf(root),\n            message: `the row measured 0px wide while occupants were relocated out of it, and it does generate a box — so this is a width its host really gave it. Re-admitting every occupant ${String(MAX_ZERO_RECOVERIES)} times never produced a width the slack probe could judge, so the bar has stopped deciding: everything back in the row, CSS clips. Two hosts reach this. One shrink-wraps to the bar, so every eviction shrinks the width that decides the next one — put the bar where there is room to give: as the growing cell of a single-line row, with no Fill or other flex-1 sibling competing for the same slack, and never inside a shrink-to-content parent (inline-flex, w-fit, Cluster). The other is a row so over-full that the bar's flex-1 cell (base size 0) has nothing left to resolve to — there the fix is the bar's SIBLINGS, which are taking more than the row has. ${relayNote(grow.relays)}`,\n          });\n        }\n      } else if (\n        zeroRecoveriesRef.current > 0 &&\n        !overFullReportedRef.current &&\n        isRendered(root)\n      ) {\n        // The re-admission ANSWERED. This row holds every occupant it has, is\n        // fully rendered, and still measures nothing — so the zero did not come\n        // from the bar's own evictions and never could have: the row it sits in\n        // is over-full, and `flex: 1 1 0%` against negative free space resolves\n        // this cell to exactly nothing.\n        //\n        // Reported, and reported once, because the alternative is silence about\n        // an invisible toolbar: at 0px with `overflow-hidden` every occupant AND\n        // the `⋯` trigger are clipped away, and a surface that shows nothing\n        // with nothing filed is the outcome this primitive's guards exist to\n        // prevent. `reportFault` rather than `failLoudly` — nothing is latched,\n        // nothing throws, and the bar goes straight back to work when the row\n        // has room. The same discipline as `empty-rung`: handled correctly, and\n        // still worth knowing.\n        //\n        // Gated on a recovery having happened, which is what makes it evidence\n        // rather than a guess — and what keeps it away from the ordinary\n        // \"not laid out yet\" pause and from the `display: none` case, which\n        // never recovers because `isRendered` refuses it first.\n        overFullReportedRef.current = true;\n        reportFault({\n          kind: \"no-slack\",\n          label,\n          overflow,\n          ...originOf(root),\n          message:\n            \"the bar's own cell resolved to 0px while it was fully rendered and holding every occupant it has — so the row it sits in is over-full: its other cells' content leaves negative free space, and flex: 1 1 0% resolves this cell to nothing. Everything the bar holds, the ⋯ trigger included, is clipped to invisibility at that width. Nothing was evicted and nothing has been latched: the bar decides again as soon as the row has room. The fix is on the SIBLING cells — make one of them shrinkable (min-w-0, or a truncating leaf) so the row stops over-filling.\",\n        });\n      }\n      return;\n    }\n\n    // ── The yielding cell's floor ─────────────────────────────────────────\n    // The room the occupants may NOT have, so that the one child which can\n    // shrink is not the one that pays for all of them.\n    //\n    // The yielding cell is `min-w-0` among rigid neighbours, so flex takes the\n    // whole deficit out of it first — and while it can still give, the row does\n    // not overflow, `assign` sees a total that fits, and nothing is ever\n    // demoted or relocated. A pane title therefore went to \"Une\" and then to\n    // nothing while ten header widgets sat inline. Reserving its floor is the\n    // whole mechanism: the search is handed a smaller row, so pressure past the\n    // floor IS overflow and is paid for the ordinary way — by an occupant\n    // moving into the `⋯`.\n    //\n    // Above the floor nothing changes: the cell still absorbs every pixel the\n    // occupants leave, so a roomy header is laid out exactly as before. Zero\n    // when there is no yielding child, and zero when it renders nothing — an\n    // empty cell has no legibility to protect, and a title-less header must\n    // land its actions where it always did.\n    const yieldFloor = yieldFloorPx(yieldCellRef.current);\n    yieldReservedRef.current = yieldFloor > 0;\n    /**\n     * What the search is handed, as against `available`, which is what the ROW\n     * has. The two are the same number until a yielding cell reserves its\n     * floor, and they are kept apart because they answer different questions:\n     * `available` is a fact about the host (did it give this bar a width at\n     * all, does its width follow its own content), and the guards that ask\n     * those questions must not see a width the bar itself subtracted from.\n     *\n     * Never negative — the difference between \"no room for the occupants\" and\n     * \"no width\" is the whole `available <= 0` branch above, and manufacturing\n     * the second from the first would send a merely-narrow row through the\n     * zero-width recovery and, in the end, latch a fault on a healthy host.\n     * Clamped, a row narrower than the floor is an ordinary total overflow: the\n     * fit seats nobody, every evictable occupant relocates behind the `⋯`, and\n     * the cell keeps whatever the trigger leaves — below its floor, because\n     * there is nothing left to take it from. Stable, because the clamp holds\n     * the budget at 0 however much narrower the row gets.\n     */\n    // Plus one gap per laid-out cell that is not the bar's own (a host's\n    // `Fill`, the yield cell): its width gives, its gap does not, and the fit\n    // only prices the gaps between its own items. See `foreignCellCount`.\n    const foreignGapsPx = layoutMeasured\n      ? foreignCellCount(root, [\n          ...order\n            .filter(({ anchor, entry }) =>\n              isDockedInline(entry.container, anchor),\n            )\n            .map(({ entry }) => entry.container),\n          ...(trigger === null ? [] : [trigger]),\n        ]) * metrics.gapPx\n      : 0;\n    const budget = Math.max(0, available - yieldFloor - foreignGapsPx);\n\n    // The bar's whole premise: `available` is handed to it and does not move\n    // when it decides. Tested against the layout engine rather than inferred\n    // from a style — `flex-grow: 1` is no promise of slack when an ancestor\n    // shrink-wraps, and that shape reads as healthy on every proxy.\n    //\n    // Asked again whenever the row is narrower than the width the premise last\n    // held at, because the premise is a property of the host and the host can\n    // change under a mounted bar. Narrowing is the ratchet's own direction and\n    // the moment a masked shrink-wrap first bites; `MAX_SLACK_PROBES` bounds\n    // what that costs during a drag.\n    const verifiedAt = slackVerifiedAtRef.current;\n    const unverified =\n      verifiedAt === null || available < verifiedAt - HYSTERESIS_PX;\n    if (unverified && slackProbesRef.current < MAX_SLACK_PROBES) {\n      const inline = order\n        .filter(\n          ({ anchor, entry }) =>\n            isDockedInline(entry.container, anchor) &&\n            entry.container.hidden !== true,\n        )\n        .map(({ entry }) => entry.container);\n      // A probe with nothing in the row proves nothing: hiding no occupants\n      // changes no width, and the two readings agree for the wrong reason.\n      if (inline.length > 0) {\n        // Before the probe, not after: a dev throw must leave the probe spent,\n        // or the fault re-arms itself on the way back out.\n        slackProbesRef.current += 1;\n        slackVerifiedAtRef.current = available;\n        if (widthFollowsContent(root, inline, measure, rowPx)) {\n          setDegraded(true);\n          failLoudly({\n            kind: \"no-slack\",\n            label,\n            overflow,\n            ...originOf(root),\n            message: `the bar's own width moves with its own content, so every eviction shrinks the width that decides the next one — a one-way ratchet with an empty row at the end of it. Put it where there is room to give: as the growing cell of a single-line row, with no Fill or other flex-1 sibling competing for the same slack, and never inside a shrink-to-content parent (inline-flex, w-fit, Cluster, or a wrapper that relays shrink but not grow). One adaptive bar per row. ${relayNote(grow.relays)}`,\n          });\n          return;\n        }\n      }\n    }\n\n    // ── The stop ──────────────────────────────────────────────────────────\n    // A surrendered bar still DOCKS — section 1 ran, so an occupant that\n    // mounted or unmounted since is placed correctly — but it does not decide.\n    // Everything below is the search, and a fault says the search cannot be\n    // trusted AT THIS WIDTH.\n    //\n    // Below the measurement rather than above it, because \"has the premise\n    // changed\" is a question about the width. A resize is the one event that\n    // makes re-deriving legitimate, and it cannot be self-inflicted: the bar is\n    // the grow cell, so this number comes from its row and never from its own\n    // content — which the slack probe just above has now VERIFIED of the layout\n    // engine rather than assumed. `MAX_SURRENDERS` is the backstop anyway.\n    if (surrenderedRef.current) {\n      const surrenderedAt = surrenderedAtRef.current;\n      // In the SEARCH's currency (`budget`), because that is what the surrender\n      // was stamped with and what it was about: a bar stops deciding because it\n      // could not fit the occupants in the room it had, and the room it had is\n      // the row minus the yielding cell's floor. The two currencies differ by a\n      // constant, so this is the same test at the same widths — except when the\n      // floor itself changes, and a title arriving genuinely IS a change in the\n      // room the search failed at.\n      const resized =\n        surrenderedAt === null ||\n        Math.abs(budget - surrenderedAt) > HYSTERESIS_PX;\n      if (!resized || surrenderCountRef.current >= MAX_SURRENDERS) return;\n      surrenderedRef.current = false;\n      startEpisode(episodeRef.current);\n    }\n\n    const gapPx = metrics.gapPx;\n    const triggerPx =\n      overflow === \"panel\"\n        ? measureTrigger(trigger, measure, triggerWidthRef)\n        : 0;\n\n    /** Every occupant this pass could legitimately read — the round's premise. */\n    const measured: RoundItem[] = [];\n    for (const { id, anchor, entry } of order) {\n      const rung = rungOf(placement, id);\n      if (rung === null) continue;\n      // Only an INLINE node is measurable. A width read in the panel describes\n      // the panel's layout, not the row's, and would poison every later fit —\n      // `write` refuses it, and this is the caller half of that contract.\n      // \"Inline\" is \"docked at its own anchor\", never \"a child of the root\":\n      // the anchor is as deep as the host put it.\n      if (!isDockedInline(entry.container, anchor)) continue;\n\n      // ── The occupant rendered nothing, and this is where that is learned ──\n      //\n      // \"Renders nothing\" is a fact about this occupant AT THIS RUNG, and an\n      // inline pass is the only place it can be read. Recorded as such (see\n      // `core/absent-rungs.ts`), so the bar stops OFFERING a rung the widget\n      // vanishes on — rather than concluding the occupant itself is nothing,\n      // dropping it from the placement, reading the hole as rung 0 next round,\n      // and flipping between the two for ever.\n      //\n      // Nothing is measured here on purpose: a hidden element reports 0 because\n      // it generates no box, not because it is 0 wide, and the ledger's\n      // discipline is that absence is decided from the DOM and never from a 0\n      // (`write` refuses one outright).\n      if (entry.container.hidden === true) {\n        // A rung outside the declared ladder is stale bookkeeping (the widget\n        // re-declared a shorter one and the placement has not caught up), so\n        // there is no form to name and nothing true to record about it. The next\n        // pass clamps it; see `clampCurrent`.\n        const declaredRungs = inlineRungsOf(entry.ladder).length;\n        if (\n          rung < declaredRungs &&\n          !isAbsentRung(absentRef.current, id, rung)\n        ) {\n          absentRef.current = markAbsentRung(absentRef.current, id, rung);\n          // Its H2 bars go: a bar says \"this rung did not fit\", which was a\n          // claim about content the occupant is evidently no longer rendering.\n          blockedRef.current = unbarItem(blockedRef.current, id);\n          // The WIDTHS deliberately do not, and the symmetry is a trap. The\n          // ladder has just been cut to this rung, so downgrading rung 0 leaves\n          // it with no wider rung to bound it: `resolveWidth` reports\n          // `unbounded`, `doesFit` is false at EVERY width, and the search walks\n          // every other occupant out of the row to pay for one widget's blank\n          // form. Nothing is lost by leaving them — this pass measured nothing\n          // (a hidden element has no box to read), and any width below the cut\n          // is unreachable until the mark is cleared, which only the\n          // content-changed clause below does, having downgraded them already.\n          //\n          // Rung 0 blank is the ordinary supported case — a contribution that\n          // renders nothing — and is nobody's bug. A blank rung BELOW it is a\n          // widget that declared a form and does not render it, which the bar\n          // now recovers from silently and which nobody would otherwise ever\n          // find out about.\n          if (rung > 0) {\n            const form = formFor(entry.ladder, rung);\n            reportFault({\n              kind: \"empty-rung\",\n              label,\n              overflow,\n              ...originOf(root),\n              item: { id, rung, form },\n              message: `bar item \"${id}\" declared a \"${form}\" form and then rendered nothing as one. That form is not offered to it again: the widget stays at its widest form and leaves the row when the row runs out of room. Render something as \"${form}\", or stop declaring it — a widget that cannot render a form right now should not be offering it.`,\n            });\n          }\n        }\n        continue;\n      }\n\n      const px = measure(entry.container);\n      measured.push({ id, rung, px });\n      const known = estimate(cacheRef.current, id, rung);\n      // ── What this occupant renders has changed ────────────────────────────\n      // Two ways to notice it, one conclusion. Either it measures differently at\n      // a rung it was already sitting at, or it is rendering at a rung recorded\n      // blank — reachable only at rung 0, since a blank rung above that is never\n      // offered again and so is never sat on.\n      const rendersAgain = isAbsentRung(absentRef.current, id, rung);\n      if (rendersAgain || (known.kind === \"exact\" && known.px !== px)) {\n        // The item's own size changed, so what we believe about its OTHER rungs\n        // is hearsay. Kept as estimates rather than deleted: an item sitting at\n        // rung 1 is only measurable at rung 1, so dropping the rest would strand\n        // it there forever.\n        cacheRef.current = staleOthers(cacheRef.current, id, rung);\n        // Its bars go outright, though. A bar says \"this rung did not fit\", and\n        // that was a statement about the content this occupant was rendering at\n        // the time — content whose size has just moved, so the rejection is\n        // about something that no longer exists.\n        blockedRef.current = unbarItem(blockedRef.current, id);\n        // And so do the rungs the bar stopped offering it, for exactly the same\n        // reason: \"renders nothing as compact\" was a claim about content that\n        // has since moved. This is the ONE channel by which a cut ladder grows\n        // back — a blank rung above 0 is never sat on again, so nothing else can\n        // ever observe it — and it costs one demote-and-measure round trip per\n        // content change, the same bound H2 lives under. It cannot re-open the\n        // flip: the fit's own demote/promote chain never produces a changed\n        // width at an UNCHANGED rung, which is the restriction the premise check\n        // rests on too.\n        absentRef.current = clearAbsentRungs(absentRef.current, id);\n      }\n      const result = write(cacheRef.current, {\n        id,\n        rung,\n        px,\n        dockedInline: true,\n      });\n      // A refusal is information, not an error: a 0 means the contribution\n      // rendered nothing, which the `hidden` flag above already recorded.\n      if (result.ok) cacheRef.current = result.cache;\n    }\n\n    // ── The premise ───────────────────────────────────────────────────────\n    // Was this round asking the same question as the last one? Only then is a\n    // changed answer evidence that the search does not settle. A resize, a\n    // contribution mounting, or an occupant resizing itself at a rung it was\n    // already sitting at are all \"somebody moved the row underneath us\" — the\n    // rounds before are about a width that no longer exists, so they are not\n    // rounds of this search and the counter starts again.\n    //\n    // The restriction to an UNCHANGED rung is what keeps this from dissolving\n    // the bound: an occupant that just changed rung is SUPPOSED to measure\n    // differently, and treating that as a moving premise would reset the\n    // counter on every round of the bar's own chain. `episode.total` bounds the\n    // other side — see HARD_ROUND_CEILING.\n    const episode = episodeRef.current;\n    const round: Round = {\n      // The premise is what the SEARCH is handed, so the round records the\n      // budget rather than the row: a yielding cell that starts (or stops)\n      // reserving its floor moved the room this search is about, exactly as a\n      // resize does, and the rounds decided before it were about a row that no\n      // longer exists.\n      available: budget,\n      // The ladder as DECLARED, never as currently offered. A cut ladder is\n      // self-inflicted — the bar found the blank rung by putting the widget\n      // there — and a premise is by definition what a decision reads that the\n      // decision itself does not cause. Counting it would reset `rounds` on the\n      // bar's own chain, blame the shift on \"the widths underneath this bar\",\n      // and (worst) clear `episode.promoted`, throwing away H2's evidence for\n      // every OTHER occupant in the row. A discovery is paid for on the budget\n      // side instead — see `FitItem.declaredRungs`.\n      shape: order\n        .map(\n          ({ id, entry }) =>\n            `${id}:${String(inlineRungsOf(entry.ladder).length)}`,\n        )\n        .join(\",\"),\n      items: measured,\n    };\n    const previous = episode.premise;\n    episode.premise = round;\n    pushRound(episode.trace, round, TRACE_ROUNDS);\n    if (previous !== null) {\n      const shift = premiseShift(previous, round, WIDTH_EPSILON_PX);\n      if (isShifted(shift)) {\n        episode.rounds = 0;\n        episode.shifts += 1;\n        recordMoves(episode.moved, shift.moved);\n        // And the promotion record goes with them. A promotion is evidence only\n        // against the width, the item set and the widths it was decided at —\n        // exactly what a shift says has moved. This is also the half that covers\n        // every early return above without enumerating any of them: a pane that\n        // collapses and reopens wider reads as a resize here, so the record from\n        // before the collapse can never bar a rung at the new width.\n        episode.promoted.clear();\n      }\n    }\n\n    // ── 3. Decide ─────────────────────────────────────────────────────────\n    // A bar's own terms are \"until the row is genuinely wider than the width\n    // that rejected this rung\". Once it is, the bar is DISCHARGED rather than\n    // dormant — so it is dropped here, at the one moment the row's width is\n    // known, instead of being left to be re-evaluated months later against a row\n    // that has been re-laid-out and re-measured since. Not memory hygiene: the\n    // ledger is bounded by items × rungs either way.\n    blockedRef.current = sweepBarred(blockedRef.current, budget, HYSTERESIS_PX);\n\n    // THE one place \"is this an occupant at all\" is decided, and the one place\n    // the offered ladder is derived. Everything downstream — the fit, the\n    // budget, the floor, the placement — takes occupants as given, so none of\n    // them repeats the rule and none of them can drift from it.\n    const items: FitItem[] = [];\n    for (const { id, entry } of order) {\n      const declaredRungs = inlineRungsOf(entry.ladder).length;\n      // What the widget declared, cut short at the first rung it has been\n      // observed to render nothing at: a form a widget does not render is not a\n      // form it has, so the fit is never offered it.\n      const rungCount = offeredRungCount(absentRef.current, id, declaredRungs);\n      // Cut to nothing: it renders nothing at every form the bar could hand it.\n      // It keeps its host and its hidden container — section 1 above docked it —\n      // but it is not an occupant, so it costs no width, no gap, cannot be\n      // evicted, and gets no entry in the placement.\n      if (rungCount === 0) continue;\n      items.push({\n        id,\n        inlineWidths: inlineWidthsFor(cacheRef.current, id, rungCount),\n        declaredRungs,\n        evictable: overflow !== \"scroll\" && !entry.immovable,\n        yieldRank: yieldRankOf(entry.ladder),\n        pinned:\n          entry.holds > 0 ||\n          entry.popupOpen ||\n          entry.pointerPinned ||\n          entry.immovable,\n        currentRung: rungOf(placement, id),\n      });\n    }\n\n    const result = assign({\n      available: budget,\n      gap: gapPx,\n      triggerPx,\n      hysteresisPx: HYSTERESIS_PX,\n      items,\n      blocked: blockedRef.current,\n    });\n    // This round's OUTPUT, kept on the round so a repeat is recognisable as a\n    // cycle in the fit rather than as a premise that keeps moving. Two different\n    // defects, two different fixes, and only the evidence can tell them apart.\n    round.decided = placementKey(result.placement);\n\n    // H2: a promotion we COMMITTED, then measured, and are now undoing at the\n    // same width was a promotion this row cannot afford. Bar that rung until the\n    // row is genuinely wider than the width that rejected it — the failed\n    // promotion measured the true width, so this costs at most one round trip\n    // per (item, rung) per content change, not one per resize.\n    //\n    // Stamped with the width the PROMOTION was decided at, never this pass's\n    // `available`. The two agree whenever the premise held, and where they do\n    // not, the promotion's own width is the only one that ever rejected\n    // anything.\n    for (const [id, promotion] of episode.promoted) {\n      const now = result.placement.get(id);\n      if (now === undefined) continue;\n      if (now === null || now > promotion.rung) {\n        blockedRef.current = barRung(\n          blockedRef.current,\n          id,\n          promotion.rung,\n          promotion.atWidth,\n        );\n      }\n    }\n\n    // The best answer the search has produced so far, kept for the case where it\n    // runs out of rounds. `fits` from measurements alone — an estimate can\n    // refuse a fit but never fabricate one, so a `fits` reached through\n    // estimates is a weaker claim than the one this fallback needs to make.\n    if (result.fits && !result.usedEstimate) {\n      episode.best = { placement: result.placement, available: budget };\n    }\n\n    if (samePlacement(result.placement, placement)) {\n      // The episode is over: the counters, the premise and the evidence all\n      // belong to a search that has finished, and carrying them into the next\n      // one would blame it for rounds it never ran.\n      startEpisode(episode);\n\n      // The row-overflow guard belongs HERE, and only here.\n      //\n      // It compares what the fit believes against what the layout engine did —\n      // so the two have to describe the SAME configuration.\n      // `measureRowOverflow` measures the row as currently rendered, which is\n      // the COMMITTED placement; `result` is what we are about to commit. On\n      // any pass where they differ, the row on screen is the one we already\n      // know is wrong and are in the middle of fixing, so checking it there\n      // reports a disagreement that does not exist — and, in dev, throws over\n      // it.\n      //\n      // Converged means rendered == blessed, which is the only state in which\n      // \"the fit says it fits and the row does not\" is a real contradiction.\n      //\n      // `usedEstimate` deliberately does NOT gate this. An estimate is an upper\n      // bound, so it can refuse a fit but never fabricate one: a `fits: true`\n      // reached through estimates is still a claim the row fits, and an\n      // overflowing row still contradicts it.\n      //\n      // In `scroll` mode the row overflowing IS the contract — nothing leaves\n      // the row and the row scrolls — so there is no contradiction to detect.\n      // The skip is mandatory rather than cosmetic: the root is user-scrollable\n      // there, so the occupants' rects shift with `scrollLeft`, and flooring a\n      // bar that was asked to scroll would shrink every one of them.\n      if (layoutMeasured && overflow !== \"scroll\" && result.fits) {\n        const overflowingBy = measureRowOverflow(root, order, trigger);\n        if (overflowingBy > 0) {\n          // The floor, unconditionally: the fit's own numbers have just been\n          // contradicted by the engine, so \"the widest placement the fit blessed\n          // as fitting\" is exactly the claim under suspicion.\n          commitFloor(items, overflow, setPlacement, surrender, budget);\n          failLoudly({\n            kind: \"row-overflow\",\n            label,\n            overflow,\n            ...originOf(root),\n            message: `the fit says everything fits and the rendered row still overflows the box the bar was given, by ${String(Math.round(overflowingBy))}px — so the widths the fit decided from are not the widths the row actually has.`,\n          });\n          // Not a settled answer: it floored and surrendered. Falling through\n          // to the clear below would refund a zero-width recovery on the way\n          // out of a fault, which is the one place it must not be refunded.\n          return;\n        }\n      }\n      // A settled answer at a real width, with nothing to report — so whatever\n      // a zero-width recovery was about is over, and the next one starts from\n      // scratch. This is the ONLY place the counter is cleared, and it is safe\n      // for a structural reason: convergence means no `setState`, so it ENDS\n      // the synchronous re-entry chain. Nothing can reach here from inside one.\n      // See {@link MAX_ZERO_RECOVERIES}.\n      zeroRecoveriesRef.current = 0;\n      return;\n    }\n\n    episode.rounds += 1;\n    episode.total += 1;\n    // Three bounds, three diagnoses, one remedy. They are counted separately\n    // because they are different bugs with different owners, and the fault says\n    // which one tripped:\n    //\n    // - `rounds` is the search's own cost, derived from the steps this row has\n    //   to give. Over it means the fit really is not settling at a premise that\n    //   held still.\n    // - `shifts` means the widths under this bar never stopped moving. Not the\n    //   search's fault, but not something to keep re-deciding through either.\n    // - `total` is the one nothing resets. It is what makes tolerating a moving\n    //   premise safe rather than unbounded — see HARD_ROUND_CEILING.\n    const stopped =\n      episode.rounds > passBudget(items)\n        ? `the placement still changed after ${String(episode.rounds)} measure-and-decide rounds at a premise that held still`\n        : episode.shifts > MAX_PREMISE_SHIFTS\n          ? `the widths underneath this bar moved ${String(episode.shifts)} times without the placement ever settling`\n          : episode.total > HARD_ROUND_CEILING\n            ? `this bar has re-decided ${String(episode.total)} times without ever settling`\n            : null;\n    if (stopped !== null) {\n      const evidence = summarizeRounds(episode.trace, episode.moved, {\n        rounds: episode.rounds,\n        shifts: episode.shifts,\n        total: episode.total,\n      });\n      const remedy = commitSurrender(\n        items,\n        episode.best,\n        overflow,\n        setPlacement,\n        surrender,\n        budget,\n      );\n      failLoudly({\n        kind: \"no-convergence\",\n        label,\n        ...originOf(root),\n        overflow,\n        message: `${stopped}. ${describeEvidence(evidence)} ${remedy} The bar has stopped deciding until the row is genuinely resized.`,\n        evidence,\n      });\n      return;\n    }\n\n    // The evidence for the NEXT pass: what this one is about to commit as a\n    // promotion, and the width it decided that at.\n    episode.promoted.clear();\n    for (const { id } of order) {\n      const from = rungOf(placement, id);\n      const to = result.placement.get(id);\n      if (to === undefined || to === null) continue;\n      if (from === null || to < from)\n        episode.promoted.set(id, { rung: to, atWidth: budget });\n    }\n    setPlacement(result.placement);\n  }, [\n    root,\n    trigger,\n    panelDock,\n    parkingDock,\n    placement,\n    effective,\n    degraded,\n    surrender,\n    collapsed,\n    overflow,\n    label,\n    measure,\n    isRendered,\n    layoutMeasured,\n    nestedInBar,\n    grow.granted,\n    grow.relays,\n  ]);\n\n  // ONE subscription covering everything that can change a width: the row's own\n  // size, the trigger's, and every occupant's — which folds in content change,\n  // font load, control-density change, theme change and zoom. Its first callback\n  // runs in the frame's after-layout pass (`dom/after-layout`), which is what\n  // gives the cold start no flash: measure, decide and re-commit all happen\n  // before paint — each re-commit's own pass draining in the same frame.\n  useResizeObserver(\n    () => {\n      if (root === null) return null;\n      const observed: Element[] = [root];\n      if (trigger !== null) observed.push(trigger);\n      for (const entry of entriesRef.current.values())\n        observed.push(entry.container);\n      return observed;\n    },\n    reconcile,\n    { deps: [reconcile, version] },\n  );\n\n  // ── The two contract-free locks ──────────────────────────────────────────\n  // React synthetic events bubble the FIBER tree, not the DOM tree, so the bar's\n  // own root sees a pointer-down inside a widget that physically lives in the\n  // body-portaled panel. That is what makes this work with no author opt-in:\n  // the item under the pointer is pinned for the duration of the gesture, and\n  // `useHoldShrink` is left to cover only what survives the release.\n  const onPointerDownCapture = useCallback(\n    (e: ReactPointerEvent): void => {\n      const target = e.target as Node | null;\n      if (target === null) return;\n      for (const entry of entriesRef.current.values()) {\n        if (!entry.container.contains(target)) continue;\n        entry.pointerPinned = true;\n        // A release outside the bar (the pointer left the widget, or capture was\n        // never taken) would never reach a React handler here, and a permanently\n        // pinned item is worse than a moved one. The document listeners are the\n        // fail-safe, and they run once.\n        const release = (): void => {\n          entry.pointerPinned = false;\n          document.removeEventListener(\"pointerup\", release, true);\n          document.removeEventListener(\"pointercancel\", release, true);\n          bump();\n        };\n        document.addEventListener(\"pointerup\", release, true);\n        document.addEventListener(\"pointercancel\", release, true);\n        return;\n      }\n    },\n    [bump],\n  );\n\n  /**\n   * Said once per mount, and only once the root is attached so the fault can\n   * name WHERE the nested bar is written — `origin` is the innermost UI-context\n   * node above the bar's root, and it is the field the report is deduped on.\n   */\n  const nestedReportedRef = useRef(false);\n  // \"One adaptive bar per row\", enforced instead of written down.\n  //\n  // Not part of `reconcile`, and deliberately so: nesting is a fact about the\n  // TREE, not about a width, so it holds from the first commit and needs no\n  // measurement to establish. Routing it through the pass would also make it\n  // unreachable in exactly the shape it describes — a nested bar's grow ask is\n  // swallowed by the rigid container it sits in, so `reconcile` can return at\n  // `!grow.granted` and never reach a guard placed below it.\n  //\n  // The remedy is `no-slack`'s (the ceiling, latched) rather than the floor's,\n  // and for the same reason: a bar inside another bar's occupant is inside a\n  // `shrink-0` container, so every width it reads is its own content's. An\n  // eviction is precisely what a bad width reading was already producing.\n  // Committed BEFORE the throw, so the dev crash leaves behind the layout that\n  // hides nothing.\n  useLayoutEffect(() => {\n    if (!nestedInBar || root === null || nestedReportedRef.current) return;\n    nestedReportedRef.current = true;\n    setDegraded(true);\n    failLoudly({\n      kind: \"nested-bar\",\n      label,\n      overflow,\n      ...originOf(root),\n      message:\n        \"this bar is rendered INSIDE another adaptive bar's occupant, and one adaptive bar per row is the primitive's contract. Both bars declare themselves min-w-0 flex-1 and ask the row above for its slack, so the inner one takes all of it and the outer one is left measuring its own content — which the outer bar then reports as no-slack, blaming a host that is fine. The inner bar has stopped deciding: every occupant back in the row, CSS clips. Delete it and render its occupants as ordinary children of the widget, so the OUTER bar's ⋯ collapses them; a bar per row is what makes either bar's width mean anything. (An AdaptiveBar.Collapsed nested in a bar is legitimate and never reaches this: it is one shrink-0 ⋯ that measures nothing.)\",\n    });\n  }, [nestedInBar, root, label, overflow]);\n\n  // Detect the one case a plain re-parent destroys outright, once per item, at\n  // the moment we would otherwise move it.\n  useLayoutEffect(() => {\n    if (supportsStatePreservingMove()) return;\n    for (const entry of entriesRef.current.values()) {\n      if (entry.immovable || !holdsIframe(entry.container)) continue;\n      entry.immovable = true;\n      reportFault({\n        kind: \"iframe-relocation\",\n        label,\n        overflow,\n        ...(root === null ? {} : originOf(root)),\n        message: `bar item \"${entry.id}\" contains an <iframe> and this browser has no moveBefore(), so relocating it would reload the frame. It is pinned in the row instead.`,\n      });\n      bump();\n    }\n  }, [version, label, bump, root, overflow]);\n\n  const rootClass = collapsed\n    ? cn(BAR_COLLAPSED_ROOT, className)\n    : cn(\n        BAR_ROOT,\n        overflow === \"scroll\" ? BAR_SCROLL : spill ? BAR_SPILL : BAR_CLIP,\n        align === \"end\" && BAR_ALIGN_END,\n        className,\n      );\n\n  return (\n    <BarRegistryContext.Provider value={registry}>\n      <BarRegionAttrsContext.Provider value={regionAttrs}>\n        <BarFormsContext.Provider value={forms}>\n          {/*\n          A bar is a single-line strip by contract: a raw string or chip inside\n          it must not wrap the row into two lines, and a `<Text>` leaf inside a\n          widget must ellipsize rather than grow the row it is being measured\n          against.\n        */}\n          <SingleLineProvider value={true}>\n            <Stack\n              ref={setRoot}\n              direction=\"row\"\n              align=\"center\"\n              gap={gap}\n              className={rootClass}\n              // Lets a growing `AdaptiveBar.Yield` see whether the row holds an\n              // explicit slack claimant (a reorder spacer) and give the slack up.\n              data-adaptive-bar-root=\"\"\n              onPointerDownCapture={onPointerDownCapture}\n            >\n              {/*\n              The bar mints one stable container per occupant and re-parents it\n              to place it, so THAT container is each item's box. A slot rendering\n              its contributions in here must not draw a second one — it would be\n              a competing flex item that swallowed the container, and the bar's\n              gap, measurement and docking would describe the cell instead of the\n              row. Declared here so `.Render` composes inside an `AdaptiveBar`\n              the way this primitive's own docstring has always shown it.\n            */}\n              <SlotItemLayout orientation=\"host-owned\">\n                {children}\n              </SlotItemLayout>\n              <span\n                ref={setTrigger}\n                data-adaptive-bar-trigger=\"\"\n                hidden={!showTrigger}\n                // The trigger is a flex item of this row whose width\n                // `measureTrigger` CACHES, so one squeezed reading would\n                // under-reserve it forever. It says so itself now that the row no\n                // longer declares rigidity for its children — see `BAR_ROOT`.\n                className={rigidClass()}\n              >\n                <IconButton\n                  icon={moreHorizIcon}\n                  label={label}\n                  aria-haspopup=\"dialog\"\n                  aria-expanded={panelOpen}\n                  onClick={() => setPanelOpen((open) => !open)}\n                />\n              </span>\n              {/*\n              The parking dock: a live, hidden parent that always exists inside\n              the bar. `overflow=\"clip\"` drops occupants here rather than\n              detaching them, so a container is never orphaned and a clipped\n              widget comes back as the same instance the moment the row is wider.\n            */}\n              <div hidden ref={setParkingDock} />\n            </Stack>\n          </SingleLineProvider>\n          <OverflowPanel\n            open={panelOpen}\n            anchor={trigger}\n            label={label}\n            dockRef={setPanelDock}\n            regionAttrs={regionAttrs}\n            hasOpenChildPopup={() =>\n              [...entriesRef.current.values()].some(\n                (entry) =>\n                  entry.popupOpen &&\n                  panelDock?.contains(entry.container) === true,\n              )\n            }\n            onDismiss={() => setPanelOpen(false)}\n          />\n        </BarFormsContext.Provider>\n      </BarRegionAttrsContext.Provider>\n    </BarRegistryContext.Provider>\n  );\n}\n\n/**\n * The trigger's real width, never a hardcoded constant — a `MORE_BTN_W = 32`\n * is simply wrong at any other control density, and density is ambient.\n *\n * The trigger is `hidden` while nothing is evicted, so the very first fit has\n * nothing to read. Revealing it, measuring, and re-hiding inside one\n * synchronous block costs one forced reflow ONCE per bar (the answer is cached\n * and re-measured by the shared observer whenever the trigger is genuinely\n * visible) and is invisible to both React and the paint.\n */\nfunction measureTrigger(\n  trigger: HTMLElement | null,\n  measure: (el: Element) => number,\n  cache: { current: number | null },\n): number {\n  if (trigger === null) return cache.current ?? 0;\n  if (!trigger.hidden) {\n    const px = measure(trigger);\n    if (px > 0) cache.current = px;\n    return cache.current ?? 0;\n  }\n  if (cache.current !== null) return cache.current;\n  trigger.hidden = false;\n  const px = measure(trigger);\n  trigger.hidden = true;\n  // Same `px > 0` guard as the visible branch, and for a sharper reason: a 0\n  // cached HERE is permanent. A hidden element reports no resize, so the shared\n  // observer can never repair it, and every later fit would under-reserve the\n  // trigger's width and manufacture a row that overflows by exactly one button.\n  if (px > 0) cache.current = px;\n  return px;\n}\n\n/**\n * Does this bar's width follow its own content?\n *\n * The one question the whole primitive rests on, asked of the layout engine\n * directly instead of inferred from a style. Take the reading the pass already\n * has (`withContent`), hide everything the row is currently holding, read the\n * row again, put it back: a bar that was GIVEN its width measures the same\n * either way, and a bar sitting in a box that shrink-wraps to it measures its\n * own content twice.\n *\n * Every cheaper proxy misses the shape that actually ships. `flex-grow: 0` is\n * false here — the bar sets `flex-1` on itself, so the failing case reads as\n * healthy — and `measureRowOverflow` cannot fire either, because a bar whose box\n * grew to fit its own content is not overflowing that box. Both proxies describe\n * the bar's own declaration; only this one describes what the engine did with it.\n *\n * One forced reflow per ask, and invisible to React and to the paint: the\n * mutation is reverted inside the same synchronous block, so the shared\n * `ResizeObserver` compares against sizes that never changed. Same discipline\n * as {@link measureTrigger}, which reveals the hidden trigger to measure it.\n * The caller decides how often to ask — see {@link MAX_SLACK_PROBES}.\n *\n * Goes through the measurement seam rather than `getBoundingClientRect`, so the\n * jsdom suite can model a shrink-wrapping host and drive this exact path —\n * a real fixture, not a mock of the thing under test.\n */\nfunction widthFollowsContent(\n  root: HTMLElement,\n  inline: readonly HTMLElement[],\n  measure: (el: Element) => number,\n  withContent: number,\n): boolean {\n  const wasHidden = inline.map((el) => el.hidden);\n  for (const el of inline) el.hidden = true;\n  const withoutContent = measure(root);\n  inline.forEach((el, i) => {\n    el.hidden = wasHidden[i] ?? false;\n  });\n  // A pixel of tolerance: sub-pixel layout rounding is not content dependence,\n  // and the failure this catches is measured in whole occupants.\n  return Math.abs(withContent - withoutContent) > 1;\n}\n\n/**\n * Every unpinned occupant at its narrowest rung — the one configuration\n * guaranteed not to overflow, and therefore what we commit when we stop\n * believing the search.\n *\n * Only for a fault whose width reading is TRUSTWORTHY and whose fit disagrees\n * with the engine anyway. When the width itself is the lie, the floor is the\n * wrong direction entirely and `degraded` (the ceiling) is the remedy — taking\n * occupants out of the row is precisely what a bad width was already doing.\n *\n * **It is also the last placement this bar computes at this width**, and that\n * is why the surrender is latched HERE rather than by the callers: flooring and\n * stopping are one act, so there is no spelling of \"take the floor and keep\n * deciding\".\n *\n * That spelling is what took the Layout Lab pane down. A floor commit changes\n * the placement, a changed placement re-runs the measure-and-decide effect, and\n * the fit — deliberately current-state-independent apart from pins and\n * hysteresis — recomputes the same ideal it had before, converges, trips the\n * same guard, and floors again. Neither counter could stop it: the convergence\n * branch and the commit both reset the round counter, so the budget counted a\n * number that was being zeroed underneath it, and React eventually threw\n * \"maximum update depth exceeded\" over a layout disagreement.\n *\n * Scoped to the WIDTH rather than the mount, and that distinction is load-\n * bearing rather than cautious. `no-convergence` is often transient — a font\n * arriving mid-pass, a late icon — and it is observed on ordinary healthy\n * surfaces; parking such a bar at its floor until the pane is reopened buries\n * every action in the `⋯` panel, which is worse than the fault.\n * {@link MAX_SURRENDERS} bounds the re-arms.\n */\nfunction commitFloor(\n  items: readonly FitItem[],\n  overflow: AdaptiveBarOverflow,\n  setPlacement: (next: Placement) => void,\n  surrender: Surrender,\n  atWidth: number,\n): void {\n  surrender.surrendered.current = true;\n  surrender.at.current = atWidth;\n  surrender.count.current += 1;\n  const floor = new Map<string, number | null>();\n  for (const item of items) {\n    if (item.pinned === true) {\n      floor.set(item.id, item.currentRung);\n      continue;\n    }\n    // Evicting is only a remedy where an evicted occupant is still REACHABLE,\n    // and that is `panel` alone. `clip` drops its evictions into a hidden\n    // parking dock, so flooring a clip bar hides every occupant it holds — a\n    // strictly worse outcome than the clipping that mode already accepts, and\n    // for a fault whose whole premise is \"my width reading is honest\".\n    const evictable = item.evictable && overflow === \"panel\";\n    floor.set(item.id, evictable ? null : item.inlineWidths.length - 1);\n  }\n  setPlacement(floor);\n}\n\n/**\n * Stop deciding, and commit the best answer this search actually produced.\n *\n * A search that runs out of rounds has usually produced perfectly good answers\n * along the way, and the floor throws all of them away: every occupant at its\n * narrowest rung, everything evictable behind the `⋯`. That is what makes a\n * *transient* fault cost the user their whole toolbar, and the fault is\n * transient often enough to be worth this.\n *\n * The floor's one virtue is that it cannot overflow. A placement the fit blessed\n * as `fits` from measurements alone (never estimates, which can refuse a fit but\n * never fabricate one) carries the same claim, by the same arithmetic, and is\n * strictly wider — so it is preferred whenever the search produced one AT THIS\n * WIDTH. The width test is not decoration: a placement that fitted 900px says\n * nothing about 400px.\n *\n * Latching lives HERE, in both branches, and that is the load-bearing part.\n * Committing and stopping are one act, so there is no spelling of \"take the\n * fallback and keep deciding\" — which is precisely what took the Layout Lab pane\n * down: a commit changes the placement, a changed placement re-runs the\n * measure-and-decide effect, the fit recomputes the same answer, trips the same\n * guard, and commits again, forever.\n *\n * Scoped to the WIDTH rather than the mount, bounded by {@link MAX_SURRENDERS}:\n * a genuine resize is a premise this bar has not failed under, and refusing to\n * re-derive there would park a toolbar for the life of the pane.\n *\n * Returns the sentence describing what it did, for the fault message — so the\n * remedy cannot be described by a caller that does not know which branch ran.\n */\nfunction commitSurrender(\n  items: readonly FitItem[],\n  best: { placement: Placement; available: number } | null,\n  overflow: AdaptiveBarOverflow,\n  setPlacement: (next: Placement) => void,\n  surrender: Surrender,\n  atWidth: number,\n): string {\n  if (best !== null && Math.abs(best.available - atWidth) <= WIDTH_EPSILON_PX) {\n    surrender.surrendered.current = true;\n    surrender.at.current = atWidth;\n    surrender.count.current += 1;\n    setPlacement(best.placement);\n    return \"Committed the widest placement this search measured as fitting, rather than throwing the whole search away.\";\n  }\n  commitFloor(items, overflow, setPlacement, surrender, atWidth);\n  return overflow === \"panel\"\n    ? \"The search never produced a placement it could vouch for at this width, so the bar took the floor: every unpinned occupant at its narrowest rung, everything else in the overflow panel.\"\n    : \"The search never produced a placement it could vouch for at this width, so the bar took the floor: every unpinned occupant at its narrowest rung, all of them still in the row.\";\n}\n\n/**\n * Start counting again: these rounds were not part of the search that is about\n * to run.\n *\n * Called from the two places an episode genuinely ends — a converged pass, and\n * a surrender re-armed by a real resize. Takes the whole {@link Episode} for the\n * same reason {@link Surrender} is bundled: a caller able to reset the counter\n * but not the evidence would file a fault describing a different episode, and a\n * caller able to reset `total` would give back the termination bound.\n *\n * `premise` is deliberately NOT cleared. It describes the row as it currently\n * is, not the search — so the first round of the next episode can still say\n * whether a width moved underneath it.\n */\nfunction startEpisode(episode: Episode): void {\n  episode.rounds = 0;\n  episode.total = 0;\n  episode.shifts = 0;\n  episode.trace.length = 0;\n  episode.moved.clear();\n  episode.best = null;\n  // The promotion record goes too: it is H2's evidence about the search that\n  // has just finished, and the next one has not promoted anything yet.\n  episode.promoted.clear();\n}\n\n/** A placement as one comparable string — for spotting a repeat, not for equality. */\nfunction placementKey(placement: ReadonlyMap<string, number | null>): string {\n  return [...placement]\n    .map(([id, rung]) => `${id}:${rung === null ? \"-\" : String(rung)}`)\n    .sort()\n    .join(\",\");\n}\n\n/**\n * Where this bar is written.\n *\n * A generic primitive has no name of its own, and the one its consumer gave it\n * (`label`) is not an identity: it defaults to `\"More\"`, and two unrelated bars\n * on one route take that default today. The DOM already holds the answer — the\n * innermost UI-context node above the bar's root, which resolves to\n * `apps-core.tab-bar@apps.tab-bar` for the app tab strip and\n * `conversations.conversation-view.prompt-templates@prompt-editor.floating-action`\n * for the pinned prompt-template chips. Measured on the live app, not assumed.\n *\n * Deliberately NOT `nearestSource` (the build-stamped `<file>:<line>` the\n * element picker uses), even though it reads like the better name: the nearest\n * stamped element above a bar root is the picker's own marker span, or a\n * primitive the consumer composed — never the consumer. It would have been the\n * same constant for every bar in the app.\n *\n * The full lineage path is carried separately and never fingerprinted: it embeds\n * per-instance region ids, so two conversation panes would split one finding in\n * two — the mirror of the collision this exists to fix.\n *\n * On the fault path only. The walk climbs ancestors and portal chains, which is\n * far too much to pay per pass and exactly nothing to pay per fault.\n */\nfunction originOf(root: HTMLElement): { origin?: string; originPath?: string } {\n  const nodes = collectLineage(root);\n  const innermost = nodes[nodes.length - 1];\n  const path = formatLineagePath(nodes);\n  // A contribution node is already an id-free name (`plugin@slot`), and\n  // `formatLineageNode` is where that spelling lives — re-spelling it here is\n  // how two consumers of one grammar drift. A region node is NOT usable as it\n  // stands: its spelling carries the per-instance pane/tab id, so it is reduced\n  // to the parts that are the same on every mount.\n  const origin =\n    innermost === undefined\n      ? undefined\n      : innermost.kind === \"contribution\"\n        ? formatLineageNode(innermost)\n        : `${innermost.pluginId ?? \"\"}#${innermost.regionKind}`;\n  return { origin, originPath: path === \"\" ? undefined : path };\n}\n\nfunction samePlacement(a: Placement, b: Placement): boolean {\n  if (a.size !== b.size) return false;\n  for (const [id, rung] of a) {\n    if (!b.has(id) || b.get(id) !== rung) return false;\n  }\n  return true;\n}\n\n/** A px length off a computed style, where \"not a length\" means zero. */\nfunction px(value: string): number {\n  const n = Number.parseFloat(value);\n  return Number.isFinite(n) ? n : 0;\n}\n\n/**\n * By how much does the rendered row stick out of the box the bar was given?\n *\n * The second half of the grow-cell contract. `widthFollowsContent` catches \"the\n * width I read is not a width I was given\" once, at mount; this catches the\n * case where the width is honest and the fit's own numbers are not — per pass,\n * against the rendered result rather than an assumption.\n *\n * **The occupants against the bar's own content box — never an ancestor.**\n * This question used to be put to `root.offsetParent`, which is the nearest\n * *positioned* ancestor: a different thing from \"the row I am a cell of\", and\n * one that can be anywhere on the page. A bar inside a horizontally scrolled\n * strip sits hundreds of pixels to its right in viewport space while fitting\n * its own row perfectly, and was accused on every pass — which is what killed\n * the Layout Lab (now Debug → Exhibits), where every exhibit card has exactly\n * that shape. Do not reintroduce an ancestor comparison in any form;\n * `parentElement` is no better,\n * since the parent may shrink or carry padding of its own.\n *\n * **And not `root.scrollWidth > root.clientWidth` either**, tempting as the\n * one-liner is. LTR scrollable overflow ignores content past the *left* edge,\n * and `align=\"end\"` packs the occupants against the far edge — so a pane header\n * (every one of which is `align=\"end\"`) overflowing by 16px reads\n * `scrollWidth === clientWidth`. Measured, not assumed. It also folds in\n * *descendants'* overflow, so a widget's own `active:scale` transform or an\n * absolutely-positioned badge would inflate it into a false accusation, and a\n * false accusation costs the whole pane.\n *\n * Reading the occupant containers instead is exact on both counts: each rect is\n * that container's own border box, so nothing a widget paints inside itself\n * leaks into the answer, and the union covers both directions.\n */\nfunction measureRowOverflow(\n  root: HTMLElement,\n  order: readonly { anchor: HTMLElement; entry: BarItemEntry }[],\n  trigger: HTMLElement | null,\n): number {\n  const rect = root.getBoundingClientRect();\n  const style = getComputedStyle(root);\n  const box = {\n    left: rect.left + px(style.paddingLeft) + px(style.borderLeftWidth),\n    right: rect.right - px(style.paddingRight) - px(style.borderRightWidth),\n  };\n\n  const spans: Span[] = [];\n  const addIfLaidOut = (el: HTMLElement): void => {\n    // Load-bearing: an element generating NO boxes (`hidden`, which is how\n    // absence and the un-needed `⋯` are both spelled) reports a rect of all\n    // zeros — at the viewport origin, which would fabricate a full-width LEFT\n    // overflow on every bar. The layout harness documents the same trap for\n    // `display: none` slots.\n    if (el.getClientRects().length === 0) return;\n    const r = el.getBoundingClientRect();\n    spans.push({ left: r.left, right: r.right });\n  };\n  // The other filter, and it is per-KIND because \"still in the row\" is asked\n  // differently of the two. An occupant is in the row when it is docked at its\n  // own anchor, however deep the host put that anchor; one that is not has been\n  // relocated into the body-portaled panel, so its rect describes the panel's\n  // layout and says nothing about this row. The `⋯` trigger is the bar's own\n  // element and IS a direct child, so for it the parent check is exact.\n  for (const { anchor, entry } of order) {\n    if (!isDockedInline(entry.container, anchor)) continue;\n    addIfLaidOut(entry.container);\n  }\n  if (trigger !== null && trigger.parentNode === root) addIfLaidOut(trigger);\n\n  return overflowPx(box, spans);\n}\n","import type { PluginDefinition } from \"@plugins/framework/plugins/web-sdk/core\";\n\nexport {\n  AdaptiveBar,\n  AdaptiveBarCollapsed,\n  type AdaptiveBarProps,\n  type AdaptiveBarCollapsedProps,\n  type AdaptiveBarOverflow,\n  type AdaptiveBarAlign,\n} from \"./internal/adaptive-bar\";\nexport {\n  AdaptiveBarItem,\n  type AdaptiveBarItemProps,\n} from \"./internal/bar-item\";\nexport {\n  AdaptiveBarYield,\n  type AdaptiveBarYieldProps,\n} from \"./internal/bar-yield\";\nexport {\n  adaptiveBarReportSink,\n  type AdaptiveBarFault,\n  type AdaptiveBarFaultKind,\n} from \"./internal/diagnostics\";\n\nexport default {\n  description:\n    \"Overflow as relocation, not transformation: a bar that asks each widget for a smaller form of itself and moves the rest — as themselves, ONE live instance each, never rendered twice — into an always-mounted panel. Each occupant owns one stable portal container the bar re-parents imperatively, so a relocated slider is still the same slider mid-drag; measurement reads the real nodes, and every policy (which forms exist, how eagerly to yield) comes from the widget through action-presentation rather than from the host.\",\n  contributions: [],\n} satisfies PluginDefinition;\n"],"mappings":"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"}