dsh-model-think-level 1.0.7 → 1.1.1

package/lib/client/EffortEditor.d.ts

@@ -143,6 +143,22 @@ export declare function ladderIntent(nextThinking: boolean, built: EffortIntent,
  * @returns the draft, or undefined when it holds no field at all.
  */
 export declare function compatDraftOf(compat: CompatSuggestion | undefined): CompatSuggestion | undefined;
+/**
+ * The compat advice three MANUAL field values spell, from the values handed in.
+ *
+ * The editor's three compat controls are its own edit surface, so the handler
+ * that just changed one must report the value it computed: re-reading the
+ * component state there reports the PRE-update field, because React commits
+ * that state after the event — the queued write then carries the previous
+ * advice while the control already shows the new one.
+ * @param parts - the three field values as they will read after the event.
+ * @returns the draft, or undefined when all three are empty.
+ */
+export declare function manualCompatOf(parts: {
+    budgetField: string;
+    priorityText: string;
+    maxOutput: string;
+}): CompatSuggestion | undefined;
 /**
  * Assemble one complete pending write from the parts a caller resolved: the
  * compat merge (the applied suggestion's block with the caller's own fields on

package/lib/client/HeadersEditor.d.ts

@@ -14,6 +14,12 @@
  * card's own fields. The headers land through `llm-pi-ai.providers.<route>.headers`,
  * the one channel the adapter actually sends.
  *
+ * Deferred mode (`deferred`) is this same section rendered where there is no
+ * route to write TO yet — the create-provider card's 高级配置 pane, whose route
+ * the card's own 保存 declares. There the draft is reported instead of written,
+ * and the whole-dict discipline is what makes the two commit seams the same
+ * write: see {@link DeferredHeaders}.
+ *
  * @module dsh-model-think-level/HeadersEditor
  */
 import type { ReactNode } from 'react';
@@ -54,6 +60,22 @@ export interface HeaderEnvironment {
         preferOfficialLayer: boolean;
     };
 }
