@kitn.ai/ui 0.27.0 → 0.29.0

package/src/state/stream.ts

@@ -1,246 +0,0 @@
-// src/state/stream.ts
-import type { ChatMessage, MessagePart, Source } from '../elements/chat-types';
-import type { ToolPart } from '../components/tool-types';
-import type { CardEnvelope } from '../primitives/card-contract';
-import type { AttachmentData } from '../components/attachment-types';
-import { appendReasoningPart, appendTextPart, upsertCardPart, upsertToolPart, type ReasoningOpts } from './parts';
-
-/** The one universal contract: a functional-updater setter (React setState shape). */
-export type SetMessages = (updater: (prev: ChatMessage[]) => ChatMessage[]) => void;
-
-/* --------------------------------------------------------------------------
- * Bag exclusivity: why the mutators below do not just take their payload type.
- *
- * `Source`, `Partial<ToolPart>` and `ReasoningOpts` are WEAK types — not one
- * required field between them — and TypeScript only excess-property-checks
- * OBJECT LITERALS. Hand a mutator a VARIABLE and that check never runs, so any
- * bag sharing a single optional key name flows straight in. `addSource(source:
- * Source)` therefore accepted an `AttachmentData` and a `CardEnvelope`, and
- * `addFile(a) { inner.addSource(a); }` compiled clean at exit 0 while writing a
- * file payload into a `source` part. Nine such pairs existed across these three
- * bags and not one of them was a type error; `./stream-types.test.ts` pins all
- * nine, and fails with nine "Unused '@ts-expect-error'" if this guard is lifted.
- *
- * Tightening the PAYLOAD types is not available. A citation with no url and no
- * title is a rendered, tested state (`citationTitle` in components/message.tsx
- * falls through title -> url -> a generic word, and message.stories.tsx ships
- * "a citation with no url at all"), and a patch/opts bag is optional by
- * definition. So the exclusivity lives on the PARAMETER instead, which leaves
- * every published data type — and every artifact generated from them — alone.
- *
- * The forbidden key set is DERIVED from the `MessagePart` union, the same
- * derivation `verify:scaffold` and `lint:silent-drops` read, so a seventh
- * variant re-fires this on its own rather than quietly widening the hole.
- *
- * THE BOUNDARY — three things this deliberately does NOT cover. Each is a
- * decision with a reason, not an unfinished edge; they are collected here so
- * the whole boundary reads in one place instead of being met one at a time.
- *
- * 1. A KEY NO SIBLING BAG OWNS still passes. `Unmixed` is a denylist over the
- *    sibling vocabulary, not an exact type, so a consumer's own superset of a
- *    citation — `{ url, title, relevance }` — keeps compiling. Full exactness
- *    would catch marginally more and push real callers toward a cast, and a
- *    cast to `Source` from an attachment is the original bug. A guard people
- *    route around is worse than a narrower guard they keep.
- *
- * 2. `addCard` / `addFile` ARE NOT WRAPPED. Both take STRONG types —
- *    `CardEnvelope` requires type+id+data, `AttachmentData` requires id+type —
- *    so ordinary assignability already does what `Unmixed` exists to do for a
- *    weak bag. Measured, not assumed: wrapping `addCard` buys ZERO (no sibling
- *    bag is assignable to `CardEnvelope`, because nothing else carries `data`).
- *    Wrapping `addFile` buys exactly one pair — `addFile(c)` with
- *    `c: CardEnvelope<'file', unknown>` — and costs two ordinary consumer
- *    shapes, since the derived denylist owns `state` and `index`:
- *
- *        { id, type: 'file', filename, state: 'uploading' }  // upload progress
- *        { id, type: 'file', filename, index: 3 }            // display position
- *
- *    That one pair needs a hand-written generic narrowing with no other
- *    purpose; an ordinarily-inferred `CardEnvelope` is ALREADY rejected.
- *    Rejecting likely code to block contrived code is the wrong trade — the
- *    same trade point 1 refused. Both facts this rests on are pinned in
- *    ./stream-types.test.ts, so it re-opens if either stops holding.
- *
- * 3. A HAND-BUILT PART BYPASSES ALL OF IT. `parts.push({ type: 'source',
- *    source: attachmentVariable })` compiles, because these mutators are not
- *    in the path. Closing it means intersecting the guard into `MessagePart`
- *    itself — and `docs/web-components.md` and `llms-full.txt` inline that
- *    union's fully-expanded structural text, so dozens of consumer-facing
- *    prop-table rows would grow `type?: undefined; state?: undefined;
- *    data?: undefined`. That cost lands on every consumer reading the docs
- *    while the benefit reaches only someone who has already stepped around
- *    the provided API. The mutators are the supported path; they are guarded.
- *    This is where the supported path ends, not a gap in it.
- * ------------------------------------------------------------------------ */
-
-/** Every OBJECT payload a `MessagePart` variant carries. `type`/`raw` are the
- *  variant's own bookkeeping, not payload; the primitive payloads (`text`,
- *  `label`, `index`, ...) drop out at `Extract<..., object>`. */
-type PartPayload = Extract<
-  MessagePart extends infer P ? (P extends object ? P[Exclude<keyof P, 'type' | 'raw'>] : never) : never,
-  object
->;
-
-/** Every bag one of these mutators takes: the part payloads plus the options
- *  bags that are not payloads themselves. */
-type MutatorBag = PartPayload | ReasoningOpts;
-
-/** `keyof` over a union member-by-member. The bare `keyof (A | B)` is the
- *  INTERSECTION of their keys, which is the opposite of what this needs. */
-type KeysOf<T> = T extends unknown ? keyof T : never;
-
-/** `Shape`, but any key that belongs exclusively to a SIBLING bag is a compile
- *  error. Keys `Shape` never heard of are untouched, so a consumer's own
- *  superset of a citation still passes — only the mix-ups fail. That is a
- *  denylist, not an exact type, and deliberately so: boundary point 1. */
-type Unmixed<Shape> = Shape & { [K in Exclude<KeysOf<MutatorBag>, keyof Shape>]?: never };
-
-function newId(): string {
-  if (typeof crypto !== 'undefined' && crypto.randomUUID) return crypto.randomUUID();
-  return 'kai-' + Math.random().toString(36).slice(2);
-}
-
-/** A fluent builder for one in-flight assistant message. Owns no state. */
-export interface AssistantStream {
-  readonly id: string;
-  appendText(delta: string): AssistantStream;
-  appendReasoning(delta: string, opts?: Unmixed<ReasoningOpts>): AssistantStream;
-  upsertTool(toolCallId: string, patch: Unmixed<Partial<ToolPart>>): AssistantStream;
-  /** Adds a card, or REPLACES the existing one with the same `envelope.id`. A
-   *  model that revises a card mid-turn re-sends the whole envelope, so a second
-   *  call with a known id revises that card in place rather than rendering a
-   *  second copy of it. See `upsertCardPart`. */
-  addCard(envelope: CardEnvelope): AssistantStream;
-  addSource(source: Unmixed<Source>): AssistantStream;
-  /* Unwrapped on purpose — these two take STRONG types, so ordinary
-   * assignability already holds. Measurements and the trade: boundary point 2. */
-  addFile(attachment: AttachmentData): AssistantStream;
-  done(): void;
-  /** Settles the turn as FAILED and puts `reason` where the reader can find it.
-   *
-   *  WHERE THE REASON LANDS, in order:
-   *  1. every tool part that has NOT produced a result flips to `output-error`
-   *     with `errorText: reason`, so no panel spins forever. A tool ALREADY in
-   *     `output-error` with its own non-empty `errorText` is left exactly as it
-   *     is: "search index offline" is the answer to what went wrong and
-   *     "Connection lost." is the generic outer symptom, so overwriting the
-   *     specific with the generic loses the only actionable thing on the
-   *     message. It still counts as carrying the failure. A tool in
-   *     `output-error` with NO text does get filled in — an error panel with
-   *     nothing in it says no more than a blank bubble does.
-   *  2. if no part was able to carry it, the reason is APPENDED as its own text
-   *     part.
-   *
-   *  Never both — a turn does not report the same failure twice.
-   *
-   *  "Where the reader can FIND it" is deliberate, and rule 1 and rule 2 are not
-   *  equally loud. Rule 2 is text in the thread: read without any interaction.
-   *  Rule 1 is a tool panel, which renders COLLAPSED — the header shows an error
-   *  icon and a badge, so the failure is unmissable, but the `errorText` itself
-   *  is one click away. That is the right default for a failed tool inside an
-   *  otherwise readable answer, and it is why rule 2 exists rather than always
-   *  stamping the panel and calling it reported.
-   *
-   *  Rule 2 is the whole point and it used to be missing. `abort` only ever did
-   *  rule 1, so a TEXT-ONLY turn — every turn of a text-only support widget —
-   *  had nothing to stamp: the string was discarded and a failed request
-   *  rendered an EMPTY assistant bubble, while the consumer that passed a
-   *  perfectly good sentence believed it had reported the failure. That is the
-   *  repo's "decide loudly" rule broken on the one path where being quiet is
-   *  worst, and it shipped because the discard is invisible from the call site.
-   *
-   *  It is a NEW part, never a merge onto the trailing text: gluing "Connection
-   *  lost." onto the model's half-finished sentence reads as the model saying
-   *  it. Text that already streamed stays exactly where it is.
-   *
-   *  The reason is TRIMMED, and `abort()` with no reason — or one that is empty
-   *  or all whitespace — appends nothing: there is no reason to discard, and the
-   *  kit will not invent copy the consumer did not write. Rule 1 still runs,
-   *  with `errorText: undefined`. Whitespace is not a pedantic case here: the
-   *  scaffold hands over `err.message`, and an `Error` is free to carry `''`,
-   *  which would otherwise render an INVISIBLE text part — a blank bubble that
-   *  also claims to have said something.
-   *
-   *  Settled is settled: after `done()` or a first `abort()`, this is a no-op
-   *  like every other mutator, so the reason cannot be appended twice.
-   *
-   *  The reason is CONSUMER-facing text and is rendered as markdown like any
-   *  other text part. Pass a sentence a visitor can read, not a stack trace. */
-  abort(reason?: string): void;
-}
-
-/** Start an assistant message and drive it through `set`. New refs on every mutation. */
-export function createAssistantStream(
-  set: SetMessages,
-  init: Partial<ChatMessage> = {},
-): AssistantStream {
-  const id = init.id ?? newId();
-  let settled = false;
-
-  set((prev) => [...prev, { id, role: 'assistant', parts: [], ...init }]);
-
-  const mutate = (fn: (parts: MessagePart[]) => MessagePart[]) => {
-    if (settled) return;
-    set((prev) => {
-      const i = prev.findIndex((m) => m.id === id);
-      if (i < 0) return prev;
-      const next = fn(prev[i].parts);
-      if (next === prev[i].parts) return prev;
-      return [...prev.slice(0, i), { ...prev[i], parts: next }, ...prev.slice(i + 1)];
-    });
-  };
-
-  const stream: AssistantStream = {
-    id,
-    appendText(delta) { mutate((p) => appendTextPart(p, delta)); return stream; },
-    appendReasoning(delta, opts) { mutate((p) => appendReasoningPart(p, delta, opts)); return stream; },
-    upsertTool(toolCallId, patch) { mutate((p) => upsertToolPart(p, toolCallId, patch)); return stream; },
-    // Upsert, not append: keyed on envelope.id so a revised card replaces itself.
-    addCard(envelope) { mutate((p) => upsertCardPart(p, envelope)); return stream; },
-    addSource(source) { mutate((p) => [...p, { type: 'source', source }]); return stream; },
-    addFile(attachment) { mutate((p) => [...p, { type: 'file', attachment }]); return stream; },
-    done() { settled = true; },
-    abort(reason) {
-      // Whitespace-only is the same nothing as empty. `err.message` on a thrown
-      // Error is free to be either, and appending it would render an INVISIBLE
-      // text part -- a blank bubble that also claims to have said something.
-      const text = reason?.trim() || undefined;
-      mutate((p) => {
-        let carried = false;
-        const next = p.map((part) => {
-          if (part.type !== 'tool' || part.tool.state === 'output-available') return part;
-          // Already showing its own, more specific failure: keep it, and count
-          // it as carrying. See the note above `abort`.
-          if (part.tool.state === 'output-error' && part.tool.errorText?.trim()) {
-            carried = true;
-            return part;
-          }
-          carried = true;
-          return { ...part, tool: { ...part.tool, state: 'output-error' as const, errorText: text } };
-        });
-        // The reason has to land SOMEWHERE. See the note above `abort`.
-        if (carried || !text) return next;
-        return [...next, { type: 'text', text }];
-      });
-      settled = true;
-    },
-  };
-  return stream;
-}
-
-/** Wrap a stream so `onSettle` fires on done/abort (used to toggle a `loading` flag).
- *  Preserves the fluent chain by returning the wrapper from every mutator. */
-export function onStreamSettled(inner: AssistantStream, onSettle: () => void): AssistantStream {
-  const wrapper: AssistantStream = {
-    id: inner.id,
-    appendText(delta) { inner.appendText(delta); return wrapper; },
-    appendReasoning(delta, opts) { inner.appendReasoning(delta, opts); return wrapper; },
-    upsertTool(toolCallId, patch) { inner.upsertTool(toolCallId, patch); return wrapper; },
-    addCard(envelope) { inner.addCard(envelope); return wrapper; },
-    addSource(source) { inner.addSource(source); return wrapper; },
-    addFile(attachment) { inner.addFile(attachment); return wrapper; },
-    done() { inner.done(); onSettle(); },
-    abort(reason) { inner.abort(reason); onSettle(); },
-  };
-  return wrapper;
-}

