zidane-ui 9.0.4 → 9.1.3

package/src/chat/composer/use-run-meter.ts

@@ -1,140 +0,0 @@
-/**
- * The current run's counters in a component, from the host's `runs`
- * (`createRunMeter` keeps them per session, outside React). The live
- * counters tick about 4 times a second, so each hook reads one field: a
- * reader re-renders only when its field changes, and keeps one subscription.
- */
-import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
-
-import type { ComposerRuns } from '../headless/composer/host-chrome';
-import { EMPTY_RUN_METER, type RunMeterState } from '../headless/composer/run-meter';
-import type { Readable } from '../headless/store';
-import { useComposerHost } from './ComposerHostProvider';
-
-const noSubscribe = () => () => undefined;
-
-/**
- * One field of a session's run counters (`store`: `RunMeter.session(id)`, `null` for none).
- *
- * @param store - The session's counters.
- * @param key - The field to read.
- */
-export function useRunMeterValue<K extends keyof RunMeterState>(
-  store: Readable<RunMeterState> | null,
-  key: K,
-): RunMeterState[K] {
-  const read = () => (store ? store.get() : EMPTY_RUN_METER)[key];
-  // Stable per store: a fresh function each render would unsubscribe and resubscribe on every progress tick.
-  const follow = useCallback((l: () => void) => (store ? store.subscribe(l) : noSubscribe()), [store]);
-  return useSyncExternalStore(follow, read, read);
-}
-
-function useSessionMeter(runs: ComposerRuns | undefined, sessionId: string | null): Readable<RunMeterState> | null {
-  return useMemo(() => (runs && sessionId ? runs.meter(sessionId) : null), [runs, sessionId]);
-}
-
-function useField<K extends keyof RunMeterState>(sessionId: string | null, key: K): RunMeterState[K] {
-  return useRunMeterValue(useSessionMeter(useComposerHost().runs, sessionId), key);
-}
-
-/**
- * The streaming parent turn's live counters, `null` between turns.
- *
- * @param sessionId - The session, `null` for none.
- */
-export const useRunProgress = (sessionId: string | null) => useField(sessionId, 'progress');
-
-/**
- * Output tokens of the run's settled parent turns.
- *
- * @param sessionId - The session, `null` for none.
- */
-export const useRunOutputTokens = (sessionId: string | null) => useField(sessionId, 'outputTokens');
-
-/**
- * Cost of turns settled since the last settling cost read.
- *
- * @param sessionId - The session, `null` for none.
- */
-export const useRunAccruedCost = (sessionId: string | null) => useField(sessionId, 'accruedCost');
-
-/**
- * When the run started (epoch ms), `null` while this window knows of none.
- *
- * @param sessionId - The session, `null` for none.
- */
-export const useRunStartedAt = (sessionId: string | null) => useField(sessionId, 'startedAt');
-
-/**
- * A running session this window did not see start (opened, reloaded or
- * reconnected mid-run): reads its run from the host once (`runs.progress`),
- * so the chip neither restarts its time nor counts its output from zero. A
- * run whose `run:start` it saw counts from the start already.
- *
- * @param sessionId - The session, `null` for none.
- * @param running - Whether it runs now.
- */
-export function useJoinedRunProgress(sessionId: string | null, running: boolean): void {
-  const runs = useComposerHost().runs;
-  const store = useSessionMeter(runs, sessionId);
-  const generation = useRunMeterValue(store, 'generation');
-  const joined = useRunMeterValue(store, 'startedFrom') !== 'host';
-  useEffect(() => {
-    if (!sessionId || !running || !joined || !runs?.progress) return undefined;
-    let cancelled = false;
-    // Best effort: unread, the chip counts from when this window saw the run.
-    runs.progress(sessionId).then(
-      (progress) => {
-        if (!cancelled && progress) runs.noteProgress?.(sessionId, generation, progress);
-      },
-      () => undefined,
-    );
-    return () => {
-      cancelled = true;
-    };
-  }, [runs, sessionId, running, joined, generation]);
-}
-
-/**
- * Whole-second elapsed counter for the session's current run, from its start
- * (the host's, so neither switching conversations nor opening a window
- * restarts it). Ticks every `tickMs`: 250 ms by default so `0s → 1s` is not
- * laggy, but renders once per second.
- *
- * @param sessionId - The session.
- * @param running - Whether it runs now.
- * @param tickMs - How often the clock is read.
- * @param runsOverride - The run counters to read. Default: the host's `runs`.
- */
-export function useRunElapsedSec(
-  sessionId: string,
-  running: boolean,
-  tickMs = 250,
-  runsOverride?: ComposerRuns,
-): number {
-  const hostRuns = useComposerHost().runs;
-  const runs = runsOverride ?? hostRuns;
-  const startedAt = useRunMeterValue(useSessionMeter(runs, sessionId), 'startedAt');
-  const startedAtRef = useRef(startedAt);
-  // eslint-disable-next-line react-hooks/refs -- the interval reads the latest start without restarting
-  startedAtRef.current = startedAt;
-  const [now, setNow] = useState(() => Date.now());
-  useEffect(() => {
-    if (running) runs?.noteSeen?.(sessionId);
-  }, [runs, sessionId, running]);
-  useEffect(() => {
-    if (!running) return undefined;
-    // A tick that lands in the same whole second keeps the old state: the fine
-    // tick is for promptness at the boundary, not a render 4 times a second.
-    const sec = (t: number) => (startedAtRef.current === null ? 0 : Math.floor((t - startedAtRef.current) / 1000));
-    const tick = () => {
-      const t = Date.now();
-      setNow((prev) => (sec(prev) === sec(t) ? prev : t));
-    };
-    // eslint-disable-next-line react-hooks/set-state-in-effect -- the clock starts with the run
-    setNow(Date.now());
-    const id = window.setInterval(tick, tickMs);
-    return () => window.clearInterval(id);
-  }, [running, tickMs]);
-  return running && startedAt !== null ? Math.max(0, Math.floor((now - startedAt) / 1000)) : 0;
-}

