dsh-model-think-level 1.0.6 → 1.1.0

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/injection/model-order-drag.d.ts

@@ -47,6 +47,21 @@ export declare function createModelOrderState(): ModelOrderState;
  * `.modelList { display: flex; flex-direction: column; gap: 8px }` lays out.
  */
 export declare function modelListsOf(root: HTMLElement): HTMLElement[];
+/**
+ * Whether a mutation burst added or removed model ROWS.
+ *
+ * The official editor keys its model rows by ARRAY INDEX (`models.map((model,
+ * index) => <ModelRow ... />, index)`), so deleting one model commits as the
+ * LAST row element leaving the list and every row after the deleted one
+ * swapping its contents INSIDE its existing element. Those elements keep the
+ * CSS `order` this module wrote for the model that moved out of them: the
+ * list paints its tail shifted into the wrong slots, and re-sorts itself
+ * when the debounced scan finally corrects the order a frame or more later —
+ * the "delete one model and the whole list flashes" report. The observer
+ * answers that burst with an order pass in its own microtask, before the
+ * first painted frame; the same reasoning that made the tab pass synchronous.
+ */
+export declare function modelListMutation(records: readonly MutationRecord[]): boolean;
 /**
  * One pass over the page: name every model row in every provider editor, mount a
  * grip in its grid, and place the rows in the order the user stored for that
@@ -64,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

@@ -103,6 +103,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
@@ -414,11 +416,94 @@ 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?: ReadonlyArray<{
+    id: string;
+    name: string;
+}>): 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/locales.d.ts

@@ -148,6 +148,9 @@ export declare const en: {
     providerReorderHint: string;
     providerToggleAria: string;
     providerToggleHint: string;
+    providerDisabledGroupShow: string;
+    providerDisabledGroupHide: string;
+    providerDisabledGroupHint: string;
     providerRemoveDisabled: string;
     providerRemoveLocked: string;
     modelReorderAria: string;

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

@@ -54,5 +54,3 @@ export declare function resolveModelOrder(provider: string, ids: readonly string
 export declare function orderModelEntries<T extends {
     readonly id: string;
 }>(entries: readonly T[], preferred: readonly string[]): readonly T[];
-/** Drop everything one provider stored (used when its last model is removed). */
-export declare function clearModelOrder(provider: string): void;