package/src/state/suggestions.ts

@@ -1,9 +0,0 @@
-/** Append a suggestion; no-op when already present. Returns a new array. */
-export function addSuggestion(suggestions: string[], s: string): string[] {
-  return suggestions.includes(s) ? suggestions.slice() : [...suggestions, s];
-}
-
-/** Remove a suggestion by value. */
-export function removeSuggestion(suggestions: string[], s: string): string[] {
-  return suggestions.filter((x) => x !== s);
-}

package/src/state/threads.ts

@@ -1,142 +0,0 @@
-// src/state/threads.ts — the thread-switching fold.
-//
-// The identity category from the workspace glue inventory (spec §1/§3b): an
-// id-bound `SetMessages`, per-thread loading state, the abort map, and
-// delete-under-stream safety. Pure folds + callbacks per the state charter —
-// no fetch, no DOM, no storage; the only state a helper here owns is the
-// irreducible kind (which turns are in flight), never the consumer's records.
-import type { ChatMessage } from '../elements/chat-types';
-import type { SetMessages } from './stream';
-
-/** The minimal thread record the fold needs. The consumer's own record type
- *  (title, timestamps, whatever its storage keeps) extends this — those fields
- *  are policy and stay outside the kit. */
-export interface ThreadLike {
-  id: string;
-  messages: ChatMessage[];
-}
-
-/** The functional-updater setter over the whole thread LIST — the same
- *  React-setState shape `SetMessages` is, one level up. */
-export type SetThreads<T extends ThreadLike> = (updater: (prev: T[]) => T[]) => void;
-
-export interface BindThreadOptions<T extends ThreadLike> {
-  /** Stamp the changed record (e.g. `updatedAt`). Runs on a hit only. Kept a
-   *  callback because WHAT gets stamped — and with whose clock — is the
-   *  consumer's record shape, not ours. */
-  touch?: (thread: T) => T;
-  /** A delta arrived for a thread that is no longer in the list (deleted while
-   *  its reply was streaming). The delta is dropped either way — dropping is
-   *  the only correct fold — but the drop is reported, not silent. */
-  onDrop?: (threadId: string) => void;
-}
-
-/**
- * Pure fold: apply `updater` to the messages of thread `id` within a list.
- *
- * reactivity-two-halves (CLAUDE.md): the hit gets a NEW containing array
- * (which notifies) and a NEW record object (which makes the change visible);
- * every other record keeps its reference. A MISS returns `threads` itself —
- * the same reference — so a late delta for a deleted thread re-renders
- * nothing and resurrects nothing.
- */
-export function updateThreadMessages<T extends ThreadLike>(
-  threads: T[],
-  id: string,
-  updater: (prev: ChatMessage[]) => ChatMessage[],
-  opts: BindThreadOptions<T> = {},
-): T[] {
-  let hit = false;
-  const next = threads.map((t) => {
-    if (t.id !== id) return t;
-    hit = true;
-    const updated = { ...t, messages: updater(t.messages) };
-    return opts.touch ? opts.touch(updated) : updated;
-  });
-  if (!hit) {
-    opts.onDrop?.(id);
-    return threads;
-  }
-  return next;
-}
-
-/**
- * A `SetMessages` bound to ONE thread. Capture the id when the user hits send
- * and hand the result to `createAssistantStream`: the reply then lands in the
- * thread that was open at send time, never whichever one is open when the
- * tokens arrive — which is what makes switching away mid-reply (and coming
- * back to a finished answer) safe.
- */
-export function bindThreadMessages<T extends ThreadLike>(
-  setThreads: SetThreads<T>,
-  id: string,
-  opts: BindThreadOptions<T> = {},
-): SetMessages {
-  return (updater) => {
-    setThreads((prev) => updateThreadMessages(prev, id, updater, opts));
-  };
-}
-
-/** The in-flight-turn bookkeeping for a multi-thread app: which threads are
- *  streaming, and the AbortController for each. See `createThreadSessions`. */
-export interface ThreadSessions {
-  /** Register a new in-flight turn. One turn per thread: a prior in-flight
-   *  turn for the SAME thread is aborted first. Pass the returned controller's
-   *  `signal` to your fetch — the fetch line itself stays yours. */
-  begin(threadId: string): AbortController;
-  /** The turn settled (done or failed) — call from your `finally`. `controller`
-   *  is required so a slow old turn's cleanup cannot clear a newer turn that
-   *  has since begun on the same thread: a stale controller is a no-op. */
-  end(threadId: string, controller: AbortController): void;
-  /** Cancel the in-flight turn (the delete-under-stream story): aborts the
-   *  controller and clears the streaming state. Returns whether anything was
-   *  actually in flight. Pair it with the id-bound sink above, which drops any
-   *  deltas that were already past the abort. */
-  abort(threadId: string): boolean;
-  isStreaming(threadId: string): boolean;
-  /** A fresh array snapshot each call — safe to hand straight to a setState. */
-  streamingIds(): string[];
-}
-
-/**
- * Create the session tracker. `onChange` fires with a fresh `streamingIds()`
- * snapshot after every transition — mirror it into your framework's state to
- * derive `loading` (`sessions.isStreaming(activeId)` is the per-thread flag a
- * single boolean cannot be, because a stream keeps running when you switch
- * away).
- *
- * This is the one stateful object in the module, because an abort map is
- * irreducibly stateful; it still does no I/O and owns no timer.
- */
-export function createThreadSessions(onChange?: (streamingIds: string[]) => void): ThreadSessions {
-  const inFlight = new Map<string, AbortController>();
-  const snapshot = () => Array.from(inFlight.keys());
-  const notify = () => onChange?.(snapshot());
-
-  return {
-    begin(threadId) {
-      inFlight.get(threadId)?.abort();
-      const controller = new AbortController();
-      inFlight.set(threadId, controller);
-      notify();
-      return controller;
-    },
-    end(threadId, controller) {
-      if (inFlight.get(threadId) !== controller) return;
-      inFlight.delete(threadId);
-      notify();
-    },
-    abort(threadId) {
-      const controller = inFlight.get(threadId);
-      if (!controller) return false;
-      controller.abort();
-      inFlight.delete(threadId);
-      notify();
-      return true;
-    },
-    isStreaming(threadId) {
-      return inFlight.has(threadId);
-    },
-    streamingIds: snapshot,
-  };
-}