package/src/chat/composer/use-send-prompt.ts

@@ -1,188 +0,0 @@
-/**
- * The composer's send and stop, bound to the hosts: the send flow
- * (`sendPrompt`, `zidane-ui/chat/headless`: draft → session, `!` shell, queue
- * while running, `/side`, the provider check, echo and send) over the
- * `ChatHost`, the session host's queue, the composer host's `/` commands, the
- * git host's machine folders and clone on send (`cloneOnServer`: a server
- * draft started from a local project runs in a clone of its repository
- * there), and the prompt history. The app gives what only it holds: how a
- * session is created, the picks a new one starts with, the side panel's
- * hand-over and the provider flag it keeps.
- */
-import { parseCommandInvocation } from 'zidane/chat/pure';
-import { useState, useSyncExternalStore } from 'react';
-
-import { useGitHost } from '../../git/GitProvider';
-import { useSessionHost } from '../../session/SessionProvider';
-import { useChatHost } from '../ChatProvider';
-import {
-  newSessionRequest,
-  sendPrompt,
-  type NewSessionDefaults,
-  type NewSessionRequest,
-  type SendAttachment,
-} from '../headless/send-flow';
-import type { Readable, Writable } from '../headless/store';
-import { useSessionStreamActions } from '../SessionStreamsProvider';
-import { useComposerHost, useComposerLabels } from './ComposerHostProvider';
-import { usePromptHistory } from './PromptHistoryProvider';
-import type { DraftTarget } from './use-draft-target';
-
-/** What {@link useSendPrompt} sends from and through. */
-export interface SendPromptOptions {
-  /** The conversation, `null` for the new-chat draft. */
-  session: { id: string } | null;
-  /** A run is in flight: a prompt is queued. */
-  running: boolean;
-  /** The draft's target (`useDraftTarget`). */
-  draft: DraftTarget;
-  /** The server the composer talks to (`null`: this computer). */
-  hostId: string | null;
-  /** Creates the draft's session. Rejects with why it can't (shown on the draft). */
-  createSession(request: NewSessionRequest): Promise<{ id: string; provisioning?: boolean }>;
-  /** What a new session starts with, read as it is created. */
-  newSessionDefaults(): Omit<NewSessionDefaults, 'untitled'>;
-  /** The draft's session exists: the picks that were for that chat only can reset. */
-  onSessionCreated?(): void;
-  /** Brings what was just sent into view (on the next frame). */
-  reveal?(): void;
-  /** Hands `/side [question]` over; returns why it can't, `null` once handed over. Absent: `/side` is a prompt. */
-  side?(sessionId: string | null, question: string): string | null;
-  /** Whether a provider is ready on this computer (`null`: not known), which a send checks and updates. Absent: never checked. */
-  providerReady?: Writable<boolean | null>;
-}
-
-/** The composer's send and stop. */
-export interface SendPromptControls {
-  /** Sends one prompt; rejects (the composer keeps the text) when it could not go. */
-  send(
-    text: string,
-    attachments: readonly SendAttachment[],
-    activatedSkills?: readonly string[],
-    options?: { keepDraft?: boolean },
-  ): Promise<void>;
-  /** Stops the conversation's run. */
-  stop(): void;
-  /** A send found no provider: the app asks to connect one, until one is ready. */
-  needsProvider: boolean;
-}
-
-const UNKNOWN: Readable<boolean | null> = { get: () => null, subscribe: () => () => {} };
-
-/**
- * Binds the send flow to the hosts and the app's inputs.
- *
- * @param options - See {@link SendPromptOptions}.
- */
-export function useSendPrompt(options: SendPromptOptions): SendPromptControls {
-  const { session, running, draft, hostId, providerReady } = options;
-  const chat = useChatHost();
-  const git = useGitHost();
-  const composer = useComposerHost();
-  const queue = useSessionHost().queue;
-  const history = usePromptHistory();
-  const streams = useSessionStreamActions();
-  const labels = useComposerLabels();
-
-  const provider = providerReady ?? UNKNOWN;
-  const ready = useSyncExternalStore(provider.subscribe, provider.get, provider.get);
-  const [needsProvider, setNeedsProvider] = useState(false);
-  // A provider ready since: the notice goes, while rendering.
-  if (ready && needsProvider) setNeedsProvider(false);
-
-  // On a machine: its folder, or its first one, through the draft's host.
-  const machineRoot = async (machineId: string) => {
-    const listed = await git!.listFolders!({ hostId: draft.machineHost, machineId });
-    if (!listed.ok) throw new Error(listed.error.code === 'failed' ? listed.error.message : listed.error.code);
-    return listed.listing.path;
-  };
-
-  // On a server with no folder picked: the local project's repository, cloned there first. `null`: nothing to clone.
-  const cloneForDraft = async (): Promise<string | null> => {
-    const { server, remoteFolder, remoteClone } = draft;
-    // Nothing to clone: a folder is picked, no local project, or cloning is off (the session starts in the first root).
-    if (!server || remoteFolder !== null || !remoteClone || remoteClone.state === 'off' || !git?.cloneOnServer)
-      return null;
-    draft.setCloning(true);
-    try {
-      const result = await git.cloneOnServer(server.id, remoteClone.input, remoteClone.parent);
-      if (result.ok) return result.path;
-      if ('cancelled' in result) throw new Error(labels.sendCloneCancelled);
-      const reason = result.error.code === 'failed' ? result.error.message : result.error.code;
-      throw new Error(labels.sendCloneFailed(remoteClone.input, reason));
-    } finally {
-      draft.setCloning(false);
-    }
-  };
-
-  const createFromDraft = async (text: string) => {
-    const { machine, machineFolder } = draft;
-    draft.setError(null);
-    try {
-      const onMachine = machine ? (machineFolder ?? (await machineRoot(machine.id))) : null;
-      const cloned = machine ? null : await cloneForDraft();
-      const request = newSessionRequest(
-        cloned ? { ...draft, remoteFolder: cloned } : draft,
-        text,
-        { ...options.newSessionDefaults(), untitled: labels.sendUntitled },
-        onMachine,
-      );
-      const created = await options.createSession(request);
-      options.onSessionCreated?.();
-      return created;
-    } catch (err) {
-      // Not created (its server went offline, …): say why; the composer puts the prompt back.
-      draft.setError(labels.sendCreateFailed((err as Error)?.message ?? String(err)));
-      throw err;
-    }
-  };
-
-  const isCommand = async (cwd: string, text: string) => {
-    const list = composer.completions?.commands;
-    if (!list) return false;
-    const commands = await list({ cwd, hostId }).catch(() => []);
-    return parseCommandInvocation(text, commands) !== null;
-  };
-
-  const send: SendPromptControls['send'] = (text, attachments, activatedSkills = [], opts = {}) => {
-    const cwd = draft.folderPath ?? '';
-    return sendPrompt(
-      {
-        sessionId: session?.id ?? null,
-        text,
-        attachments,
-        activatedSkills,
-        keepDraft: opts.keepDraft,
-        running,
-        cwd,
-        remote: Boolean(hostId || draft.server),
-      },
-      {
-        host: chat,
-        streams,
-        createSession: createFromDraft,
-        ...(queue?.add ? { enqueue: queue.add } : {}),
-        isCommand: (prompt) => isCommand(cwd, prompt),
-        remember: (id, prompt) => history.push(id, prompt),
-        ...(options.reveal ? { reveal: () => requestAnimationFrame(options.reveal!) } : {}),
-        ...(options.side ? { side: options.side } : {}),
-        draftError: (message) => draft.setError(message),
-        ...(providerReady
-          ? {
-              provider: {
-                known: providerReady.get,
-                ready: () => providerReady.set(true),
-                missing: () => setNeedsProvider(true),
-              },
-            }
-          : {}),
-      },
-    );
-  };
-
-  const stop = () => {
-    if (session) chat.interrupt?.(session.id);
-  };
-
-  return { send, stop, needsProvider };
-}