+/**
+ * Deferred mode: how a pane that has no route yet reports its draft.
+ *
+ * The create-provider card's 高级配置 pane edits an id the settings document
+ * does not declare — the card's own 保存 is what declares it — so that pane has
+ * nothing to write and no button to press. It hands the editor this instead:
+ * every change to the draft goes out as the complete dict its Save would write,
+ * and a Cancel reports that the draft is gone. Same component, same whole-dict
+ * discipline; only the commit seam changes, from a write to a report.
+ */
+export interface DeferredHeaders {
+    /** Every change to the draft, as the dict the editor's Save would write. */
+    onDraft: (headers: Record<string, string>) => void;
+    /** The user cleared the draft: whatever was staged for it must go. */
+    onCancel: () => void;
+}
 /** Props of {@link HeadersEditor}. */
 export interface HeadersEditorProps {
     /** The provider route this card edits. */
@@ -62,6 +84,24 @@ export interface HeadersEditorProps {
     api: RemoteApi;
     /** Localized copy. */
     t: (key: string, params?: Record<string, string | number>) => string;
+    /**
+     * Close the whole provider card, as the official footer's `取消` does.
+     *
+     * Only the mount that owns the card's DOM can press that button, so the
+     * editor takes the action as a prop instead of reaching for the DOM itself
+     * (this component needs no injection pass — see the module doc). Called by
+     * {@link cancel} in pane mode only; omitted, cancel stays a draft reset.
+     */
+    onDismiss?: () => void;
+    /**
+     * Deferred mode: report the draft instead of writing it.
+     *
+     * Set by the create-provider card's pane, whose route does not exist yet. The
+     * editor then edits in place — no disclosure, no Edit step — and has no Save
+     * of its own: its copy states that the draft lands with the card's own 保存,
+     * which is the write that declares the route the draft is addressed to.
+     */
+    deferred?: DeferredHeaders;
 }
 /** One editable header row; a stable `id` keeps React keys off the name. */
 interface DraftRow {
@@ -79,8 +119,8 @@ interface Draft {
 export declare function headersFromDraft(draft: Draft): Record<string, string>;
 /**
  * Render the provider card's request-header section.
- * @param props - route identity, write seam and copy.
+ * @param props - route identity, write seam, copy and the card dismiss seam.
  * @returns the section.
  */
-export declare function HeadersEditor({ route, api, t }: HeadersEditorProps): ReactNode;
+export declare function HeadersEditor({ route, api, t, onDismiss, deferred }: HeadersEditorProps): ReactNode;
 export {};

package/lib/client/injection/add-card.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The add-provider card: the custom-API form on its own, carrying the tab bar.
+ *
+ * The official card offers two ways to add a provider — adopt one from the
+ * built-in catalogue, or declare a custom API endpoint — behind a segmented
+ * "How to add" control. The catalogue half only duplicates the configured
+ * provider rows above it, so this pass reduces the card to the custom half: it
+ * selects that mode, hides the switch, and gives the form the same three panes
+ * its sibling editor cards carry — the bar, and the 高级配置 section the card
+ * has nowhere else to put ({@link CreateCardPane}).
+ *
+ * The card is the SAME card the tab takeover dresses (`bre-tabbed`), and that
+ * takeover scopes its regions to the visible half of the form
+ * ({@link activeScopeOf}). What it cannot do is hang the bar: the official card
+ * renders the provider-card slot only inside the catalogue half, so the custom
+ * form has no plugin mount to render a bar into. The mount is created here
+ * instead, at the top of the visible form, and it is the ONLY node this module
+ * inserts. Everything else is attributes on nodes the official page owns.
+ *
+ * Degradation is total: a card with no custom half (no API protocol to declare,
+ * or no `llm-pi-ai` namespace to declare one into) is left exactly as the
+ * official page built it, switch and all, and a card whose dressing throws is
+ * rolled back to that same state.
+ *
+ * @module dsh-model-think-level/client/injection/add-card
+ */
+import type { ReactNode } from 'react';
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots';
+import { type ForeignMount } from './mount.js';
+import type { StagedHeadersState } from './staged-headers.js';
+import type { RemoteApi } from '../types.js';
+export interface AddCardDeps {
+    /** The plugin's own translator, for the tab labels and the pane's copy. */
+    t: Translate;
+    /** The write seam the pane's header editor reads the settings document with. */
+    api: RemoteApi;
+    /** The official labels of the form's provider-id field, by locale. */
+    routeIdLabels: () => readonly string[];
+    /** The session's deferred-header ledger (see `staged-headers`). */
+    staged: StagedHeadersState;
+    /** The plugin's locale-refresh seam, so the pane's copy follows a language
+     * switch exactly as the seats the official slot mounts do. */
+    refreshed: (children: () => ReactNode) => ReactNode;
+}
+/** One card's mount, remembered by the card it belongs to. */
+interface AddCardHost {
+    /** The node the root renders into, so a re-created form can be told from a
+     * settled one. */
+    readonly host: HTMLElement;
+    readonly mount: ForeignMount;
+}
+export interface AddCardState {
+    /** Cards this module mounted a bar into. The mount goes with the card, so a
+     * card the page has dropped is dropped here on the next visit. */
+    readonly hosts: Map<HTMLElement, AddCardHost>;
+}
+export declare function createAddCardState(): AddCardState;
+/**
+ * Reduce every add-provider card on the page to its custom form.
+ *
+ * Idempotent by construction: a card already showing the custom form with its
+ * bar up is left untouched, and switching the mode is driven by the official
+ * control's own selected state, so a re-visit writes nothing.
+ */
+export declare function reconcileAddCards(root: HTMLElement, deps: AddCardDeps, state: AddCardState): void;
+/**
+ * Give every card back to the official page: the mounts go, and the switch
+ * comes out of hiding. The mode the card is left in is the official page's own
+ * state, and it is not this module's to reset — React unmounts the card whole.
+ */
+export declare function teardownAddCards(state: AddCardState): void;
+export {};

package/lib/client/injection/create-card-pane.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The create-provider card's 高级配置 pane: the tab bar and the request-header
+ * editor, for a provider that does not exist yet.
+ *
+ * This is the half {@link add-card} used to leave out. On an existing provider
+ * the same editor arrives through the official `settings.models.provider-card`
+ * slot, which the official card renders only inside its CATALOGUE half — so the
+ * custom-only card this plugin reduces it to had a tab bar whose 高级配置 button
+ * could never light up: nothing in that half carried a `.bre-headers` section for
+ * the takeover to reveal. This pane is that section, mounted at the same seat
+ * the bar is.
+ *
+ * The route the pane edits is the id the user is TYPING, which is the one thing
+ * about this card the settings document does not have yet — the card's own 保存
+ * is what declares it. So the pane cannot write as the official card can:
+ *
+ *  - the id is read off the live form (the panel's own label, never a position)
+ *    and re-read on every keystroke, because the form's React state is not ours
+ *    to subscribe to;
+ *  - the rows are editable whether or not the id has been typed: a draft is held
+ *    by the session ledger once it has a route to belong to, and until then it
+ *    simply waits for the id — which the pane does NOT announce, because the id
+ *    field is on the 供应商配置 tab of this same card and the official form
+ *    already speaks for it;
+ *  - once there is an id the editor runs in DEFERRED mode: it edits, and reports
+ *    the draft to the session ledger, but the write happens when the route
+ *    appears in the document — the proof the card's own create landed. The pane
+ *    also asks, one keystroke in, whether that id was ALREADY declared, because
+ *    only a route that was not can be this card's work. See
+ *    {@link staged-headers} for why that is a gate and not a delay.
+ *
+ * @module dsh-model-think-level/client/injection/create-card-pane
+ */
+import type { ReactNode } from 'react';
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots';
+import type { RemoteApi } from '../types.js';
+import { type StagedHeadersState } from './staged-headers.js';
+export interface CreateCardPaneProps {
+    /** The plugin's own mount inside this card; the bar resolves the card from it. */
+    host: {
+        readonly current: HTMLDivElement | null;
+    };
+    /** The write seam, for the editor's own settings read. */
+    api: RemoteApi;
+    /** The plugin's translator. */
+    t: Translate;
+    /** The official labels of the form's provider-id field, by locale. */
+    routeIdLabels: () => readonly string[];
+    /** The session's deferred-header ledger. */
+    staged: StagedHeadersState;
+}
+/** One create card's pane: its bar, and the headers pane once there is a route. */
+export declare function CreateCardPane({ host, api, t, routeIdLabels, staged }: CreateCardPaneProps): ReactNode;

package/lib/client/injection/editor-tabs.d.ts

@@ -75,6 +75,23 @@ export declare function createEditorTabsState(): EditorTabsState;
  * other.
  */
 export declare function editorCardOf(element: Element | null): HTMLElement | null;
+/**
+ * The part of a card that presents its editor.
+ *
+ * A provider ROW has one editor and this returns the card itself. The
+ * create-provider card has TWO form halves — the built-in catalogue and the
+ * custom API declaration — and the official page mounts each once it is visited
+ * and hides the inactive one with `hidden`. Every lookup below is scoped to the
+ * visible half, because the hidden one carries a provider-card slot of its own:
+ * the plugin's mount inside it publishes a route, a tab bar and a headers
+ * section, and reading those would dress the visible form with the hidden
+ * form's provider.
+ *
+ * A card with both halves hidden (mid-swap, before React commits the show) and
+ * a card with none are both scoped to the card, which is the rule this module
+ * has always applied to a single-form card.
+ */
+export declare function activeScopeOf(card: HTMLElement): HTMLElement;
 /**
  * Switch one card to a tab. The card attribute is the single source of truth:
  * the stylesheet swaps the pane on the attribute alone, and the bar's buttons

package/lib/client/injection/model-order-drag.d.ts

@@ -79,5 +79,3 @@ export declare function reconcileModelOrder(root: HTMLElement, deps: ModelOrderD
  * persisting that order — on behalf of a fiber that no longer exists.
  */
 export declare function teardownModelOrder(state: ModelOrderState): void;
-/** The stored sequence for one provider, for callers that only need to read it. */
-export declare function storedModelOrder(provider: string): readonly string[];

package/lib/client/injection/models-page-editor.d.ts

@@ -74,6 +74,14 @@ export interface HostLabels {
      * offers this plugin no seat to stamp that name on.
      */
     editProvider: readonly string[];
+    /**
+     * The official input-types control's image choice ("Image" / "图片"). When a
+     * row ships that control, it — not the plugin's ledger — is what tells the
+     * user (and the official Save) that a model takes images, so the copy is the
+     * anchor that finds the box a verdict belongs in: see
+     * {@link echoOfficialModality}.
+     */
+    inputImage: readonly string[];
 }
 /** The join the injector renders from. */
 export interface InjectorDeps {
@@ -103,6 +111,8 @@ export interface InjectorDeps {
      * editing" is the only moment this side may safely write the document.
      */
     onIdle?(): void;
+    /** Wake the debounced scan after provider-wide adaptation stages a row. */
+    onPendingChanged?(): void;
     /**
      * Arm a timed retry after a failed idle pass. The backoff clock only helps
      * if something wakes the injector when it expires; a settled page has no DOM
@@ -389,6 +399,65 @@ export interface AutofillFootprint {
  * position (the label's trailing number IS the position).
  */
 export declare function inputValueByLabel(card: HTMLElement, labels: readonly string[]): string;
+/**
+ * The official input-types checkbox an image verdict belongs to, or undefined
+ * when this row ships no such control (a legacy kernel) — or ships one whose
+ * boxes cannot be told apart.
+ *
+ * The official fieldset maps its two choices in a fixed order (`["text",
+ * "image"]`) and labels each one, so the image box is the one whose own label
+ * carries the image copy — matched like every other anchor, by copy, with the
+ * second box as the fallback for a host whose copy is in a language neither
+ * this plugin's locale nor its English floor knows: the order still identifies
+ * it.
+ */
+export declare function officialImageCheckboxOf(container: HTMLElement, imageLabels: readonly string[]): HTMLInputElement | undefined;
+/**
+ * Print a verdict about images on the OFFICIAL input-types control, and report
+ * whether that control now owns the row's modality.
+ *
+ * The official checkbox renders the official card's own DRAFT, not the
+ * settings document, so a document write of the plugin's can never tick it
+ * before the card is saved and reopened — the gap the user hit. Clicking the
+ * box is a real user-equivalent edit: the official form holds the tick in its
+ * draft and its own Save is what persists it. That is also why a row reaching
+ * this path must keep the modality OUT of its own write (see
+ * {@link officialModalityIntent}): two writers for one field would let this
+ * plugin's held write land after that Save and revert whatever the user chose
+ * in the meantime.
+ *
+ * A missing box, or a DISABLED one (a read-only card, which will not carry the
+ * click anywhere), reports `false` so the caller keeps its own write — the
+ * only remaining way the verdict can reach the document.
+ */
+export declare function echoOfficialModality(container: HTMLElement, image: boolean, imageLabels: readonly string[]): boolean;
+/**
+ * The modality intent a row's own write may carry, once the official
+ * input-types control has been offered the verdict.
+ *
+ * `undefined` out means the write states nothing about the modality: either it
+ * never carried one, or the official control took the verdict over. A row with
+ * no such control — a legacy kernel, or a row the user has left folded — hands
+ * its intent through unchanged, which keeps the document write as the way the
+ * verdict travels.
+ *
+ * `null` is the plugin's deliberate UNSET, which the official control cannot
+ * express at all (it knows only text and text+image): it passes through
+ * untouched.
+ */
+export declare function officialModalityIntent(container: HTMLElement | undefined, input: InputModalities | null | undefined, imageLabels: readonly string[]): InputModalities | null | undefined;
+/**
+ * One model row a card shows on screen: what the walk needs to name it, plus
+ * the row element itself, so a verdict about its modality can be printed on
+ * the row's own official control (which lives inside the row, collapsed or
+ * not). The element is optional because a caller may know the rows only by
+ * their ids.
+ */
+export interface ScreenModel {
+    readonly id: string;
+    readonly name: string;
+    readonly row?: HTMLElement;
+}
 /**
  * Adapt every model of one provider, the rows the user never unfolded
  * included.
@@ -414,11 +483,91 @@ export declare function inputValueByLabel(card: HTMLElement, labels: readonly st
  * @param state - mutable scan state: the adapting guard and the held ledger.
  * @param deps - the injection dependencies.
  * @param route - the provider route whose models are adapted.
+ * @param state - mutable scan state: the adapting guard and the held ledger.
+ * @param deps - the injection dependencies.
+ * @param route - the provider route whose models are adapted.
+ * @param visibleRows - the models the route's card shows on screen, from the
+ *   scan's own rows (id and display name). The document cannot know the rows
+ *   the card holds but has not saved yet, so the pass extends its walk with
+ *   them: their holds land with the card's own Save, exactly like a row's own
+ *   auto-adapt.
  * @returns what the pass did, so the seat can say something true about the
  *   click: how many models it held an adaptation for, how many had no
  *   suggestion, and -- when nothing could be adapted at all -- why.
  */
-export declare function adaptEveryModel(state: ScanState, deps: InjectorDeps, route: string): Promise<AutoAdaptReport>;
+export declare function adaptEveryModel(state: ScanState, deps: InjectorDeps, route: string, visibleRows?: readonly ScreenModel[]): Promise<AutoAdaptReport>;
+/**
+ * Hand a viewport delta back to whichever container actually moved the card.
+ *
+ * The card's distance from the top of the viewport is the sum of every scroll
+ * offset between it and the document, so the correction belongs to the
+ * container that really moved: usually the nearest scrollable one, but a
+ * deletion near the bottom of a long page moves the PAGE's offset instead. Each
+ * container is asked for as much of the delta as it can still give, the ones
+ * this window has already written first and the rest from the inside out, and
+ * every container that answers is watched from then on. A container whose
+ * offset is no longer the one this loop left is being scrolled by somebody
+ * else, and is skipped rather than fought.
+ */
+export declare function absorbDelta(chain: readonly HTMLElement[], watched: Set<HTMLElement>, lastSet: Map<HTMLElement, number>, delta: number): void;
+/**
+ * Start recording where a click inside a model list leaves its scroll host.
+ *
+ * Document-level and capture-phase, like the stand-down listeners a re-pin
+ * window installs: the position has to be read before the official handler
+ * (and React's commit behind it) can shorten the list. Reference counted, so
+ * a reload that lands a second fiber over a page that already has one does not
+ * take the listeners away from the first.
+ */
+export declare function watchModelListOffsets(): void;
+/**
+ * Stop watching, drop every blank, and forget the last position.
+ *
+ * The blanks are elements this plugin owns inside the official page: a fiber
+ * that goes away must not leave a scroll container holding a gap nothing
+ * maintains. Removing one can move the view (the range it held goes with it),
+ * which is the right thing to do to a page whose watcher is gone.
+ */
+export declare function unwatchModelListOffsets(): void;
+/**
+ * Hold every open provider card's top across a model row burst, and hold the
+ * scroll host's own range open while it does.
+ *
+ * The official list keys rows by array index, so a deletion removes the LAST
+ * element and re-fills the survivors: the card loses a row's height INSIDE
+ * itself, above whatever its tail holds. Left to its anchoring the browser
+ * keeps a node near the hole visually stable instead — it buys the shrink
+ * back by moving the whole view, and deleting a model slides the page DOWN
+ * rather than letting the content below the list contract upward into the
+ * hole it opened. Suppressing anchoring from the burst's own microtask (the
+ * injector runs this before the browser has laid the deletion out) holds the
+ * card's top where it was: the header does not move, and the tail rises.
+ *
+ * Anchoring is only half of it, and the half that shows up when the list is
+ * scrolled near its end. There the shrink also takes the scroll RANGE away,
+ * and the browser clamps the offset down to the new maximum on the first
+ * flush that sees the shorter content — which is this very microtask.
+ * Measured on the live page (list scrolled to its end, eight deletions): every
+ * step moved the card's top by exactly the amount the clamp took, 54px per
+ * row, and no anchor suppression could stop it because nothing was anchoring:
+ * the range was simply gone. {@link holdListSlack} is what gives it back, from
+ * the position the row's own click recorded before the change.
+ *
+ * The window also covers the burst's second height change. The re-filled rows
+ * leave the mounted editor of the model that moved out of them STALE, and the
+ * debounced scan re-renders (or mounts) it a frame or two after the deletion
+ * itself — the same two-stage change {@link pinCardTop} was built for, now
+ * opened by the mutation rather than by a click.
+ *
+ * The card vocabulary is the same three flavours {@link wireEditRepin} knows:
+ * a deletion inside a NEW provider's setup card (or the add card) has no
+ * rowCard to climb into at all, and a pin that names only saved providers
+ * silently skips the very card the user is editing.
+ *
+ * @param root - the panel to search for model lists.
+ * @param windowMs - how long each found card stays pinned.
+ */
+export declare function pinModelListCards(root: HTMLElement, windowMs?: number): void;
 /**
  * Scan the settings DOM for official model rows and reconcile the injected
  * editors. Idempotent: existing editors are left alone, new disclosures get

package/lib/client/injection/provider-disabled-group.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The folded group of switched-off providers on the official Models page.
+ *
+ * A switched-off provider is not deleted: its row is the only place it can be
+ * switched back on, and its configuration is still the user's. It does not
+ * belong in the list the user reads either — a page whose built-in providers all
+ * stay in the way makes the two or three real ones hard to find. So the rows of
+ * the switched-off providers fold away behind one control at the end of the
+ * list, and that control says how many are folded and unfolds them again.
+ *
+ * Unfolding does not scatter them back among the providers that are on: the
+ * folded rows are ORDERED behind the control, so the group reads as one group
+ * under its own control. The order comes from the plugin's stylesheet
+ * (`.bre-row-folded`, `.bre-provider-disabled-seat`), where `!important` outranks
+ * the inline orders the drag passes write — this module therefore never has to
+ * fight them for the attribute, and the rows are never moved or rebuilt: their
+ * DOM slot, which the drag passes read back out of the DOM, stays exactly where
+ * the host put them.
+ *
+ * The only node this module inserts is its own control, as the list's last item:
+ * a control outside the list could not head rows inside it, and the list is a
+ * flex column the host itself lays out. Both the class writes and the insertion
+ * are guarded on the state they would produce: a scan that changes nothing
+ * writes nothing, because every write here would otherwise feed the observer
+ * that scheduled the scan.
+ *
+ * The folded state is per session and deliberately not stored. The point of the
+ * group is that the switched-off providers are out of the way, and a reload
+ * showing them folded again is the behaviour that was asked for.
+ *
+ * @module dsh-model-think-level/client/injection/provider-disabled-group
+ */
+import type { HostLabels } from './models-page-editor.js';
+/** Per-scan bookkeeping (one instance lives in `models-page.ts`). */
+export interface ProviderDisabledGroupState {
+    /** Whether the folded rows are currently unfolded. */
+    expanded: boolean;
+}
+export interface ProviderDisabledGroupDeps {
+    /** The plugin's own translator, for the control's label and tooltip. */
+    t: (key: string, params?: Record<string, string | number>) => string;
+    /** The official `settings.models` label sets, resolved fresh on every scan. */
+    labels: () => HostLabels;
+}
+export declare function createProviderDisabledGroupState(): ProviderDisabledGroupState;
+/**
+ * Fold the switched-off providers away — or put them back when the control says
+ * so — and keep the control's own label, count and position in step.
+ *
+ * Idempotent: a row already folded stays folded, and the control is only ever
+ * written when a value genuinely changed, so a scan never mutates the page on
+ * behalf of a state that is already on it.
+ */
+export declare function reconcileProviderDisabledGroup(root: HTMLElement, deps: ProviderDisabledGroupDeps, state: ProviderDisabledGroupState): void;
+/** Remove the control and unfold every row it hid. */
+export declare function teardownProviderDisabledGroup(): void;

package/lib/client/injection/row-drag.d.ts

@@ -62,6 +62,13 @@ export interface DragSession {
     frame: number | undefined;
     dropped: boolean;
 }
+/** What a list looked like the last time a scan read it. */
+export interface ListSighting {
+    /** The ids in the sequence they screened, in screen order. */
+    readonly ids: readonly string[];
+    /** The row elements that were on screen. */
+    readonly rows: readonly Element[];
+}
 /** Per-scan bookkeeping; one instance per module that owns a list. */
 export interface DragState {
     /** The drag sources already carrying listeners. */
@@ -70,6 +77,16 @@ export interface DragState {
     readonly lists: WeakSet<Element>;
     /** The insertion line; created on the first drag and reused until teardown. */
     line: HTMLElement | undefined;
+    /**
+     * What each list looked like on the last pass, by list element.
+     *
+     * Needed because a removal cannot be told from a rename or an addition by
+     * looking at the current DOM: when the host keys its rows by index, deleting
+     * a model leaves every row below it drawn with the next model, so the rows on
+     * screen are the same elements holding the same `order`s they always had. See
+     * {@link arrangement} for what that does to the screen order.
+     */
+    readonly sighted: WeakMap<Element, ListSighting>;
     drag: DragSession | undefined;
 }
 export declare function createDragState(): DragState;
@@ -78,9 +95,11 @@ export declare function rowElements(parent: HTMLElement): HTMLElement[];
 /** The rows in the sequence they currently screen. */
 export declare function visualRows(list: HTMLElement): HTMLElement[];
 /**
- * Put `sequence` on screen: each row it names takes the slot a named row
- * already held, and a row it does not name keeps the slot it has. Every child
- * gets an explicit `order` once anything moves, so no two rows share a slot.
+ * Put `sequence` on screen against the order the rows currently screen in.
+ *
+ * Only for a gesture in flight: the pointer's arrangement IS the screen order,
+ * so that is the sequence the rows are placed against. Everything outside a
+ * gesture goes through {@link applyIdOrder}, which places against the DOM.
  */
 export declare function placeRows(list: HTMLElement, sequence: readonly HTMLElement[]): void;
 /**
@@ -96,6 +115,14 @@ export declare function orderedIds(list: HTMLElement, idOf: (row: HTMLElement) =
 /**
  * Place the rows in `ids` order. Rows without a known id are left exactly where
  * they are: a row we cannot name is a row we must not move.
+ *
+ * The slots come from the DOM order. React owns the child list and keeps it
+ * compacted and truthful across a removal, while the inline `order`s still on
+ * the survivors describe where those models were before it. Taking the slots
+ * from the DOM and the sequence from {@link arrangement} is what lets the two
+ * meet: the rows land in the order the user had, in the slots the host now
+ * genuinely has, so the gap a deletion left closes instead of leaving a row
+ * behind the end of the list.
  */
 export declare function applyIdOrder(list: HTMLElement, ids: readonly string[], idOf: (row: HTMLElement) => string | undefined): void;
 /** Hand every row back the inline geometry a drag wrote on it. */
@@ -121,6 +148,21 @@ export declare function dropLineTop(row: HTMLElement, after: boolean): number;
 export declare function makeGhost(row: HTMLElement, label?: string): HTMLElement;
 /** The nearest ancestor that actually scrolls, for the edge auto-scroll. */
 export declare function scrollHostOf(node: HTMLElement): HTMLElement | undefined;
+/**
+ * Every container that can hold `node` in place, nearest first.
+ *
+ * {@link scrollHostOf} answers the one container an edge-drag has to drive. A
+ * window that CORRECTS the view needs the rest of the chain as well: the offset
+ * a change takes away is held by whichever ancestor the browser is using as the
+ * scrolling box, and the nearest container is only the innermost candidate for
+ * that — an ancestor the nearest one delegates to can be the one that moved.
+ *
+ * The page's own scroller is the last candidate even though it never declares
+ * an overflow of its own: a long settings page scrolls there when nothing
+ * inside it does, and a row deletion near the bottom of that page takes its
+ * range away exactly like a deletion inside a small panel would.
+ */
+export declare function scrollChainOf(node: HTMLElement): HTMLElement[];
 /** The pixels per frame `host` should scroll while the pointer is at `clientY`. */
 export declare function edgeScrollStep(host: HTMLElement, clientY: number): number;
 /**

package/lib/client/injection/saved-notice.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The official "Saved <provider>." line, taken out of the flow and
+ * answered by a bubble at the top of the window instead.
+ *
+ * The host confirms a save by inserting a paragraph above the provider list
+ * (`ModelsSection`'s `savedNotice`, `role="status"`) that stays there until the
+ * next edit, remove or add clears it. It is feedback, not state — the row it
+ * names is on screen and shows the save itself — but it holds a whole line of
+ * the panel's height the whole time the user works in the card, which is the
+ * "the hint eats space" report. So the line is hidden (never removed: React
+ * owns it, and it must survive the page's own re-renders) and the same words go
+ * up as the plugin's fixed top-centre bubble, which takes itself away after
+ * {@link NOTE_TTL_MS} — the treatment the auto-adapt seat's verdict already
+ * gets, and the one the host's own toast uses.
+ *
+ * The pass owns no wire and no state of its own: it is DOM-only, idempotent and
+ * compare-before-write, so a settled page emits no mutation of its own.
+ *
+ * @module dsh-model-think-level/client/injection/saved-notice
+ */
+/**
+ * Hide every official saved line inside the panel, and put up a bubble for the
+ * one that just appeared.
+ * @param root - the Models panel the passes all decorate.
+ */
+export declare function reconcileSavedNotice(root: HTMLElement): void;
+/** Put every official line back and take the bubble down (plugin dispose). */
+export declare function teardownSavedNotice(): void;