package/src/test-utils/fake-clock.ts

@@ -1,88 +0,0 @@
-import { vi, beforeEach, afterEach } from 'vitest';
-
-/**
- * Shared fake `requestAnimationFrame` + `performance.now()` clock for tests
- * that need to drive time deterministically instead of racing real timers.
- *
- * requestAnimationFrame's timestamp and performance.now() share a time origin
- * per spec, so production code can read either. Stubbing them off the same
- * fake `now` keeps the two from silently disagreeing.
- *
- * The stub holds a REAL per-registration queue, matching a real browser: a
- * single frame fires every callback that was pending BEFORE that frame, all
- * with the SAME advanced `now`, in registration order -- so two
- * independently-animating things under test (e.g. a `createTween`'s own step
- * loop and `ShaderCanvas`'s separate `draw` loop, both requestAnimationFrame
- * consumers, both mounted at once) tick together on one `advance()` call
- * instead of the second silently stealing the first's slot.
- *
- * This used to be a single PENDING-callback slot, not a queue: a second
- * consumer scheduling a new frame before `advance()` ran overwrote the
- * first rather than queueing behind it. That was fine for anything that only
- * ever has ONE thing pending at a time (the common case, e.g. bar/grid/radial's
- * single sequencer tick, or a lone `createTween`), which is why switching to a
- * queue does not change any of those. It was NOT fine for a mounted shader
- * variant, where a tween and ShaderCanvas's `draw` are both independently
- * pending at once: `draw` always registers last and re-arms itself every
- * `advance()`, so it permanently "won" the single slot and the tween's step
- * never fired -- silently defeating any test trying to prove something holds
- * while UNIFORM VALUES genuinely change every frame (see
- * `variant-custom.test.tsx`'s recompile-guard test for the concrete case this
- * was fixed for).
- *
- * `cancelAnimationFrame` cancels by id now (each `requestAnimationFrame` call
- * gets its own), not by clearing whatever happens to be in the single slot --
- * required once more than one callback can be pending at a time, so a
- * `cancelAnimationFrame(idA)` cannot accidentally drop a DIFFERENT pending
- * callback `idB`.
- *
- * Call once per `describe` block (or at file scope for the whole file); it
- * registers `beforeEach`/`afterEach` hooks scoped to wherever it is called,
- * exactly like inlining the hooks would, and returns the driver bound to
- * that scope's fake clock.
- */
-export function installFakeClock() {
-  let now = 0;
-  let nextId = 1;
-  let pending = new Map<number, (t: number) => void>();
-
-  beforeEach(() => {
-    now = 0;
-    nextId = 1;
-    pending = new Map();
-    vi.stubGlobal('requestAnimationFrame', (cb: FrameRequestCallback) => {
-      const id = nextId++;
-      pending.set(id, cb as (t: number) => void);
-      return id;
-    });
-    vi.stubGlobal('cancelAnimationFrame', (id: number) => {
-      pending.delete(id);
-    });
-    vi.stubGlobal('performance', { now: () => now });
-  });
-
-  afterEach(() => vi.unstubAllGlobals());
-
-  /**
-   * Advance the fake clock and run every callback pending BEFORE this call,
-   * all at the new `now` -- one simulated frame. A callback that reschedules
-   * itself (the normal RAF-loop pattern) lands in a FRESH pending set for the
-   * NEXT `advance()`, not this one: snapshotting the callback list before
-   * invoking any of them is what keeps a self-rescheduling loop from looping
-   * forever inside a single `advance()` call, matching how a real browser
-   * frame never re-enters itself either.
-   */
-  function advance(ms: number) {
-    now += ms;
-    const callbacks = Array.from(pending.values());
-    pending = new Map();
-    for (const cb of callbacks) cb(now);
-  }
-
-  /** Whether at least one requestAnimationFrame callback is currently pending. */
-  function isFramePending(): boolean {
-    return pending.size > 0;
-  }
-
-  return { advance, isFramePending };
-}

