@genesislcap/ai-assistant 15.23.3 → 15.24.0

package/dist/dts/main/budget-controller.d.ts

@@ -0,0 +1,368 @@
+import { type AIProviderRegistry, type AIProviderRegistryStatusEntry, type AIProviderType, type ChatConfig, type ChatDriverResult, type TurnFailureReason } from '@genesislcap/foundation-ai';
+import type { VendorBudgetFigures } from '../state/ai-assistant-slice';
+import type { SessionStoreReturn } from '../state/session-store';
+import type { SettingsBudgetRow } from './main.types';
+/**
+ * Banner copy built from the figures a 402 actually reported, or `undefined`
+ * when the proxy sent none.
+ *
+ * `undefined` is the meaningful return, not a fallback: paired with the
+ * slice's "a re-latch without a reason keeps the existing explanation" rule, it
+ * makes a figureless driver latch leave a host-supplied reason intact rather
+ * than blanking it back to the default at the exact moment the wall is hit.
+ *
+ * Exported for the unit test that pins the formatting; not part of the element
+ * API.
+ *
+ * @internal
+ */
+export declare function formatBlockedReason(budget?: Partial<Extract<ChatDriverResult, {
+    reason: 'done';
+}>['budget']>, vendor?: AIProviderType): string | undefined;
+/**
+ * Whole-number percentage of a budget consumed, for the meter (GENC-1464).
+ *
+ * Deliberately unclamped — spend can genuinely overshoot the cap (the last
+ * allowed call may cross it), and the meter's TEXT shows the truth; only the
+ * bar clamps, at the render site. The one special case is a `$0` cap, which the
+ * platform treats as "no spend allowed" (not "unlimited"): it has no headroom
+ * by definition, so the meter reads full rather than dividing by zero.
+ *
+ * Exported for the unit test that pins the arithmetic; not element API.
+ *
+ * @internal
+ */
+export declare function budgetPercentOf(figures: VendorBudgetFigures): number;
+/**
+ * What the controller needs from its host.
+ *
+ * `sessionRef` is a deliberate departure from the other controllers, which take
+ * one value callback per field. The budget surface is a projection of the redux
+ * slice: nine of its members are thin reads of `store.aiAssistant.*` and four are
+ * action dispatches, so threading a callback per field would be ten pieces of
+ * plumbing that still hard-code the slice shape in their signatures — coupling
+ * without isolation. It is also required rather than merely tidier:
+ * {@link BudgetController.latchFrom} writes through a session ref *captured at
+ * call time*, so a teardown race cannot land a wall in a new session's store, and
+ * a value callback cannot express that.
+ */
+export interface BudgetDeps {
+    /** The live session store. Observable on the element, so reads here stay tracked. */
+    sessionRef: () => SessionStoreReturn | undefined;
+    providerStatuses: () => AIProviderRegistryStatusEntry[];
+    /** Needed to tell a chat-capable provider from a status-only one — see `reachableVendors`. */
+    providerRegistry: () => AIProviderRegistry | undefined;
+    /** For `ui.showBudgetUsage` only. */
+    chatConfig: () => ChatConfig;
+}
+/**
+ * The AI-spend budget: which vendors are walled, whether that locks the composer,
+ * the banner copy that explains it, and the settings-modal meter (GENC-1464).
+ *
+ * Two invariants run through the whole file:
+ *
+ * - **Walls latch; locking derives.** A wall is one-way per vendor and nothing in
+ *   here clears it, because nothing the user can do refills a budget. But
+ *   {@link BudgetController.blocked} is *derived* from "is every reachable vendor
+ *   walled", so a host swapping its registry to a vendor with headroom recovers
+ *   the composer without un-latching anything.
+ * - **The banner may only name vendors the user could actually be routed to.**
+ *   Hence {@link BudgetController.relevantBlockedVendors}, and hence the
+ *   provenance mark the sweep writes.
+ *
+ * @internal
+ */
+export declare class BudgetController {
+    private readonly deps;
+    /**
+     * When budget figures last arrived — from the host's
+     * {@link BudgetController.setVendorBudget} or the wall latch's own feed — as
+     * epoch ms; `null` until the first feed.
+     *
+     * ELEMENT state, not slice state, on purpose: the reducer is idempotent by
+     * value (an unchanged re-feed must not re-render the meter rows), but "when
+     * was this fetched" must move on every feed, changed figures or not — a
+     * refresh that confirms the same dollars is still a refresh. Only the
+     * toolbar label observes this, so a stamp re-renders one span, not the rows.
+     */
+    meterLastFedAt: number | null;
+    /**
+     * One warning per element for garbage fed to
+     * {@link BudgetController.setVendorBudget}. Once, not per call, because the
+     * documented feed re-runs after every turn — a host bug would otherwise repeat
+     * the same warning on every send for the life of the page.
+     *
+     * Not observable: nothing renders it.
+     */
+    private warningIssued;
+    constructor(deps: BudgetDeps);
+    private get slice();
+    /**
+     * Whether the assistant is blocked by a backend condition and cannot send.
+     *
+     * Derived, not stored — see the class note. Unknown reachability (statuses not
+     * loaded yet, or providers that report no status) fails SAFE: any wall blocks
+     * everything, and that needs no clause of its own, because `every` on the empty
+     * set is vacuously true.
+     */
+    get blocked(): boolean;
+    set blocked(value: boolean);
+    /**
+     * The distinct vendors the registry can currently reach, from the provider
+     * statuses the element loads on connect and refreshes on every
+     * observable-registry change.
+     *
+     * This is the answer to "which vendor would the next turn use" — a question
+     * that has **no** correct answer and deliberately gets no API. The provider is
+     * resolved per turn AND per agent: `activeProviderInput` may be an async
+     * function of the turn's context, an orchestrated turn picks its agent with an
+     * LLM `classify()` call, and sub-agents resolve their own providers. Any
+     * pre-turn "peek" would therefore be a guess that is wrong precisely on the
+     * multi-agent hosts per-vendor budgets exist for.
+     *
+     * Asking instead which vendors are REACHABLE is answerable, synchronous, and
+     * free — and it is enough: the composer must stay live while any reachable
+     * vendor has headroom, and must lock when none does. It also makes
+     * vendor-switch recovery a derivation rather than a mutation.
+     */
+    get reachableVendors(): readonly AIProviderType[];
+    /** Vendors currently walled, in the order they were walled. */
+    get blockedVendors(): readonly AIProviderType[];
+    /** Whether this specific vendor's budget is walled, regardless of the others. */
+    isVendorBlocked(vendor: AIProviderType): boolean;
+    /** Whether this vendor's wall came from the sweep alone — see the slice's `sweptVendors`. */
+    private isVendorSwept;
+    /**
+     * Wall (or release) one vendor's budget, optionally with banner copy for it.
+     *
+     * `'none'` is rejected with a warning rather than accepted: it is the "no
+     * provider configured" sentinel, not a vendor. Latching it would put the raw
+     * sentinel in the banner ("none's AI usage limit is reached") and could never be
+     * undone by derivation, because `'none'` never appears in
+     * {@link BudgetController.reachableVendors} — so `blocked` could never become
+     * derivable from it either.
+     */
+    setVendorBlocked(vendor: AIProviderType, blocked: boolean, reason?: string | null): void;
+    private warnOnce;
+    /**
+     * Feed (or clear) one vendor's AI-spend figures for the meter. Returns `false`
+     * — warning once, not per call — for a non-budgeted vendor or a figure that is
+     * not a finite number `>= 0`, and also for "no store yet", which is a lifecycle
+     * window rather than bad input and so is deliberately not warned about.
+     *
+     * The full host-facing contract, including the intended `GET /api/budget` feed,
+     * is on the element's `setVendorBudget`.
+     */
+    setVendorBudget(vendor: string, figures: {
+        budgetUsd: number;
+        spentUsd: number;
+    } | null): boolean;
+    /** "Updated HH:MM:SS" for the meter toolbar, or `undefined` before any feed. */
+    get updatedLabel(): string | undefined;
+    /**
+     * The walled vendors the user can still be routed to — i.e.
+     * {@link BudgetController.blockedVendors} narrowed to the reachable set, which
+     * is the only set the banner may name.
+     *
+     * A wall the registry can no longer reach is not news: it cannot be hit, and
+     * naming it puts a vendor in front of the user that is not theirs. The concrete
+     * failure this exists to stop: a host ships Anthropic-only, Anthropic walls, the
+     * host swaps its registry to Gemini, Gemini walls — and the banner reads "AI
+     * usage limits are reached for Anthropic and Gemini" to a user who has never
+     * had an Anthropic key. The spurious second name also flips the copy onto the
+     * plural branch, so even the closing sentence is wrong.
+     *
+     * When nothing is reachable YET (the statuses are still loading — the exact
+     * window the pre-flight and the cross-tab bus latch into), the fallback keeps
+     * every wall for LOCKING (`blocked` still derives true) but names only the
+     * vendors walled by a REFUSAL, dropping the ones the `otherVendorAvailable`
+     * sweep added. A refusal is a fact about a vendor this user just used; a sweep
+     * entry is the proxy's headroom verdict about a vendor the host may not even
+     * ship — naming it here reproduced the exact failure above from the other
+     * direction ("Gemini's AI usage limit is reached" to an Anthropic-only user),
+     * and flipped the copy onto the plural branch with it. Self-corrects when the
+     * statuses land: from then on reachability, not provenance, decides.
+     */
+    get relevantBlockedVendors(): readonly AIProviderType[];
+    /**
+     * Whether the blocked banner has anything to say — a vendor-agnostic block, or
+     * a partial wall that the NEXT send would actually hit.
+     *
+     * Partial exhaustion is announced only while the ACTIVE vendor (the registry
+     * default the next send resolves to) is among the walled ones. A user who has
+     * switched to a vendor with headroom has already acted on the advice —
+     * keeping the banner up past that point nagged about a vendor they just left
+     * (GENC-1464 tester feedback), while switching BACK to the walled vendor
+     * brings the banner straight back. Two conservative fallbacks keep it
+     * fail-informative: while the statuses are still loading the active vendor is
+     * unknowable, so any reachable-and-walled vendor still announces; and a
+     * vendor-agnostic block announces always, exactly as before.
+     */
+    get bannerVisible(): boolean;
+    /**
+     * Whether a suggestions fetch would hit a wall.
+     *
+     * Unlike a chat turn, this one CAN be resolved exactly: both suggestion paths
+     * go to the registry **default** and never to a per-agent override
+     * (`ChatDriver.getSuggestions` calls `providerRegistry.default()`, and
+     * `OrchestratingDriver.getSuggestions` just delegates to it). So the vendor a
+     * suggestions call would use is knowable, and this is the one place in the
+     * feature where that is true.
+     */
+    get suggestionsBlocked(): boolean;
+    /**
+     * The vendor the NEXT send resolves to — the registry default's provider, as
+     * reported through `providerStatuses`. `undefined` while the statuses are
+     * still loading (or when the default reports the `'none'` sentinel), which
+     * every consumer treats conservatively.
+     */
+    private get activeVendor();
+    /** Host override for the banner copy, or `null` for the element's default. */
+    get blockedReason(): string | null;
+    set blockedReason(value: string | null);
+    /**
+     * Block or unblock the assistant, optionally with custom banner copy.
+     *
+     * Blocking writes the **vendor-agnostic** block — what a host with one budget
+     * pot means — and does not populate {@link BudgetController.blockedVendors}.
+     * Unblocking clears the per-vendor walls as well, so a host asserting "the wall
+     * is gone" after its own pre-flight cannot be silently overruled by a driver
+     * latch it never saw.
+     */
+    setBlocked(blocked: boolean, reason?: string | null): void;
+    /**
+     * Latch the backend block off a turn outcome. The single decision point for
+     * both latch sites (the `tool-loop-end` bus subscription and `send()`'s
+     * return-value check), so the rule cannot diverge between them.
+     *
+     * Idempotent and one-way **per vendor**: it never unblocks, and it never
+     * re-writes an existing wall. That guard is load-bearing, not just an
+     * optimisation — the bus fires from the driver's `finally`, i.e. BEFORE
+     * `sendMessage()` resolves, so a host subscribed to `tool-loop-end` (what the
+     * migration guide's Option C recommends) sets its own detailed reason and the
+     * return-value latch would otherwise land a moment later and blank it.
+     *
+     * The guard being per-vendor rather than global is the whole difference. A
+     * single global "already blocked, do nothing" would swallow a second vendor's
+     * wall entirely.
+     *
+     * **Vendor attribution, in precedence order:**
+     *
+     * 1. `budget.vendorLabel` — stamped by the transport that was actually refused,
+     *    so it is the only source that cannot be a guess. A label the element does
+     *    not recognise leaves it unclaimed by any vendor.
+     * 2. `budget.vendor` — which the driver resolved from the label where it could,
+     *    and otherwise from the proxy's own `vendor` field on the 402. It is
+     *    therefore NOT simply `vendorLabel` normalised, and the two can disagree.
+     * 3. `vendorHint` — the bus detail's top-level vendor, i.e. the driver's
+     *    best guess at the turn's vendor, which may be the previous turn's vendor
+     *    or nothing at all.
+     *
+     * A wall that names no recognised vendor falls back to the vendor-agnostic
+     * block — fail-safe, and identical to the pre-per-vendor behaviour.
+     *
+     * **`otherVendorAvailable: false` is server-known truth and outranks every
+     * local guess.** Only the proxy knows whether anything else has headroom; this
+     * element can only observe which vendors the registry can reach. So when the
+     * proxy says no, every other *budgeted* vendor is walled in the same pass. That
+     * is what makes `blocked` derive true — locking the composer on the first wall
+     * rather than leaving it live against a vendor set the banner would otherwise
+     * have advised switching to.
+     *
+     * The sweep runs over `BUDGETED_VENDORS`, NOT
+     * {@link BudgetController.reachableVendors}: reachability is loaded
+     * asynchronously, so a reachability-scoped sweep dropped the verdict entirely
+     * when the wall beat the statuses home — making it effectively un-latch, since
+     * the single wall derived `blocked` only while nothing was reachable, and the
+     * composer came back to life against a budget the proxy had already said was
+     * gone. Sweeping the metered list instead makes the verdict independent of load
+     * order. Walling a vendor the registry cannot reach costs nothing: `blocked`
+     * only asks whether every REACHABLE vendor is walled, and the banner reads
+     * {@link BudgetController.relevantBlockedVendors}.
+     *
+     * One boundary remains on the sweep: it walls only vendors the proxy meters,
+     * because a vendor it does not meter has no budget there to exhaust, so "no
+     * other vendor has budget" is not a statement about it.
+     *
+     * The sweep runs last but sits OUTSIDE the per-vendor idempotence guard, and
+     * both halves of that matter. Last, so the vendor that actually refused this
+     * turn heads the wall order the multi-vendor banner reads. Outside the guard,
+     * because the verdict can arrive on a LATER 402 for a vendor that is already
+     * walled.
+     *
+     * @param reason - the turn's failure reason; anything but `'budget-exhausted'` is ignored.
+     * @param ref - the session store to write through, captured by the caller so a
+     *   teardown race cannot land the wall in a new session's store.
+     * @param budget - what the 402 reported: figures when the proxy sent any, the
+     *   refusing vendor, and its `otherVendorAvailable` verdict.
+     * @param vendorHint - the `tool-loop-end` detail's top-level vendor, used only
+     *   when the budget payload names none.
+     */
+    latchFrom(reason?: TurnFailureReason, ref?: SessionStoreReturn | undefined, budget?: Extract<ChatDriverResult, {
+        reason: 'done';
+    }>['budget'], vendorHint?: AIProviderType): void;
+    /**
+     * Copy shown in the blocked banner, in ascending specificity:
+     *
+     * 1. the host's `blockedReason` — a whole-banner override, unchanged;
+     * 2. copy composed from the walled vendors (their per-vendor reasons when set,
+     *    else their figures);
+     * 3. the default budget-exhaustion message.
+     *
+     * The action clause is composed HERE, not stored at latch time, because whether
+     * "switch vendor" or "contact your administrator" is honest depends on whether
+     * another reachable vendor still has headroom — which changes when the registry
+     * changes, long after the wall was latched. Telling a user to switch to a vendor
+     * that is also exhausted is worse than saying nothing.
+     *
+     * **Per-vendor copy is composed however many vendors are walled**, which is what
+     * `setVendorBlocked`'s `reason` parameter promises. It used to be honoured only
+     * on the single-vendor branch, so a host that had carefully set copy for each of
+     * its vendors watched all of it vanish the moment a second one walled.
+     */
+    get effectiveBlockedReason(): string;
+    /**
+     * Copy the driver writes into the TRANSCRIPT when a turn hits the budget wall,
+     * or `undefined` to let the driver compose it per wall.
+     *
+     * A set `blockedReason` still wins — a white-labelled host must not read its own
+     * explanation in the banner and shipped copy directly below it.
+     *
+     * `undefined` (the usual case) is NOT the old `DEFAULT_BUDGET_EXHAUSTED_MESSAGE`
+     * fallback: it hands composition to the driver, which builds the bubble from
+     * EACH wall's own 402 — naming the exhausted vendor and advising a switch only
+     * when that refusal's `otherVendorAvailable` positively vouched for headroom
+     * elsewhere. That is immune to the staleness this getter used to guard against
+     * by freezing the copy: construction-time advice could outlive its truth
+     * (`getOrCreateDriver` re-runs on an agents swap and would have baked the
+     * sentence into every later bubble), but per-wall advice is derived from the
+     * refusal it annotates and dies with the turn. Forcing the default here was also
+     * what made the driver's composed bubble unreachable in every real mount — the
+     * banner advised switching while the bubble under it never did (the GENC-1464
+     * tester finding, root cause).
+     */
+    get transcriptMessage(): string | undefined;
+    /**
+     * Built-in per-vendor budget meter (GENC-1464) — the money sibling of the
+     * settings modal's context-usage gate, with the same shape: not configured off,
+     * and there is data to show. "Data" here is "at least one vendor has figures",
+     * so a host that feeds nothing (or only unlimited vendors) gets no meter and no
+     * empty container.
+     *
+     * Answered from the RAW slice state rather than from
+     * {@link BudgetController.settingsRows}, whose `.length` would format every row
+     * (a `formatUsd` pair and a `budgetPercentOf` each) only to ask whether any
+     * exist. This is read several times per render pass — the getter, the section
+     * gate, the template's `when` — so it stays as cheap as the context sibling's
+     * `!= null`.
+     */
+    get settingsUsageVisible(): boolean;
+    /**
+     * The meter's rows — one per vendor that currently has figures, in
+     * `BUDGETED_VENDORS` order (the proxy's own metered list) so the rendering is
+     * stable however the host ordered its feed calls. Pre-formatted; see
+     * {@link SettingsBudgetRow} for why the text is unclamped while the bar is.
+     */
+    get settingsRows(): readonly SettingsBudgetRow[];
+}
+//# sourceMappingURL=budget-controller.d.ts.map