package/src/chat/composer/use-session-meters.ts

@@ -1,109 +0,0 @@
-/**
- * A conversation's meters: its context gauge (`ComposerHost.context.status`),
- * its cost as last read (`context.cost`) and its model, read for the session
- * it shows: keyed by session, so a switch never shows the previous
- * conversation's figures.
- */
-import { useEffect, useMemo, useState } from 'react';
-
-import type { ComposerContextStatus, ComposerCostStatus } from '../headless/composer/host-chrome';
-import { useComposerHost } from './ComposerHostProvider';
-import { useHostResource } from './use-composer-stores';
-
-/** What {@link useSessionMeters} reads of a session. */
-export interface SessionMetersTarget {
-  /** The session. */
-  id: string;
-  /** Its own model pick, if it has one. */
-  modelId?: string;
-  /** That model's provider. */
-  providerKey?: string;
-}
-
-/** A conversation's meters. */
-export interface SessionMeters {
-  /** Its context gauge, `null` while unknown. */
-  contextStatus: ComposerContextStatus | null;
-  /** The cost as last read; the pills add what the run settled and streams since (`ComposerHost.runs`). */
-  fetchedCost: ComposerCostStatus | null;
-  /** The session's model: its own pick, else the one its context status reports. */
-  modelId: string | null;
-}
-
-/**
- * The meters of the session shown.
- *
- * @param session - The session, `null` for a draft.
- * @param running - Whether it runs now (a run boundary reads the cost again).
- */
-export function useSessionMeters(session: SessionMetersTarget | null, running: boolean): SessionMeters {
-  const id = session?.id ?? null;
-  const modelId = session?.modelId ?? null;
-  const providerKey = session?.providerKey ?? null;
-  const contextStatus = useSessionContextStatus(session);
-  const fetchedCost = useFetchedCost(id, running, modelId, providerKey);
-  return { contextStatus, fetchedCost, modelId: modelId ?? contextStatus?.modelId ?? null };
-}
-
-/**
- * The context gauge of a session alone (what the model and effort pickers
- * read): the same keyed read as {@link useSessionMeters}', so one request.
- *
- * @param session - The session, `null` for a draft.
- * @returns Its context status, `null` while unknown.
- */
-export function useSessionContextStatus(session: SessionMetersTarget | null): ComposerContextStatus | null {
-  const context = useComposerHost().context;
-  const id = session?.id ?? null;
-  const modelId = session?.modelId ?? null;
-  const providerKey = session?.providerKey ?? null;
-  const resource = useMemo(
-    () => (id && context?.status ? context.status(id, modelId, providerKey) : null),
-    [context, id, modelId, providerKey],
-  );
-  return useHostResource(resource).data ?? null;
-}
-
-/**
- * The session's cost, read when it opens, when a run starts or ends and when
- * its model changes. The last figure stays up while the next one is read.
- */
-function useFetchedCost(
-  id: string | null,
-  running: boolean,
-  modelId: string | null,
-  providerKey: string | null,
-): ComposerCostStatus | null {
-  const { context, runs } = useComposerHost();
-  const [fetched, setFetched] = useState<{ id: string; cost: ComposerCostStatus | null } | null>(null);
-  useEffect(() => {
-    if (!id || !context?.cost) return undefined;
-    let cancelled = false;
-    /*
-     * Only a read issued while IDLE may zero the accrual: a run's cost is
-     * stamped at its end, so that read contains every turn accrued so far.
-     * One issued at run START (or on a model switch mid-run) does not: a fast
-     * first `turn:end` landing before the round trip would be wiped and the
-     * pill would under-report until run end. And if a new run began while an
-     * idle read was in flight, `run:start` already reset the accrual for it;
-     * resetting again would drop that run's early turns.
-     */
-    const settlesAccrual = !running;
-    const generation = runs ? runs.meter(id).get().generation : 0;
-    context.cost(id).then(
-      (cost) => {
-        if (cancelled) return;
-        setFetched({ id, cost });
-        if (settlesAccrual) runs?.settleCost?.(id, generation);
-      },
-      () => {
-        if (!cancelled) setFetched({ id, cost: null });
-      },
-    );
-    return () => {
-      cancelled = true;
-    };
-  }, [context, runs, id, running, modelId, providerKey]);
-  // Never another session's figure, not even for the frames before this one's arrives.
-  return fetched?.id === id ? fetched.cost : null;
-}