package/src/types.ts

@@ -1,53 +0,0 @@
-// Types the chat kit components reference. Extracted from the kit's origin
-// project (@tab-zen/shared) so the kit is self-contained. Only the types the
-// components actually import are kept; the RAG/document/adapter types are dropped.
-
-export interface ModelOption {
-  id: string;
-  name: string;
-  provider?: string;
-  /** A short subtitle shown under the name (e.g. "Flagship model"). Takes
-   *  precedence over `provider` for the row subtitle when both are set. */
-  description?: string;
-  /** Optional group name. Models sharing a `group` are collected under a
-   *  collapsible section (e.g. "Legacy models"); ungrouped models list first. */
-  group?: string;
-}
-
-export interface SearchFilters {
-  tags?: string[];
-  authors?: string[];
-  contentType?: 'transcript' | 'markdown';
-  dateRange?: { from: string; to: string };
-}
-
-export interface ConversationScope {
-  type: 'document' | 'collection';
-  documentId?: string;
-  filters?: SearchFilters;
-}
-
-export interface ConversationSummary {
-  id: string;
-  title: string;
-  groupId?: string;
-  /** Only meaningful to scope-aware consumers; the list never reads it. */
-  scope?: ConversationScope;
-  messageCount: number;
-  /** Fallback for the auto relative time when updatedAt is absent. */
-  lastMessageAt?: string;
-  updatedAt: string;
-  /** Right-aligned trailing text on the row — a count, status, or "days ago".
-   *  When omitted, a short relative time is auto-derived from `updatedAt`
-   *  (fallback `lastMessageAt`). */
-  trailing?: string;
-}
-
-export interface ConversationGroup {
-  id: string;
-  userId?: string;
-  teamId?: string;
-  name: string;
-  sortOrder: number;
-  createdAt: string;
-}