package/dist/dts/main/budget-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget-controller.d.ts","sourceRoot":"","sources":["../../../src/main/budget-controller.ts"],"names":[],"mappings":"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"}

package/dist/dts/main/composer-menu-controller.d.ts

@@ -0,0 +1,113 @@
+import type { MetaEventType } from '../state/debug-event-log';
+/** A read/write pair for one piece of state the controller does not own. */
+export interface Accessor<T> {
+    get(): T;
+    set(value: T): void;
+}
+/** What the controller needs from its host beyond the shadow root. */
+export interface ComposerMenuDeps {
+    agentPickerOpen: Accessor<boolean>;
+    sessionMenuOpen: Accessor<boolean>;
+    /** Return focus here after Escape, rather than to a button that just vanished. */
+    focusInput: () => void;
+    /**
+     * Clear the session menu's two-step confirm prompts. Called on EVERY session-menu
+     * toggle, not just a user click on the ⋮ button — the menu must always reopen
+     * showing the menu rather than a leftover Clear-confirm, and it can be closed
+     * from four paths (the button, Escape, an outside click, opening the agent
+     * picker). Keeping it in the controller is what makes that hold on all four.
+     */
+    resetSessionConfirmations: () => void;
+    logMeta: (type: MetaEventType, detail?: Record<string, unknown>) => void;
+}
+/**
+ * The two composer menus — the agent picker and the session (⋮) menu: their
+ * mutually-exclusive open/close animation, their measured placement above the
+ * button that opened them, and the document-level listeners that dismiss them.
+ *
+ * Owns no observable state: both open flags live on the session store so the
+ * bubble and popout instances stay in sync, and reach this controller as
+ * {@link Accessor}s.
+ *
+ * @internal
+ */
+export declare class ComposerMenuController {
+    /**
+     * Typed `HTMLElement`, not the assistant: this controller needs the shadow root
+     * and nothing else, and the narrower type is what stops it reaching back into
+     * element API and recreating the god object with extra indirection.
+     */
+    private readonly host;
+    private readonly deps;
+    private readonly agentPicker;
+    private readonly sessionMenu;
+    /** Live only while a menu is open — see {@link ComposerMenuController.syncDismissal}. */
+    private dismissPointer?;
+    private dismissKey?;
+    private dismissResize?;
+    constructor(
+    /**
+     * Typed `HTMLElement`, not the assistant: this controller needs the shadow root
+     * and nothing else, and the narrower type is what stops it reaching back into
+     * element API and recreating the god object with extra indirection.
+     */
+    host: HTMLElement, deps: ComposerMenuDeps);
+    toggleAgentPicker(): void;
+    toggleSessionMenu(): void;
+    /** Close whichever menus are open, with their close animation. */
+    closeAll(): void;
+    /**
+     * Close both menus at once, with no close animation and no `panel.toggled`
+     * meta event — for a caller that is about to replace the view the menu sits in
+     * (Compact swaps the transcript for a progress indicator, Clear wipes it).
+     *
+     * Not {@link ComposerMenuController.closeAll}: animating a panel out over 200ms
+     * while the thing behind it is being replaced is the wrong effect, and routing
+     * through the toggles would log a spurious user-initiated panel toggle into the
+     * debug timeline. This matches what the direct flag assignment on the element did
+     * before — including leaving any in-flight close timer alone, which is safe
+     * because the toggle strips `closing` from the node it captured.
+     */
+    closeImmediate(): void;
+    /** Re-place whichever menu is open. Cheap enough to run from a resize. */
+    repositionOpen(): void;
+    /**
+     * Attach or drop the dismissal listeners to match whether a menu is open.
+     * Called from the open/close setters, so the listeners exist only while there is
+     * something to dismiss.
+     */
+    syncDismissal(): void;
+    /**
+     * Finalise in-flight close animations and drop every listener — call from
+     * `disconnectedCallback`.
+     *
+     * **Teardown runs LAST, and the order is load-bearing.** `finalize()` writes the
+     * flag through `setOpen`, which reaches the element setter and therefore
+     * {@link ComposerMenuController.syncDismissal} — so tearing down first let the
+     * sync re-arm the listeners on an element that is going away. Reachable, if
+     * narrowly: a panel's flag stays TRUE for the whole close animation, so
+     * switching from the session menu to the agent picker leaves both flags set for
+     * ~200ms, and a disconnect in that window finalised the closing menu while the
+     * picker was still open — `shouldListen` true, listeners re-attached, nothing
+     * left to remove them (PR #2503 review).
+     */
+    dispose(): void;
+    private teardownDismissal;
+    /**
+     * Places an open composer menu directly above the control that opened it.
+     *
+     * CSS alone cannot: the menu is a child of `.composer` — which is what lets its
+     * width be capped against the composer rather than against a button — while its
+     * anchor is a button several levels down the bar, and no selector can read a
+     * sibling's offset. So the left edge is measured on open and written as a custom
+     * property.
+     *
+     * Clamped to the composer, so a menu opened from a control near the right edge of
+     * a narrow panel slides back inside instead of overhanging. The animation origin
+     * is written separately and keeps pointing at the button's centre even after such
+     * a shift — the menu still grows out of the thing that opened it, which is the
+     * whole point of anchoring it there.
+     */
+    private position;
+}
+//# sourceMappingURL=composer-menu-controller.d.ts.map