package/src/chat/composer/use-sustained-work.ts

@@ -1,74 +0,0 @@
-/**
- * The running work the composer's Running badge shows. A call shorter than
- * `WORK_SHOW_MS` never shows it (a quick read doesn't flash a badge), and
- * work that ended keeps it for `WORK_HOLD_MS` (back-to-back calls don't
- * open and close the band between them).
- *
- * The wait is measured from the oldest item's own start, so after a reload
- * or a conversation switch work that has been running a while shows at
- * once. Capped at `WORK_SHOW_MS` from now: a server whose clock runs ahead
- * never holds it back longer.
- */
-import { useEffect, useState } from 'react';
-
-import type { RunningWorkItem } from 'zidane/ipc';
-
-/** Work shorter than this never shows. */
-export const WORK_SHOW_MS = 800;
-/** Work that ended keeps showing this long. */
-export const WORK_HOLD_MS = 1500;
-
-const NONE: readonly RunningWorkItem[] = [];
-
-/**
- * How long until `items` should show, in ms: 0 when they already should.
- *
- * @param items - The running work, non-empty.
- * @param now - The current time, epoch ms.
- */
-export function workShowDelay(items: readonly RunningWorkItem[], now: number): number {
-  const oldest = Math.min(...items.map((item) => item.startedAt));
-  return Math.min(WORK_SHOW_MS, Math.max(0, oldest + WORK_SHOW_MS - now));
-}
-
-/**
- * The running work to show for a conversation (see the header).
- *
- * @param sessionId - The conversation.
- * @param items - Its running work now.
- */
-export function useSustainedWork(
-  sessionId: string | null,
-  items: readonly RunningWorkItem[],
-): readonly RunningWorkItem[] {
-  const initial = (): readonly RunningWorkItem[] =>
-    items.length > 0 && workShowDelay(items, Date.now()) === 0 ? items : NONE;
-  const [state, setState] = useState(() => ({ sessionId, shown: initial() }));
-  // Another conversation: its own work, as it stands, never the last one's held list.
-  if (state.sessionId !== sessionId) setState({ sessionId, shown: initial() });
-  const shown = state.sessionId === sessionId ? state.shown : NONE;
-  const showing = shown.length > 0;
-
-  useEffect(() => {
-    if (items.length > 0) {
-      if (showing) {
-        // eslint-disable-next-line react-hooks/set-state-in-effect -- shown work follows the live list at once
-        setState((s) => (s.shown === items ? s : { ...s, shown: items }));
-        return undefined;
-      }
-      const show = () => setState((s) => ({ ...s, shown: items }));
-      const delay = workShowDelay(items, Date.now());
-      if (delay === 0) {
-        show();
-        return undefined;
-      }
-      const timer = setTimeout(show, delay);
-      return () => clearTimeout(timer);
-    }
-    if (!showing) return undefined;
-    const timer = setTimeout(() => setState((s) => ({ ...s, shown: NONE })), WORK_HOLD_MS);
-    return () => clearTimeout(timer);
-  }, [items, showing]);
-
-  return shown;
-}