package/src/ui/action-icons.ts

@@ -1,53 +0,0 @@
-import type { Component } from 'solid-js';
-import {
-  Copy, ThumbsUp, ThumbsDown, RefreshCw, Pencil,
-  Share, Bookmark, Download, Link, Trash2, Check, X, Star, Flag, Reply, MoreHorizontal, Volume2,
-} from 'lucide-solid';
-import type { ChatMessageAction } from '../elements/chat-types';
-
-type IconComponent = Component<{ class?: string }>;
-
-/**
- * Curated `name → lucide-solid Component` registry for message action buttons.
- *
- * Fixed allow-list — NO arbitrary SVG/URL. Covers the five built-in action
- * icons plus the common custom ones a host is likely to want. Reused across
- * `kai-message`/`kai-chat` (and, later, kai-checkpoint/kai-empty).
- */
-const ICONS: Record<string, IconComponent> = {
-  // built-in action icons
-  copy: Copy,
-  like: ThumbsUp,
-  dislike: ThumbsDown,
-  regenerate: RefreshCw,
-  edit: Pencil,
-  // common custom icons
-  share: Share,
-  bookmark: Bookmark,
-  download: Download,
-  link: Link,
-  trash: Trash2,
-  check: Check,
-  x: X,
-  star: Star,
-  flag: Flag,
-  reply: Reply,
-  more: MoreHorizontal,
-  'volume-2': Volume2,
-};
-
-/** Resolve a curated icon name to its component, or `undefined` when unknown
- *  (the caller then renders a label-only button). */
-export function actionIcon(name?: string): IconComponent | undefined {
-  if (!name) return undefined;
-  return ICONS[name];
-}
-
-/** Default labels for the built-in actions (also used as the `aria-label`). */
-export const BUILTIN_ACTION_LABEL: Record<ChatMessageAction, string> = {
-  copy: 'Copy',
-  like: 'Like',
-  dislike: 'Dislike',
-  regenerate: 'Regenerate',
-  edit: 'Edit',
-};