@tolle_/tolle-ui 18.2.29 → 18.3.0

package/lib/prompt-input.component.d.ts

@@ -0,0 +1,194 @@
+import { AfterViewInit, EventEmitter, OnChanges, OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { type VariantProps } from 'class-variance-authority';
+import * as i0 from "@angular/core";
+declare const promptInputVariants: (props?: ({
+    status?: "error" | "ready" | "streaming" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type PromptInputProps = VariantProps<typeof promptInputVariants>;
+/** Lifecycle of the response the composer is driving. */
+export type PromptInputStatus = NonNullable<PromptInputProps['status']>;
+/**
+ * Coordinates a `tolle-prompt-input` with its projected toolbar controls.
+ *
+ * The submit button is an OnPush child that must flip to a stop button the
+ * moment the status changes, so the composer publishes its state here instead
+ * of the button reading the parent's fields.
+ *
+ * Provided on `PromptInputComponent`, so each composer gets its own instance.
+ */
+export declare class PromptInputService {
+    private readonly statusSource;
+    /** Emits the composer's current status. */
+    readonly status$: import("rxjs").Observable<PromptInputStatus>;
+    private readonly canSubmitSource;
+    /** Emits whether there is submittable text and the composer is enabled. */
+    readonly canSubmit$: import("rxjs").Observable<boolean>;
+    private readonly submitSource;
+    /** Emits when a toolbar control asks the composer to submit. */
+    readonly submit$: import("rxjs").Observable<void>;
+    private readonly stopSource;
+    /** Emits when a toolbar control asks the composer to stop streaming. */
+    readonly stop$: import("rxjs").Observable<void>;
+    /** The composer's current status. */
+    get status(): PromptInputStatus;
+    /** True when the composer has submittable text. */
+    get canSubmit(): boolean;
+    setStatus(status: PromptInputStatus): void;
+    setCanSubmit(value: boolean): void;
+    requestSubmit(): void;
+    requestStop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromptInputService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PromptInputService>;
+}
+/**
+ * A message composer: an auto-growing textarea plus a toolbar, wired as a
+ * `ControlValueAccessor` so it drops into template- or reactive-driven forms.
+ *
+ * Enter submits and Shift+Enter inserts a newline (swap with `submitOnEnter`).
+ * While `status` is 'streaming' the projected `tolle-prompt-input-submit`
+ * becomes a stop button that emits `stopped`.
+ * @new
+ */
+export declare class PromptInputComponent implements ControlValueAccessor, OnInit, OnChanges, AfterViewInit, OnDestroy {
+    /** Placeholder shown while the composer is empty. @default 'Send a message…' */
+    placeholder: string;
+    /** Blocks typing and submission. @default false */
+    disabled: boolean;
+    /** Rows the textarea may grow to before it starts scrolling. @default 8 */
+    maxRows: number;
+    /** Lifecycle of the response being composed. @default 'ready' */
+    status: PromptInputStatus;
+    /** Size scale of the composer. @default 'default' */
+    size: PromptInputProps['size'];
+    /** Submit on Enter, keeping Shift+Enter for newlines. @default true */
+    submitOnEnter: boolean;
+    /** Clears the composer after a successful submit. @default true */
+    clearOnSubmit: boolean;
+    /** Accessible name for the textarea. @default '' */
+    ariaLabel: string;
+    /** Extra Tailwind classes merged onto the composer via `cn()` (last-wins). */
+    class: string;
+    /** Extra Tailwind classes merged onto the textarea via `cn()` (last-wins). */
+    textareaClass: string;
+    /** Emitted with the trimmed message text when the user submits. */
+    submitted: EventEmitter<string>;
+    /** Emitted when the user cancels an in-flight streaming response. */
+    stopped: EventEmitter<void>;
+    /** Emitted with the message text whenever it changes. */
+    valueChange: EventEmitter<string>;
+    private textarea?;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    value: string;
+    private onChange;
+    private onTouched;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    get textareaComputedClass(): string;
+    onInput(event: Event): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onBlur(): void;
+    /** Submits the current text, unless the composer is empty, disabled or busy. */
+    submit(): void;
+    /** Cancels an in-flight streaming response. */
+    stop(): void;
+    /** Moves focus into the textarea. */
+    focus(): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private get canSubmit();
+    private setValue;
+    private syncService;
+    /**
+     * Grows the textarea with its content up to `maxRows`, then lets it scroll.
+     * Measured from the computed line height so it tracks the inherited font.
+     */
+    private resize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromptInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PromptInputComponent, "tolle-prompt-input", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "maxRows": { "alias": "maxRows"; "required": false; }; "status": { "alias": "status"; "required": false; }; "size": { "alias": "size"; "required": false; }; "submitOnEnter": { "alias": "submitOnEnter"; "required": false; }; "clearOnSubmit": { "alias": "clearOnSubmit"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "class": { "alias": "class"; "required": false; }; "textareaClass": { "alias": "textareaClass"; "required": false; }; }, { "submitted": "submitted"; "stopped": "stopped"; "valueChange": "valueChange"; }, never, ["*"], true, never>;
+}
+/** Bottom bar of a `tolle-prompt-input`: tools on the left, submit on the right. */
+export declare class PromptInputToolbarComponent implements OnChanges {
+    private readonly cdr;
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Extra Tailwind classes merged onto the toolbar via `cn()` (last-wins). */
+    class: string;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromptInputToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PromptInputToolbarComponent, "tolle-prompt-input-toolbar", never, { "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** Left-aligned cluster of tool buttons inside a `tolle-prompt-input-toolbar`. */
+export declare class PromptInputToolsComponent implements OnChanges {
+    private readonly cdr;
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Extra Tailwind classes merged onto the tool row via `cn()` (last-wins). */
+    class: string;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromptInputToolsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PromptInputToolsComponent, "tolle-prompt-input-tools", never, { "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+declare const promptInputSubmitVariants: (props?: ({
+    variant?: "default" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type PromptInputSubmitProps = VariantProps<typeof promptInputSubmitVariants>;
+/**
+ * Send button for a `tolle-prompt-input`. Turns into a stop button while the
+ * composer's status is 'streaming', so one control covers both directions.
+ */
+export declare class PromptInputSubmitComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Visual style of the button. @default 'default' */
+    variant: PromptInputSubmitProps['variant'];
+    /** Size of the button. @default 'default' */
+    size: PromptInputSubmitProps['size'];
+    /** Accessible name while the composer is idle. @default 'Send message' */
+    submitLabel: string;
+    /** Accessible name while the composer is streaming. @default 'Stop generating' */
+    stopLabel: string;
+    /** Renders the label next to the icon. @default false */
+    showLabel: boolean;
+    /** Extra Tailwind classes merged onto the button via `cn()` (last-wins). */
+    class: string;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    status: PromptInputStatus;
+    canSubmit: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** True while the button is showing its stop affordance. */
+    get isStreaming(): boolean;
+    get currentIcon(): string;
+    get currentLabel(): string;
+    /** Stopping stays available with an empty composer; sending does not. */
+    get isDisabled(): boolean;
+    get computedClass(): string;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromptInputSubmitComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PromptInputSubmitComponent, "tolle-prompt-input-submit", never, { "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "submitLabel": { "alias": "submitLabel"; "required": false; }; "stopLabel": { "alias": "stopLabel"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/queue.component.d.ts

@@ -0,0 +1,106 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit } from '@angular/core';
+import { type VariantProps } from 'class-variance-authority';
+import * as i0 from "@angular/core";
+/** Where a queued entry is in its lifecycle. */
+export type QueueItemStatus = 'queued' | 'running' | 'done';
+/** Tallies of the entries currently in a queue. */
+export interface QueueCounts {
+    total: number;
+    queued: number;
+    running: number;
+    done: number;
+}
+declare const queueVariants: (props?: ({
+    size?: "default" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type QueueProps = VariantProps<typeof queueVariants>;
+declare const queueItemVariants: (props?: ({
+    status?: "running" | "done" | "queued" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type QueueItemProps = VariantProps<typeof queueItemVariants>;
+/**
+ * Counts the items of a single `tolle-queue`.
+ *
+ * The header is `OnPush` and the item count is not one of its inputs, so it is
+ * published as an observable and the subscriber calls `markForCheck()`.
+ */
+export declare class QueueService {
+    private readonly statuses;
+    private readonly countsSource;
+    /** Emits the queue's tallies whenever an item is added, updated or removed. */
+    readonly counts$: import("rxjs").Observable<QueueCounts>;
+    get counts(): QueueCounts;
+    register(id: string, status: QueueItemStatus): void;
+    setStatus(id: string, status: QueueItemStatus): void;
+    unregister(id: string): void;
+    private recompute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueueService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueueService>;
+}
+/**
+ * Messages or tasks waiting their turn. The header counts the entries for you,
+ * so the host only has to render `tolle-queue-item` children.
+ *
+ * ```html
+ * <tolle-queue title="Queued">
+ *   <tolle-queue-item label="Summarise the thread" status="running"></tolle-queue-item>
+ *   <tolle-queue-item label="Draft a reply" (remove)="drop(1)"></tolle-queue-item>
+ * </tolle-queue>
+ * ```
+ * @new
+ */
+export declare class QueueComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Heading shown above the queued items. @default 'Queue' */
+    title: string;
+    /** Text shown while the queue holds nothing. @default 'Nothing queued.' */
+    emptyMessage: string;
+    /** Padding and text scale of the queue. @default 'default' */
+    size: QueueProps['size'];
+    /** Extra Tailwind classes merged onto the queue via `cn()` (last-wins). */
+    class: string;
+    /** Emitted with the queue's tallies whenever its items change. */
+    countsChange: EventEmitter<QueueCounts>;
+    private readonly service;
+    private readonly cdr;
+    private readonly sub;
+    counts: QueueCounts;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    get countClass(): string;
+    get listClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QueueComponent, "tolle-queue", never, { "title": { "alias": "title"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "size": { "alias": "size"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "countsChange": "countsChange"; }, never, ["*"], true, never>;
+}
+/** A single entry in a `tolle-queue`. */
+export declare class QueueItemComponent implements OnInit, OnChanges, OnDestroy {
+    /** Text describing the queued work. @default '' */
+    label: string;
+    /** Lifecycle state of this entry. @default 'queued' */
+    status: QueueItemStatus;
+    /** Shows the trailing dismiss button that emits `remove`. @default true */
+    removable: boolean;
+    /** Accessible label for the dismiss button. @default 'Remove from queue' */
+    removeLabel: string;
+    /** Extra Tailwind classes merged onto the entry via `cn()` (last-wins). */
+    class: string;
+    /** Emitted when the user dismisses this entry. */
+    remove: EventEmitter<void>;
+    private readonly service;
+    private readonly id;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    get iconClass(): string;
+    get labelClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueueItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QueueItemComponent, "tolle-queue-item", never, { "label": { "alias": "label"; "required": false; }; "status": { "alias": "status"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "removeLabel": { "alias": "removeLabel"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "remove": "remove"; }, never, ["*"], true, never>;
+}
+export {};

package/lib/reasoning.component.d.ts

@@ -0,0 +1,127 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { type VariantProps } from 'class-variance-authority';
+import * as i0 from "@angular/core";
+/**
+ * Coordinates a `tolle-reasoning` with its trigger and content.
+ *
+ * The trigger and content are OnPush children, so the open/streaming/duration
+ * state they render from is published here rather than read off the parent.
+ *
+ * Provided on `ReasoningComponent`, so each trace gets its own instance.
+ */
+export declare class ReasoningService {
+    private readonly openSource;
+    /** Emits whether the trace is expanded. */
+    readonly open$: import("rxjs").Observable<boolean>;
+    private readonly streamingSource;
+    /** Emits whether the model is still producing the trace. */
+    readonly streaming$: import("rxjs").Observable<boolean>;
+    private readonly durationSource;
+    /** Emits how long the model spent reasoning, in seconds. */
+    readonly duration$: import("rxjs").Observable<number>;
+    /** True while the trace is expanded. */
+    get open(): boolean;
+    setOpen(value: boolean): void;
+    toggle(): void;
+    setStreaming(value: boolean): void;
+    setDuration(value: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReasoningService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReasoningService>;
+}
+declare const reasoningVariants: (props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ReasoningProps = VariantProps<typeof reasoningVariants>;
+/**
+ * A collapsible view of the model's reasoning, collapsed by default.
+ *
+ * While `streaming` is true the trigger reads "Thinking…"; once it finishes the
+ * trigger reports how long the model thought, using `duration`.
+ *
+ * Compose it from `tolle-reasoning-trigger` and `tolle-reasoning-content`.
+ * @new
+ */
+export declare class ReasoningComponent implements OnInit, OnChanges, OnDestroy {
+    /** Whether the trace is expanded. @default false */
+    open: boolean;
+    /** True while the model is still producing the trace. @default false */
+    streaming: boolean;
+    /** Seconds the model spent reasoning, shown once streaming finishes. @default 0 */
+    duration: number;
+    /** Text scale of the trace. @default 'default' */
+    size: ReasoningProps['size'];
+    /** Extra Tailwind classes merged onto the trace via `cn()` (last-wins). */
+    class: string;
+    /** Emitted with the new state whenever the trace is expanded or collapsed. */
+    openChange: EventEmitter<boolean>;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    /** True while an `open` input is being pushed into the service. */
+    private applyingInput;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private applyInput;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    private sync;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReasoningComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ReasoningComponent, "tolle-reasoning", never, { "open": { "alias": "open"; "required": false; }; "streaming": { "alias": "streaming"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "size": { "alias": "size"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*"], true, never>;
+}
+/**
+ * Toggle for a `tolle-reasoning`. Shows a live "Thinking…" label while the
+ * trace is streaming and the elapsed thinking time once it is done.
+ */
+export declare class ReasoningTriggerComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Remixicon class shown before the label. @default 'ri-brain-line' */
+    icon: string;
+    /** Label shown while the trace is streaming. @default 'Thinking…' */
+    thinkingLabel: string;
+    /** Label used when the trace finished without a measured duration. @default 'Thought for a few seconds' */
+    fallbackLabel: string;
+    /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */
+    class: string;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    open: boolean;
+    streaming: boolean;
+    duration: number;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** "Thinking…" while streaming, otherwise how long the model thought. */
+    get label(): string;
+    get computedClass(): string;
+    onToggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReasoningTriggerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ReasoningTriggerComponent, "tolle-reasoning-trigger", never, { "icon": { "alias": "icon"; "required": false; }; "thinkingLabel": { "alias": "thinkingLabel"; "required": false; }; "fallbackLabel": { "alias": "fallbackLabel"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The reasoning text itself. Rendered only while the trace is expanded. */
+export declare class ReasoningContentComponent implements OnChanges, OnInit, OnDestroy {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Reasoning text to render; project your own markup instead when richer. @default '' */
+    text: string;
+    /** Extra Tailwind classes merged onto the content via `cn()` (last-wins). */
+    class: string;
+    private readonly service;
+    private readonly cdr;
+    private readonly subscriptions;
+    open: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReasoningContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ReasoningContentComponent, "tolle-reasoning-content", never, { "text": { "alias": "text"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+export {};

package/lib/resizable.component.d.ts

@@ -0,0 +1,43 @@
+import { EventEmitter, ElementRef, AfterViewInit, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ResizableComponent implements AfterViewInit, OnDestroy {
+    width: number;
+    height: number;
+    minWidth: number;
+    minHeight: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    resizable: boolean;
+    directions: ('right' | 'bottom' | 'both')[];
+    class: string;
+    containerClass: string;
+    resizeStart: EventEmitter<void>;
+    resize: EventEmitter<{
+        width: number;
+        height: number;
+    }>;
+    resizeEnd: EventEmitter<{
+        width: number;
+        height: number;
+    }>;
+    container: ElementRef<HTMLDivElement>;
+    private isResizing;
+    private resizeDirection;
+    private startX;
+    private startY;
+    private startWidth;
+    private startHeight;
+    private mouseMoveListener?;
+    private mouseUpListener?;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    get computedContainerClass(): string;
+    onResizeStart(event: MouseEvent, direction: 'horizontal' | 'vertical' | 'both'): void;
+    private onMouseMove;
+    private onMouseUp;
+    private getResizeCursor;
+    private setupGlobalListeners;
+    private cleanupGlobalListeners;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResizableComponent, "tolle-resizable", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "directions": { "alias": "directions"; "required": false; }; "class": { "alias": "class"; "required": false; }; "containerClass": { "alias": "containerClass"; "required": false; }; }, { "resizeStart": "resizeStart"; "resize": "resize"; "resizeEnd": "resizeEnd"; }, never, ["*"], true, never>;
+}

package/lib/segment.component.d.ts

@@ -10,7 +10,7 @@ export type SegmentItem = {
     class?: string;
     data?: any;
 };
-export declare class SegmentedComponent implements ControlValueAccessor, AfterViewInit, OnChanges, OnDestroy {
+export declare class SegmentComponent implements ControlValueAccessor, AfterViewInit, OnChanges, OnDestroy {
     private cdr;
     items: SegmentItem[];
     class: string;
@@ -49,6 +49,16 @@ export declare class SegmentedComponent implements ControlValueAccessor, AfterVi
     registerOnTouched(fn: any): void;
     setDisabledState(isDisabled: boolean): void;
     protected cn: typeof cn;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentedComponent, "tolle-segment", never, { "items": { "alias": "items"; "required": false; }; "class": { "alias": "class"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentComponent, "tolle-segment", never, { "items": { "alias": "items"; "required": false; }; "class": { "alias": "class"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; }, {}, never, never, true, never>;
 }
+/**
+ * Back-compat alias: the class was renamed to match its `tolle-segment` selector.
+ *
+ * A re-export binding rather than `const SegmentedComponent = SegmentComponent`,
+ * because Angular's AOT compiler resolves an aliased export straight back to the
+ * class declaration — so it still works in a consumer's `imports: []` array.
+ *
+ * @deprecated Use `SegmentComponent`. This alias will be removed in a future major.
+ */
+export { SegmentComponent as SegmentedComponent };

package/lib/select.component.d.ts

@@ -1,18 +1,42 @@
-import { ElementRef, OnDestroy, QueryList, AfterContentInit, ChangeDetectorRef } from '@angular/core';
+import { EventEmitter, ElementRef, OnDestroy, QueryList, AfterContentInit, OnChanges, ChangeDetectorRef } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
+import { type VariantProps } from 'class-variance-authority';
 import { cn } from './utils/cn';
 import { SelectItemComponent } from './select-item.component';
 import { SelectService } from './select.service';
 import * as i0 from "@angular/core";
-export declare class SelectComponent implements ControlValueAccessor, AfterContentInit, OnDestroy {
+declare const selectTriggerVariants: (props?: ({
+    size?: "default" | "xs" | "sm" | "lg" | null | undefined;
+    disabled?: boolean | null | undefined;
+    readonly?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type SelectProps = VariantProps<typeof selectTriggerVariants>;
+/**
+ * A single-select listbox: a trigger that opens a floating panel of
+ * `tolle-select-item` options, with optional inline search. Implements
+ * `ControlValueAccessor`, so it works with `ngModel` and reactive forms.
+ */
+export declare class SelectComponent implements ControlValueAccessor, AfterContentInit, OnChanges, OnDestroy {
     private selectService;
     private cdr;
+    /** Text shown on the trigger when nothing is selected. @default 'Select an option' */
     placeholder: string;
+    /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). @default '' */
     class: string;
+    /** Disables the control and blocks opening the panel. @default false */
     disabled: boolean;
+    /** Adds a search box that filters the projected options. @default false */
     searchable: boolean;
-    size: 'xs' | 'sm' | 'default' | 'lg';
+    /** Height and text size of the trigger. @default 'default' */
+    size: SelectProps['size'];
+    /** Shows the current value but blocks opening the panel. @default false */
     readonly: boolean;
+    /** Emitted with the chosen value whenever the selection changes. */
+    valueChange: EventEmitter<any>;
+    /** Emitted when the panel opens. */
+    opened: EventEmitter<void>;
+    /** Emitted when the panel closes. */
+    closed: EventEmitter<void>;
     trigger: ElementRef;
     popover: ElementRef;
     container: ElementRef;
@@ -37,10 +61,17 @@ export declare class SelectComponent implements ControlValueAccessor, AfterConte
     constructor(selectService: SelectService, cdr: ChangeDetectorRef);
     get computedTriggerClass(): string;
     get iconClass(): string;
+    /**
+     * Under OnPush a `[class]` binding is applied through Angular's *styling*
+     * path, which writes the input but — unlike a plain property binding — never
+     * marks the component dirty. Without this the trigger would keep rendering
+     * the class it was born with. Covering every input here is cheap and leaves
+     * no second instance of that trap.
+     */
+    ngOnChanges(): void;
     ngAfterContentInit(): void;
     private applyPendingValue;
     private updateItemSelection;
-    private syncSelectedLabel;
     private _outsideClickHandler;
     toggle(): void;
     open(): void;
@@ -68,5 +99,6 @@ export declare class SelectComponent implements ControlValueAccessor, AfterConte
     setDisabledState(isDisabled: boolean): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "tolle-select", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "class": { "alias": "class"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "size": { "alias": "size"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, {}, ["items"], ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "tolle-select", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "class": { "alias": "class"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "size": { "alias": "size"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "valueChange": "valueChange"; "opened": "opened"; "closed": "closed"; }, ["items"], ["*"], true, never>;
 }
+export {};

package/lib/sheet.component.d.ts

@@ -8,10 +8,13 @@ export declare class SheetComponent {
     private viewContainerRef;
     private scrollStrategy;
     private overlayRef?;
+    /** Pending teardown scheduled by `hide()` for the exit animation. */
+    private disposeTimer?;
     /** Element focused before the sheet opened, restored on close. */
     private previouslyFocused?;
     contentComponent?: any;
     open(): void;
+    private cancelPendingDispose;
     close(): void;
     private show;
     private hide;

package/lib/shimmer.component.d.ts

@@ -0,0 +1,38 @@
+import { OnChanges } from '@angular/core';
+import { type VariantProps } from 'class-variance-authority';
+import * as i0 from "@angular/core";
+declare const shimmerVariants: (props?: ({
+    size?: "default" | "xs" | "sm" | "lg" | "xl" | null | undefined;
+    active?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ShimmerProps = VariantProps<typeof shimmerVariants>;
+/**
+ * Shimmering text for a live, in-progress status — "Thinking…", "Generating
+ * response…". While `active` the projected text sweeps with the `.shimmer`
+ * utility; when it is false the same text renders plain and static, so the
+ * label can stay mounted as the state settles.
+ *
+ * ```html
+ * <tolle-shimmer [active]="isStreaming" size="sm">Generating response…</tolle-shimmer>
+ * ```
+ * @new
+ */
+export declare class ShimmerComponent implements OnChanges {
+    private readonly cdr;
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges(): void;
+    /** Runs the shimmer animation; false renders plain static text. @default true */
+    active: boolean;
+    /** Text size of the label. @default 'default' */
+    size: ShimmerProps['size'];
+    /** Extra Tailwind classes merged onto the label via `cn()` (last-wins). */
+    class: string;
+    get computedClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShimmerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ShimmerComponent, "tolle-shimmer", never, { "active": { "alias": "active"; "required": false; }; "size": { "alias": "size"; "required": false; }; "class": { "alias": "class"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+export {};

package/lib/sidebar.component.d.ts

@@ -11,6 +11,8 @@ export type SidebarItem = {
     expanded?: boolean;
     /** Render as a plain anchor to an external URL / static file (opens in a new tab) instead of a router link. */
     external?: boolean;
+    /** Short trailing pill, e.g. 'New' or 'Beta'. Hidden while the sidebar is collapsed. */
+    badge?: string;
 };
 export type SidebarGroup = {
     title: string;