@kitn.ai/ui 0.28.0 → 0.30.0

package/src/primitives/link-preview.ts

@@ -1,87 +0,0 @@
-// src/primitives/link-preview.ts
-// The optional, app-supplied bare-URL → metadata hook for <kai-link-preview>, plus the
-// `link` card's data type. The card stays PURE: it renders from supplied metadata
-// and never touches the network. CORS forbids reading cross-origin HTML in the
-// browser, so there is intentionally NO built-in network implementation here — an
-// app opts in with `configureLinkPreview({ fetchMetadata })` pointing at its OWN
-// backend/proxy. See docs/superpowers/specs/2026-06-13-kc-link-embed-cards-design.md.
-import type { CardEnvelope } from './card-contract';
-
-/** Rich link / Open-Graph preview payload. The card renders from this; it never fetches. */
-export interface LinkPreviewData {
-  /** Canonical destination; opened via the contract `open` verb. */
-  url: string;
-  /** og:title — falls back to the domain. */
-  title?: string;
-  /** og:description — clamped to 3 lines. */
-  description?: string;
-  /** og:image — degrades gracefully when missing/broken. */
-  image?: string;
-  /** Alt for the preview image (defaults to title / decorative). */
-  imageAlt?: string;
-  /** Site favicon. */
-  favicon?: string;
-  /** Display domain; derived from `url` when omitted. */
-  domain?: string;
-  /** og:site_name; preferred over `domain` when present. */
-  siteName?: string;
-}
-
-/** The full envelope an agent/server emits for a link preview card. */
-export type LinkPreviewEnvelope = CardEnvelope<'link', LinkPreviewData>;
-
-/** The `type` discriminator for link preview cards. */
-export const LINK_PREVIEW_TYPE = 'link' as const;
-
-/** App-supplied resolver: a bare URL → (partial) OG metadata. Usually hits YOUR backend. */
-export type LinkMetadataFetcher = (url: string) => Promise<Partial<LinkPreviewData>>;
-
-let fetcher: LinkMetadataFetcher | undefined;
-
-/**
- * App opt-in: supply a function (usually hitting YOUR backend/proxy) that resolves
- * a bare URL to OG metadata. CORS forbids reading cross-origin HTML in the browser,
- * so there is intentionally NO default network implementation.
- */
-export function configureLinkPreview(opts: { fetchMetadata: LinkMetadataFetcher }): void {
-  fetcher = opts.fetchMetadata;
-}
-
-/** True when an app has registered a fetcher (the bare-URL path is available). */
-export function hasLinkPreviewFetcher(): boolean {
-  return fetcher !== undefined;
-}
-
-/**
- * Used by LinkPreview ONLY when the envelope lacks metadata AND a fetcher is set.
- * Returns the merged metadata or throws (card shows its fallback/error state).
- */
-export async function resolveLinkMetadata(url: string): Promise<Partial<LinkPreviewData>> {
-  if (!fetcher) throw new Error('No link-preview fetcher configured');
-  return fetcher(url);
-}
-
-/** Test-only: clear the configured fetcher so tests stay isolated. */
-export function __resetLinkPreviewForTests(): void {
-  fetcher = undefined;
-}
-
-/** Derive a clean display domain from a URL (strips a leading `www.`). `undefined` if unparseable. */
-export function deriveDomain(url: string): string | undefined {
-  try {
-    return new URL(url).hostname.replace(/^www\./, '');
-  } catch {
-    return undefined;
-  }
-}
-
-const RENDERABLE_SCHEMES = ['http:', 'https:'];
-
-/** True when `url` is a syntactically valid http(s) URL (the only renderable link schemes). */
-export function isRenderableLink(url: string): boolean {
-  try {
-    return RENDERABLE_SCHEMES.includes(new URL(url).protocol);
-  } catch {
-    return false;
-  }
-}

package/src/primitives/message-feedback.ts