package/dist/dts/main/composer-menu-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composer-menu-controller.d.ts","sourceRoot":"","sources":["../../../src/main/composer-menu-controller.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AA4B9D,4EAA4E;AAC5E,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,GAAG,IAAI,CAAC,CAAC;IACT,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CACrB;AAED,sEAAsE;AACtE,MAAM,WAAW,gBAAgB;IAC/B,eAAe,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IACnC,eAAe,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IACnC,kFAAkF;IAClF,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB;;;;;;OAMG;IACH,yBAAyB,EAAE,MAAM,IAAI,CAAC;IACtC,OAAO,EAAE,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;CAC1E;AAED;;;;;;;;;;GAUG;AACH,qBAAa,sBAAsB;IAU/B;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAfvB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsB;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsB;IAElD,yFAAyF;IACzF,OAAO,CAAC,cAAc,CAAC,CAAqB;IAC5C,OAAO,CAAC,UAAU,CAAC,CAA6B;IAChD,OAAO,CAAC,aAAa,CAAC,CAAa;;IAGjC;;;;OAIG;IACc,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,gBAAgB;IAkBzC,iBAAiB,IAAI,IAAI;IAkBzB,iBAAiB,IAAI,IAAI;IAmBzB,kEAAkE;IAClE,QAAQ,IAAI,IAAI;IAKhB;;;;;;;;;;;OAWG;IACH,cAAc,IAAI,IAAI;IAKtB,0EAA0E;IAC1E,cAAc,IAAI,IAAI;IAStB;;;;OAIG;IACH,aAAa,IAAI,IAAI;IA6BrB;;;;;;;;;;;;;OAaG;IACH,OAAO,IAAI,IAAI;IAMf,OAAO,CAAC,iBAAiB;IAezB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,QAAQ;CAgDjB"}