package/src/chat/composer/useAttachmentIngest.ts

@@ -1,116 +0,0 @@
-/**
- * The composer's staged attachments and the three ways in: paste (files, or
- * a long text folded into a `.txt`), drop, and the file picker. Every file
- * goes through the shared rule (`readAttachment`): images, PDFs and text
- * attach; anything else is refused, each refusal a line in `notices` until
- * dismissed or a few seconds pass. Disabled, every handler is a no-op that
- * lets the event through.
- */
-import { useCallback, useEffect, useRef, useState, type ChangeEvent, type DragEvent } from 'react';
-
-import { useChatLabels } from '../useChatLabels';
-import {
-  attachmentErrorText,
-  type ComposerAttachment,
-  pastedTextFilename,
-  readAttachment,
-  shouldFoldPasteToAttachment,
-} from './attachment-ingest';
-
-/** How long the notices about refused files stay, in milliseconds. */
-export const ATTACHMENT_NOTICE_MS = 8000;
-
-/** The latest notices kept: a large drop of refused files stays readable. */
-const MAX_NOTICES = 3;
-
-/**
- * The notices about files a composer did not attach: `refuse` words what
- * `readAttachment` rejected with; they clear on `dismiss`, or
- * {@link ATTACHMENT_NOTICE_MS} after the latest one.
- */
-export function useAttachmentNotices() {
-  const labels = useChatLabels();
-  const [refused, setRefused] = useState<ReadonlyArray<{ fileName: string; error: unknown }>>([]);
-
-  // A new refusal restarts the clock.
-  useEffect(() => {
-    if (refused.length === 0) return;
-    const timer = setTimeout(() => setRefused([]), ATTACHMENT_NOTICE_MS);
-    return () => clearTimeout(timer);
-  }, [refused]);
-
-  const refuse = useCallback((fileName: string, error: unknown) => {
-    setRefused((list) => [...list, { fileName: fileName || 'file', error }].slice(-MAX_NOTICES));
-  }, []);
-  const dismiss = useCallback(() => setRefused([]), []);
-  // The same file refused twice is one line.
-  const notices = [...new Set(refused.map((r) => attachmentErrorText(r.fileName, r.error, labels)))];
-  return { notices, refuse, dismiss };
-}
-
-/**
- * Manages the composer's staged attachments and the ways in: paste, drop, and the file picker. Images, PDFs and text files attach; anything else is refused with a notice.
- *
- * @param enabled - Turns the handlers on. When false every handler is a no-op that lets the event through.
- * @param initial - Attachments staged on mount, for example a restored draft. Defaults to none.
- */
-export function useAttachmentIngest(enabled: boolean, initial: readonly ComposerAttachment[] = []) {
-  const [attachments, setAttachments] = useState<ComposerAttachment[]>(() => [...initial]);
-  const { notices, refuse, dismiss } = useAttachmentNotices();
-  const [dragging, setDragging] = useState(false);
-  const inputRef = useRef<HTMLInputElement | null>(null);
-
-  const add = useCallback(
-    (files: readonly File[]) => {
-      for (const file of files) {
-        readAttachment(file).then(
-          (att) => setAttachments((list) => [...list, att]),
-          (error: unknown) => refuse(file.name, error),
-        );
-      }
-    },
-    [refuse],
-  );
-
-  return {
-    attachments,
-    notices,
-    dismissNotices: dismiss,
-    dragging,
-    inputRef,
-    remove: (id: string) => setAttachments((list) => list.filter((a) => a.id !== id)),
-    clear: () => setAttachments([]),
-    restore: (list: readonly ComposerAttachment[]) => setAttachments([...list]),
-    /** ProseMirror's paste hook: true when the paste became attachments. */
-    paste(event: ClipboardEvent): boolean {
-      if (!enabled || !event.clipboardData) return false;
-      const files = Array.from(event.clipboardData.files);
-      if (files.length > 0) {
-        add(files);
-        return true;
-      }
-      const text = event.clipboardData.getData('text/plain');
-      if (!text || !shouldFoldPasteToAttachment(text)) return false;
-      add([new File([text], pastedTextFilename(), { type: 'text/plain' })]);
-      return true;
-    },
-    pick(event: ChangeEvent<HTMLInputElement>) {
-      add(Array.from(event.target.files ?? []));
-      event.target.value = '';
-    },
-    dragOver(event: DragEvent) {
-      if (!enabled || !Array.from(event.dataTransfer.types).includes('Files')) return;
-      event.preventDefault();
-      setDragging(true);
-    },
-    dragLeave(event: DragEvent) {
-      if (event.currentTarget === event.target) setDragging(false);
-    },
-    drop(event: DragEvent) {
-      setDragging(false);
-      if (!enabled || event.dataTransfer.files.length === 0) return;
-      event.preventDefault();
-      add(Array.from(event.dataTransfer.files));
-    },
-  };
-}

package/src/chat/composer/useModelListSpy.ts

@@ -1,19 +0,0 @@
-/**
- * The model chain picker's scroll spy: the provider section under the list's
- * top edge is the active one, whatever moved the list (wheel, keyboard, a
- * jump). The list works it out from its own scroll position and the layout
- * (`groupAt`, no DOM reads) and reports it here whenever it changes.
- */
-import { useCallback, useState } from 'react';
-
-export function useModelListSpy() {
-  const [spied, setSpied] = useState<string | null>(null);
-  /**
-   * A pill click names its section outright; a short last section can never
-   * reach the top edge, so the spy would disagree. The pin holds until the
-   * user moves the list themselves (wheel, drag, keyboard).
-   */
-  const [pinned, setPinned] = useState<string | null>(null);
-  const unpin = useCallback(() => setPinned(null), []);
-  return { active: pinned ?? spied, report: setSpied, pin: setPinned, unpin };
-}