@@ -1,124 +0,0 @@
-// Message action-row feedback state — copy + like/dislike — owned ABOVE the
-// per-message `<For>` so a streaming re-render (a fresh `messages` array ref per
-// chunk) never wipes the user's optimistic vote or the transient "copied" check.
-//
-// Both facades (`ChatThread` and the `<kai-message>` element) create one of
-// these and route their action-bar clicks through `handleAction`. Keeping the
-// logic here (not inside the un-unit-testable `defineWebComponent` body) makes
-// the toggle/toast/clipboard behavior directly testable.
-
-import { createSignal, onCleanup } from 'solid-js';
-import type { ChatMessage, FeedbackVote } from '../elements/chat-types';
-import { partsToText } from '../state';
-import { toast } from './toast-store';
-
-/** Detail shape emitted by the action row. `state` is present only for the
- *  toggleable feedback votes: `'on'` when a vote is set, `'off'` when cleared.
- *  Copy / regenerate / edit / custom actions omit it. */
-export interface MessageActionDetail {
-  messageId: string;
-  action: string;
-  state?: 'on' | 'off';
-}
-
-export interface MessageFeedbackOptions {
-  /** Emit the `kai-message-action` detail (facade maps this to `dispatch` /
-   *  `onMessageAction`). */
-  emit: (detail: MessageActionDetail) => void;
-  /** How long the copy check stays before auto-clearing. Defaults to 2000ms. */
-  copiedDuration?: number;
-  /** Container the copy/feedback toasts should be scoped to (the chat, by
-   *  default) so they appear in-chat rather than at the page top. */
-  target?: () => HTMLElement | undefined;
-}
-
-export interface MessageFeedback {
-  /** Resolve the active vote for a message: a controlled `m.feedback` wins,
-   *  else the facade's own optimistic map. */
-  resolveFeedback: (m: Pick<ChatMessage, 'id' | 'feedback'>) => FeedbackVote | undefined;
-  /** Whether a message's copy button should currently show its check. */
-  isCopied: (id: string) => boolean;
-  /** Route a clicked action through copy / vote / passthrough handling. */
-  handleAction: (m: Pick<ChatMessage, 'id' | 'parts' | 'feedback'>, action: string) => void;
-}
-
-const DEFAULT_COPIED_DURATION = 2000;
-
-/**
- * Create the action-row feedback controller for one message list (or one
- * standalone message). Owns the optimistic `feedbackMap` + transient
- * `copiedIds`, resolves the controlled-wins vote, and turns clicks into
- * clipboard writes, toasts, and `kai-message-action` emissions.
- */
-export function createMessageFeedback(opts: MessageFeedbackOptions): MessageFeedback {
-  const [feedbackMap, setFeedbackMap] = createSignal<Record<string, FeedbackVote>>({});
-  const [copiedIds, setCopiedIds] = createSignal<Set<string>>(new Set());
-  const copiedDuration = opts.copiedDuration ?? DEFAULT_COPIED_DURATION;
-  const timers = new Map<string, ReturnType<typeof setTimeout>>();
-
-  onCleanup(() => {
-    timers.forEach((t) => clearTimeout(t));
-    timers.clear();
-  });
-
-  const resolveFeedback: MessageFeedback['resolveFeedback'] = (m) =>
-    m.feedback ?? feedbackMap()[m.id];
-
-  const isCopied: MessageFeedback['isCopied'] = (id) => copiedIds().has(id);
-
-  const markCopied = (id: string) => {
-    setCopiedIds((prev) => {
-      const next = new Set(prev);
-      next.add(id);
-      return next;
-    });
-    const existing = timers.get(id);
-    if (existing) clearTimeout(existing);
-    timers.set(id, setTimeout(() => {
-      timers.delete(id);
-      setCopiedIds((prev) => {
-        if (!prev.has(id)) return prev;
-        const next = new Set(prev);
-        next.delete(id);
-        return next;
-      });
-    }, copiedDuration));
-  };
-
-  const setVote = (id: string, vote: FeedbackVote | undefined) => {
-    setFeedbackMap((prev) => {
-      const next = { ...prev };
-      if (vote === undefined) delete next[id];
-      else next[id] = vote;
-      return next;
-    });
-  };
-
-  const handleAction: MessageFeedback['handleAction'] = (m, action) => {
-    if (action === 'copy') {
-      // Clipboard may be unavailable (insecure context / jsdom); fail soft.
-      try { navigator.clipboard?.writeText(partsToText(m.parts)); } catch { /* ignore */ }
-      markCopied(m.id);
-      toast('Copied to clipboard', { target: opts.target?.() });
-      opts.emit({ messageId: m.id, action });
-      return;
-    }
-    if (action === 'like' || action === 'dislike') {
-      const current = resolveFeedback(m);
-      if (current === action) {
-        // Re-tap clears the vote — no toast on un-vote.
-        setVote(m.id, undefined);
-        opts.emit({ messageId: m.id, action, state: 'off' });
-      } else {
-        setVote(m.id, action);
-        toast('Thanks for your feedback', { target: opts.target?.() });
-        opts.emit({ messageId: m.id, action, state: 'on' });
-      }
-      return;
-    }
-    // regenerate / edit / custom — passthrough, no state.
-    opts.emit({ messageId: m.id, action });
-  };
-
-  return { resolveFeedback, isCopied, handleAction };
-}