package/dist/dts/main/composer-resize-controller.d.ts

@@ -0,0 +1,80 @@
+/** What the controller needs from its host, as callbacks so it holds no element reference. */
+export interface ComposerResizeDeps {
+    /** `chatConfig.ui.resizableInput !== false` — read live, since a host can flip it. */
+    enabled: () => boolean;
+    /** The composer box, for its measured natural height on the first drag. */
+    inputEl: () => HTMLElement | undefined;
+    /** The message list, whose height is the headroom the composer may claim. */
+    messagesEl: () => HTMLElement | undefined;
+}
+/**
+ * Drag-to-resize for the composer: owns the chosen height and the transient
+ * geometry of one drag gesture.
+ *
+ * @internal
+ */
+export declare class ComposerResizeController {
+    private readonly deps;
+    /**
+     * Explicit composer height in px once the user has dragged; `null` keeps the
+     * default auto-grow behaviour.
+     *
+     * Observable because {@link ComposerResizeController.heightStyle} is bound in
+     * the template — see the sibling scratch fields for why the rest are not.
+     */
+    heightPx: number | null;
+    /**
+     * Pointer Y and height captured at the start of a drag.
+     *
+     * Deliberately NOT observable, and the same goes for the two bounds below.
+     * These are rewritten on every `pointermove`, and no binding reads them, so
+     * marking them would fire a notification per mouse-move for values nothing
+     * displays — while `heightPx`, which does drive the render, fires exactly one.
+     */
+    private startY;
+    private startHeight;
+    /** Natural (un-dragged) height, measured on the first drag — the floor for shrinking. */
+    private naturalHeight;
+    /** Upper bound for the current drag, capped to the headroom above the composer. */
+    private maxHeight;
+    constructor(deps: ComposerResizeDeps);
+    /** Whether the composer shows a drag handle. On by default; hosts opt out via config. */
+    get resizable(): boolean;
+    /**
+     * Inline style for the composer: writes the chosen height into the
+     * `--composer-height` custom property (read by `.chat-input` and its control in
+     * `main.styles.ts`). Empty until the user drags, or when resizing is disabled,
+     * so the CSS default applies.
+     *
+     * `heightPx` is read into a local BEFORE the branch, and that is load-bearing.
+     * Written as `this.resizable && this.heightPx != null ? …`, the `&&`
+     * short-circuits past `heightPx` whenever resizing is off — so on a host that
+     * mounts with `resizableInput: false`, FAST never records a dependency on it.
+     * The template's binding for this getter (`style=${(x) => x.composerHeightStyle}`)
+     * carries no `:`/`&&`/`||`, so FAST classifies it non-volatile and collects
+     * dependencies exactly once per bind; the missing dependency is therefore never
+     * picked up, and a later `resizableInput: true` gives a handle that drags —
+     * `heightPx` updates — while the composer never visibly moves.
+     *
+     * Reading it unconditionally makes the dependency honest and costs nothing.
+     * `@volatile` would also fix it, by re-collecting on every evaluation, but it pays
+     * a full unsubscribe/resubscribe cycle each time to express something that is
+     * simply true: this getter always depends on both.
+     */
+    get heightStyle(): string;
+    /**
+     * Begin a drag. Captures the pointer so move/up keep firing on the handle even
+     * when the cursor leaves its 7px band.
+     */
+    onStart(e: PointerEvent): void;
+    /**
+     * Resize while dragging. Dragging up (clientY decreases) grows the composer; the
+     * result is clamped between the natural height and the available headroom. No-op
+     * unless a drag is active (the handle holds pointer capture), so plain
+     * hover-moves are ignored.
+     */
+    onMove(e: PointerEvent): void;
+    /** End a drag and release the pointer capture. */
+    onEnd(e: PointerEvent): void;
+}
+//# sourceMappingURL=composer-resize-controller.d.ts.map