package/src/primitives/pdf-preview.ts

@@ -1,121 +0,0 @@
-// src/primitives/pdf-preview.ts
-// On-demand PDF renderer built on pdf.js, loaded from a CDN only when a PDF is
-// actually shown — so a component set that never renders a PDF ships and runs with
-// ZERO pdf.js bytes (the ~482 KB gzip library is never fetched). When a PDF does
-// appear, pdf.js is dynamically imported from the pinned CDN build and every page
-// is rendered to a <canvas>. Hosts override the loader (self-host / CSP / pin) or
-// disable inline rendering via configurePdfPreview(). Mirrors highlighter.ts.
-
-/** Minimal shape of the pdf.js module + objects we rely on. */
-export interface PdfViewportLike {
-  width: number;
-  height: number;
-}
-export interface PdfPageLike {
-  getViewport(opts: { scale: number }): PdfViewportLike;
-  render(opts: {
-    canvasContext: CanvasRenderingContext2D | null;
-    viewport: PdfViewportLike;
-  }): { promise: Promise<void> };
-}
-export interface PdfDocumentLike {
-  numPages: number;
-  getPage(n: number): Promise<PdfPageLike>;
-}
-export interface PdfjsLike {
-  getDocument(src: { url: string }): { promise: Promise<PdfDocumentLike> };
-  GlobalWorkerOptions: { workerSrc: string };
-}
-
-export interface PdfPreviewOptions {
-  /** Turn inline PDF rendering on/off globally. When false, always show the card. */
-  enabled?: boolean;
-  /** Override the pdf.js module loader (self-host / CSP / version pin). */
-  load?: () => Promise<PdfjsLike>;
-  /** Worker URL. Default = the matching jsDelivr worker for the pinned version. */
-  workerSrc?: string;
-}
-
-/** Pinned, exact (reproducible) — NOT a range. */
-const PDFJS_VERSION = '6.0.227';
-const CDN = `https://cdn.jsdelivr.net/npm/pdfjs-dist@${PDFJS_VERSION}/build`;
-const DEFAULT_LOAD = (): Promise<PdfjsLike> =>
-  // Template literal + @vite-ignore keeps this a runtime fetch (never bundled).
-  import(/* @vite-ignore */ `${CDN}/pdf.min.mjs`) as Promise<PdfjsLike>;
-const DEFAULT_WORKER_SRC = `${CDN}/pdf.worker.min.mjs`;
-
-let enabled = true;
-let loader: () => Promise<PdfjsLike> = DEFAULT_LOAD;
-let workerSrc = DEFAULT_WORKER_SRC;
-
-export function configurePdfPreview(options: PdfPreviewOptions): void {
-  if (options.enabled !== undefined) enabled = options.enabled;
-  if (options.workerSrc !== undefined) workerSrc = options.workerSrc;
-  if (options.load !== undefined) {
-    loader = options.load;
-    pdfjsPromise = null;
-  }
-}
-
-export function isPdfPreviewEnabled(): boolean {
-  return enabled;
-}
-
-export function __resetPdfPreviewForTests(): void {
-  enabled = true;
-  loader = DEFAULT_LOAD;
-  workerSrc = DEFAULT_WORKER_SRC;
-  pdfjsPromise = null;
-}
-
-let pdfjsPromise: Promise<PdfjsLike> | null = null;
-
-/** Load pdf.js once (singleton); set the worker src. Re-loads if the loader changed. */
-function loadPdfjs(): Promise<PdfjsLike> {
-  if (!pdfjsPromise) {
-    const active = loader;
-    pdfjsPromise = (async () => {
-      const mod = await active();
-      const pdfjs = ((mod as unknown as { default?: PdfjsLike }).default ?? mod) as PdfjsLike;
-      pdfjs.GlobalWorkerOptions.workerSrc = workerSrc;
-      return pdfjs;
-    })();
-  }
-  return pdfjsPromise;
-}
-
-/**
- * Render EVERY page of the PDF at `url` into `container` as stacked <canvas>
- * elements fit to `pxWidth` CSS pixels (rendered at devicePixelRatio for
- * crispness). Clears `container` first. Resolves `{ pages }`. THROWS on
- * load / CORS / parse failure — the caller catches and shows the fallback card.
- */
-export async function renderPdfInto(
-  url: string,
-  container: HTMLElement,
-  pxWidth: number,
-): Promise<{ pages: number }> {
-  const pdfjs = await loadPdfjs();
-  const doc = await pdfjs.getDocument({ url }).promise;
-  container.replaceChildren();
-  const dpr =
-    typeof window !== 'undefined' && window.devicePixelRatio ? window.devicePixelRatio : 1;
-  for (let n = 1; n <= doc.numPages; n++) {
-    const page = await doc.getPage(n);
-    const base = page.getViewport({ scale: 1 });
-    const scale = base.width > 0 ? pxWidth / base.width : 1;
-    const viewport = page.getViewport({ scale: scale * dpr });
-    const canvas = document.createElement('canvas');
-    canvas.width = Math.max(1, Math.floor(viewport.width));
-    canvas.height = Math.max(1, Math.floor(viewport.height));
-    canvas.setAttribute('role', 'img');
-    canvas.setAttribute('aria-label', `Page ${n}`);
-    canvas.style.width = '100%';
-    canvas.style.height = 'auto';
-    canvas.style.display = 'block';
-    const ctx = canvas.getContext('2d');
-    container.appendChild(canvas);
-    await page.render({ canvasContext: ctx, viewport }).promise;
-  }
-  return { pages: doc.numPages };
-}