package/dist/dts/main/composer-resize-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composer-resize-controller.d.ts","sourceRoot":"","sources":["../../../src/main/composer-resize-controller.ts"],"names":[],"mappings":"AAaA,8FAA8F;AAC9F,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,2EAA2E;IAC3E,OAAO,EAAE,MAAM,WAAW,GAAG,SAAS,CAAC;IACvC,6EAA6E;IAC7E,UAAU,EAAE,MAAM,WAAW,GAAG,SAAS,CAAC;CAC3C;AAED;;;;;GAKG;AACH,qBAAa,wBAAwB;IAyBvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAxBjC;;;;;;OAMG;IACS,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAQ;IAE3C;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,WAAW,CAAK;IACxB,yFAAyF;IACzF,OAAO,CAAC,aAAa,CAAK;IAC1B,mFAAmF;IACnF,OAAO,CAAC,SAAS,CAA0B;gBAEd,IAAI,EAAE,kBAAkB;IAErD,yFAAyF;IACzF,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,WAAW,IAAI,MAAM,CAGxB;IAED;;;OAGG;IACH,OAAO,CAAC,CAAC,EAAE,YAAY,GAAG,IAAI;IAoB9B;;;;;OAKG;IACH,MAAM,CAAC,CAAC,EAAE,YAAY,GAAG,IAAI;IAS7B,kDAAkD;IAClD,KAAK,CAAC,CAAC,EAAE,YAAY,GAAG,IAAI;CAI7B"}