package/src/primitives/toast-store.ts

@@ -1,338 +0,0 @@
-// Module-level toast store + the imperative `toast()` API.
-//
-// This is the PRIMARY way consumers raise a toast: `toast('Saved')`,
-// `toast.success('Copied')`, `toast.dismiss(id)`. The store is a single
-// reactive list held in a long-lived `createRoot` (so its reactivity survives
-// outside any component), and `ensureMounted()` lazily creates exactly ONE
-// `<kai-toast-region>` on `document.body` the first time a toast is raised,
-// binding the list to its `toasts` property. The region is a real `kai-*`
-// element, so it carries its own shadow root + the shared kit stylesheet — it's
-// viewport-positioned AND fully kit-styled, never a raw div.
-//
-// ADOPTS, else creates: `ensureMounted` first
-// looks for a connected `<kai-toast-region>` already in the document and binds
-// the store to it, so an app that placed its own region and also calls
-// `toast()` gets ONE region, not two overlapping ones. It creates a region only
-// when none exists. With two or more candidate regions the choice is genuinely
-// ambiguous — the first in document order wins, and a one-time console.warn
-// says so (decide loudly).
-//
-// SSR-safe: every DOM touch is guarded by `typeof document`. On the server,
-// raising a toast is an inert no-op (the store updates, nothing mounts).
-
-import { createRoot, createSignal } from 'solid-js';
-import { createStore, produce } from 'solid-js/store';
-import type { ToastPosition } from '../components/toast';
-
-export type ToastVariant = 'neutral' | 'success' | 'warning' | 'error' | 'info';
-/** Visual treatment: `'pill'` (default, compact single-line) or `'card'` (richer
- *  rounded card with an optional description line). */
-export type ToastAppearance = 'pill' | 'card';
-
-export interface ToastConfig {
-  stack?: 'expanded' | 'collapsed';
-  position?: ToastPosition;
-  max?: number;
-  /** Default appearance for imperatively-raised toasts. Defaults to `'pill'`. */
-  appearance?: ToastAppearance;
-  /** Default high-contrast inverse treatment for imperatively-raised toasts.
-   *  Defaults to `false`. */
-  inverse?: boolean;
-}
-
-// Module-level config the imperative singleton regions inherit. Defaults match
-// the element's own defaults, so an un-configured app behaves exactly as before.
-let toastConfig: ToastConfig = {};
-
-/** Apply the current config to a region element (attributes for scalars). */
-function applyConfig(el: HTMLElement): void {
-  if (toastConfig.stack) el.setAttribute('stack', toastConfig.stack);
-  if (toastConfig.position) el.setAttribute('position', toastConfig.position);
-  if (toastConfig.max !== undefined) el.setAttribute('max', String(toastConfig.max));
-  if (toastConfig.appearance) el.setAttribute('appearance', toastConfig.appearance);
-  if (toastConfig.inverse !== undefined) {
-    if (toastConfig.inverse) el.setAttribute('inverse', '');
-    else el.removeAttribute('inverse');
-  }
-}
-
-/**
- * Configure the imperative `toast()` singleton — call once at app start.
- * `toast.success('…')` has no element to set a prop on, so this is how you opt
- * the auto-mounted region into collapsed stacking / a position / a max. Updates
- * any already-mounted regions too, so call order doesn't matter.
- */
-export function configureToasts(config: ToastConfig): void {
-  toastConfig = { ...toastConfig, ...config };
-  if (typeof document === 'undefined') return;
-  document.querySelectorAll('kai-toast-region').forEach((el) => applyConfig(el as HTMLElement));
-}
-
-/** An action button rendered inside the toast. Returning `false` from
- *  `onAction` keeps the toast open (e.g. to show a follow-up); any other
- *  return value dismisses it. */
-export interface ToastAction {
-  label: string;
-  onAction: () => void | false;
-}
-
-export interface ToastItem {
-  id: string;
-  message: string;
-  variant?: ToastVariant;
-  /** Visual treatment: `'pill'` (default, compact single-line) or `'card'` (richer
-   *  rounded card with an optional description line). */
-  appearance?: ToastAppearance;
-  /** High-contrast inverse surface — works on either appearance, popping in light
-   *  AND dark. Defaults to `false`. */
-  inverse?: boolean;
-  /** Secondary line shown below the message in the `'card'` appearance. The
-   *  `'pill'` appearance ignores it. */
-  description?: string;
-  action?: ToastAction;
-  /** Auto-dismiss delay in ms. `0` = sticky (never auto-dismisses). When an
-   *  `action` is present the effective floor is 4000ms so it stays long enough
-   *  to act on. Defaults to 2000ms. */
-  duration?: number;
-  /** Whether the × close affordance is shown. Defaults to `true`. */
-  dismissible?: boolean;
-  /** Container to scope this toast WITHIN — it floats anchored to that element's
-   *  bounds instead of the viewport. Omit for a global, viewport-anchored toast.
-   *  The chat targets itself by default so its copy/feedback toasts stay in-chat. */
-  target?: HTMLElement;
-}
-
-/** Options accepted by `toast()` — everything but the message. Pass `id` to
- *  update an existing toast in place. */
-export interface ToastOptions {
-  id?: string;
-  variant?: ToastVariant;
-  /** Visual treatment: `'pill'` (default) or `'card'`. Falls back to the value set
-   *  via `configureToasts`, then `'pill'`. */
-  appearance?: ToastAppearance;
-  /** High-contrast inverse surface. Falls back to `configureToasts`, then `false`. */
-  inverse?: boolean;
-  /** Secondary line shown below the message in the `'card'` appearance. */
-  description?: string;
-  action?: ToastAction;
-  duration?: number;
-  dismissible?: boolean;
-  /** Scope this toast to a container's bounds (e.g. a chat) instead of the
-   *  viewport. Omit for a global, viewport-anchored toast. */
-  target?: HTMLElement;
-}
-
-/** Handle returned from `toast()` for imperative control. */
-export interface ToastHandle {
-  id: string;
-  dismiss: () => void;
-  update: (patch: Partial<Omit<ToastItem, 'id'>>) => void;
-}
-
-/** Default auto-dismiss delay. Long enough to read + reach before it leaves. */
-export const DEFAULT_TOAST_DURATION = 5000;
-/** Minimum auto-dismiss delay when the toast carries an action (e.g. Undo) — it
- *  has to stay up long enough to actually act on. */
-export const ACTION_TOAST_FLOOR = 7000;
-
-// ── The reactive store ──────────────────────────────────────────────────────
-// Held in a never-disposed root so the signal/store graph stays live for the
-// lifetime of the page, independent of any component.
-const { toasts, setToasts, mounted, setMounted } = createRoot(() => {
-  const [list, setList] = createStore<ToastItem[]>([]);
-  const [isMounted, setIsMounted] = createSignal(false);
-  return { toasts: list, setToasts: setList, mounted: isMounted, setMounted: setIsMounted };
-});
-
-/** The live toast list (reactive). The region facade binds to this. */
-export function getToasts(): ToastItem[] {
-  return toasts;
-}
-
-let counter = 0;
-function nextId(): string {
-  counter += 1;
-  return `toast-${counter}`;
-}
-
-/** Resolve the effective duration, applying the action floor. */
-function resolveDuration(item: Pick<ToastItem, 'duration' | 'action'>): number {
-  const base = item.duration ?? DEFAULT_TOAST_DURATION;
-  if (base === 0) return 0; // explicit sticky wins
-  if (item.action) return Math.max(base, ACTION_TOAST_FLOOR);
-  return base;
-}
-
-/**
- * Lazily resolve the single `<kai-toast-region>` host for a target and bind the
- * store to its `toasts` property. Idempotent + SSR-safe. The element upgrade
- * (its `defineWebComponent` registration) happens when the elements bundle
- * loads; setting the property before/after upgrade both work because
- * `customElement` reflects late-set properties.
- *
- * ADOPT-IF-PRESENT: a connected
- * `<kai-toast-region>` already in the document (same `target`, not already
- * claimed for another target) is adopted — the store binds to IT, and no
- * second region mounts. Adoption respects the region's authored attributes
- * (position/stack/…): config from `configureToasts()` is not stamped onto an
- * adopted region here, though an explicit `configureToasts()` call still
- * updates every region, adopted included. Binding the store REPLACES a
- * `toasts` array the app set as data — after the first `toast()` call the
- * imperative store owns the adopted region's list. Only when no candidate
- * exists is a fresh region created on `document.body`. Two or more candidates
- * for the same target are genuinely ambiguous: the first in document order
- * wins, with a one-time console.warn (decide loudly).
- *
- * If an adopted (or created) region later leaves the DOM, the cache entry is
- * dropped and the next call resolves fresh — adopt again if a region exists,
- * else create — so a removed region never becomes a dead cache entry that
- * swallows toasts.
- */
-// One region per distinct target (the `null` key = the global / viewport region).
-// Every region binds the SAME store proxy and filters to its own target, so a
-// toast routes to the region for its `target`.
-const regions = new Map<HTMLElement | null, HTMLElement>();
-
-// Decide-loudly, once: ambiguity between 2+ candidate regions is warned about a
-// single time per page, not on every toast.
-let warnedAmbiguousRegions = false;
-
-/** Read a region element's `target` property (undefined pre-upgrade → null =
- *  the global region). */
-function regionTarget(el: HTMLElement): HTMLElement | null {
-  return (el as unknown as { target?: HTMLElement }).target ?? null;
-}
-
-export function ensureMounted(target: HTMLElement | null = null): HTMLElement | undefined {
-  if (typeof document === 'undefined') return undefined;
-  const cached = regions.get(target);
-  if (cached && cached.isConnected) return cached;
-  // The region this key resolved to left the DOM — drop the dead entry so it
-  // can never swallow toasts, and resolve fresh below.
-  if (cached) regions.delete(target);
-
-  // Adopt a region the app already placed. Regions this store already
-  // claimed for OTHER targets are not candidates.
-  const claimed = new Set(regions.values());
-  const candidates = Array.from(
-    document.querySelectorAll<HTMLElement>('kai-toast-region'),
-  ).filter((el) => el.isConnected && !claimed.has(el) && regionTarget(el) === target);
-  if (candidates.length > 1 && !warnedAmbiguousRegions) {
-    warnedAmbiguousRegions = true;
-    console.warn(
-      `[kitn] toast(): ${candidates.length} candidate <kai-toast-region> elements are in the ` +
-        'document; adopting the first in document order. Keep one region per target so the ' +
-        'imperative toast() API has an unambiguous home.',
-    );
-  }
-  const adopted = candidates[0];
-  if (adopted) {
-    (adopted as unknown as { toasts: ToastItem[] }).toasts = toasts as ToastItem[];
-    regions.set(target, adopted);
-    setMounted(true);
-    return adopted;
-  }
-
-  const el = document.createElement('kai-toast-region') as HTMLElement;
-  // Append FIRST so the element upgrades, THEN bind. Setting a property before
-  // upgrade loses it: component-register resets every prop in the constructor on
-  // upgrade (the same pre-upgrade clobber that bites <kai-chat>), so a pre-append
-  // `el.toasts = …` is wiped and the first toast never renders.
-  document.body.appendChild(el);
-  (el as unknown as { toasts: ToastItem[] }).toasts = toasts as ToastItem[];
-  if (target) (el as unknown as { target: HTMLElement }).target = target;
-  applyConfig(el); // inherit stack/position/max from configureToasts()
-  regions.set(target, el);
-  setMounted(true);
-  return el;
-}
-
-/** Test-only: whether `ensureMounted` has run. */
-export function isToastRegionMounted(): boolean {
-  return mounted();
-}
-
-function upsert(item: ToastItem): void {
-  const idx = toasts.findIndex((t) => t.id === item.id);
-  if (idx >= 0) {
-    setToasts(idx, item);
-  } else {
-    setToasts(produce((list) => { list.push(item); }));
-  }
-}
-
-function dismiss(id: string): void {
-  setToasts((list) => list.filter((t) => t.id !== id));
-}
-
-function makeHandle(id: string): ToastHandle {
-  return {
-    id,
-    dismiss: () => dismiss(id),
-    update: (patch) => {
-      const idx = toasts.findIndex((t) => t.id === id);
-      if (idx >= 0) setToasts(idx, (prev) => ({ ...prev, ...patch }));
-    },
-  };
-}
-
-/** Internal: raise/refresh a toast of a given variant. */
-function raise(message: string, opts: ToastOptions | undefined, variant: ToastVariant): ToastHandle {
-  ensureMounted(opts?.target ?? null);
-  const id = opts?.id ?? nextId();
-  const item: ToastItem = {
-    id,
-    message,
-    variant: opts?.variant ?? variant,
-    appearance: opts?.appearance ?? toastConfig.appearance ?? 'pill',
-    inverse: opts?.inverse ?? toastConfig.inverse ?? false,
-    description: opts?.description,
-    action: opts?.action,
-    duration: opts?.duration,
-    dismissible: opts?.dismissible,
-    target: opts?.target,
-  };
-  upsert(item);
-  return makeHandle(id);
-}
-
-export interface ToastFn {
-  (message: string, opts?: ToastOptions): ToastHandle;
-  /** Raise a success (green check) toast. */
-  success: (message: string, opts?: ToastOptions) => ToastHandle;
-  /** Raise a warning (amber) toast — e.g. an agent needs your input. */
-  warning: (message: string, opts?: ToastOptions) => ToastHandle;
-  /** Raise an error (destructive/red) toast — e.g. an agent failed. */
-  error: (message: string, opts?: ToastOptions) => ToastHandle;
-  /** Raise an info (blue) toast. */
-  info: (message: string, opts?: ToastOptions) => ToastHandle;
-  /** Dismiss a toast by id. */
-  dismiss: (id: string) => void;
-  /** Dismiss every active toast. */
-  clear: () => void;
-}
-
-/**
- * Raise a transient toast. Returns a `{ id, dismiss, update }` handle.
- *
- * ```ts
- * toast('Copied to clipboard');
- * toast.success('Saved');
- * const t = toast('Working…', { duration: 0 });
- * t.update({ message: 'Done', variant: 'success', duration: 2000 });
- * ```
- */
-export const toast: ToastFn = Object.assign(
-  (message: string, opts?: ToastOptions) => raise(message, opts, 'neutral'),
-  {
-    success: (message: string, opts?: ToastOptions) => raise(message, opts, 'success'),
-    warning: (message: string, opts?: ToastOptions) => raise(message, opts, 'warning'),
-    error: (message: string, opts?: ToastOptions) => raise(message, opts, 'error'),
-    info: (message: string, opts?: ToastOptions) => raise(message, opts, 'info'),
-    dismiss,
-    clear: () => setToasts([]),
-  },
-);
-
-// Re-export for the region facade so the effective-duration rule lives in one place.
-export { resolveDuration };