@amsterdamdatalabs/enact-design-system 0.1.12 → 0.1.24

package/README.md

@@ -18,7 +18,7 @@ Ported from the proven Amsterdam Data Labs (ADL) system in `net-revenue-demo`.
 
 ```bash
 bun install
-bun run docs                # browsable component showcase (light/dark toggle) at localhost:5180
+bun run studio              # theme workbench + component catalog at localhost:5182/?p=components
 bun run typecheck           # tsc --noEmit (also enforces prop/variant contracts)
 bun run lint                # Biome + Ultracite + GritQL adherence (see below)
 bun run format              # Biome formatter (write)
@@ -284,7 +284,7 @@ src/
   tokens/        CSS custom properties (ported): colors typography spacing effects fonts base + index.css
   components/    core/ feedback/ forms/ navigation/ — each: Name.tsx + Name.module.css + index.ts
   index.ts       the ONLY public entry point
-docs/            HTML showcase (bun run docs)
+studio/          Theme workbench + Components tab (bun run studio)
 .grit/           GritQL adherence plugins (raw hex/px/font bans)
 test/            bun test (A/B/C) + visual/ Playwright specs (D)
 biome.jsonc      Biome + Ultracite config (extends + GritQL plugins)

package/dist/components/ai/ActivityLog/ActivityLog.d.ts

@@ -0,0 +1,28 @@
+import type { ButtonHTMLAttributes, ReactNode } from "react";
+export type ActivityLogTone = "system" | "info" | "success" | "error" | "artifact";
+export interface ActivityLogProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children" | "onClick"> {
+    /** Optional controlled detail content rendered below the activity row. */
+    details?: ReactNode;
+    /** Accessible and visible label for the controlled detail disclosure. */
+    detailsLabel?: ReactNode;
+    /** Controlled detail visibility. */
+    expanded?: boolean;
+    /** Optional leading visual supplied by the application. */
+    icon?: ReactNode;
+    /** Normalized activity message. */
+    message: ReactNode;
+    /** Reports an activation intent, such as opening an artifact. */
+    onActivate?: () => void;
+    /** Reports a controlled detail visibility change. */
+    onToggleDetails?: (expanded: boolean) => void;
+    /** Semantic activity tone. */
+    tone: ActivityLogTone;
+}
+/**
+ * Controlled activity-log presentation.
+ *
+ * Activity classification, translation, metadata serialization, artifact
+ * resolution, and side effects remain application responsibilities. The
+ * design system owns the normalized row, tone styling, and detail disclosure.
+ */
+export declare function ActivityLog({ className, details, detailsLabel, expanded, icon, message, onActivate, onToggleDetails, tone, type, ...rest }: ActivityLogProps): import("react").JSX.Element;

package/dist/components/ai/ActivityLog/index.d.ts

@@ -0,0 +1 @@
+export { ActivityLog, type ActivityLogProps, type ActivityLogTone, } from "./ActivityLog";

package/dist/components/ai/ActivitySummary/ActivitySummary.d.ts

@@ -0,0 +1,17 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface ActivitySummaryMetric {
+    label: string;
+    value: string | number;
+}
+export interface ActivitySummaryProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Expandable detail content rendered when open. */
+    children?: ReactNode;
+    /** Whether the detail panel starts open (uncontrolled). Defaults to false. */
+    defaultOpen?: boolean;
+    /** Optional metrics row (e.g. citations/searches). */
+    metrics?: ActivitySummaryMetric[];
+    ref?: Ref<HTMLDivElement>;
+    /** High-level text summary, e.g. "Research completed in 9m". */
+    summary: string;
+}
+export declare function ActivitySummary({ summary, metrics, defaultOpen, children, className, ref, ...rest }: ActivitySummaryProps): import("react").JSX.Element;

package/dist/components/ai/ActivitySummary/index.d.ts

@@ -0,0 +1 @@
+export { ActivitySummary, type ActivitySummaryMetric, type ActivitySummaryProps, } from "./ActivitySummary";

package/dist/components/ai/ActivityTimeline/ActivityTimeline.d.ts

@@ -0,0 +1,14 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type ActivityTimelineStatus = "pending" | "active" | "done" | "failed";
+export interface ActivityTimelineItem {
+    detail?: ReactNode;
+    id: string;
+    label: string;
+    status?: ActivityTimelineStatus;
+    timestamp?: string;
+}
+export interface ActivityTimelineProps extends Omit<HTMLAttributes<HTMLOListElement>, "children"> {
+    items: ActivityTimelineItem[];
+    ref?: Ref<HTMLOListElement>;
+}
+export declare function ActivityTimeline({ items, className, ref, ...rest }: ActivityTimelineProps): import("react").JSX.Element;

package/dist/components/ai/ActivityTimeline/index.d.ts

@@ -0,0 +1 @@
+export { ActivityTimeline, type ActivityTimelineItem, type ActivityTimelineProps, type ActivityTimelineStatus, } from "./ActivityTimeline";

package/dist/components/ai/ActivityTimelineDisclosure/ActivityTimelineDisclosure.d.ts

@@ -0,0 +1,43 @@
+import type { DetailsHTMLAttributes, ReactNode, Ref } from "react";
+import type { ToolCallGroupData } from "../ToolCallGroup/ToolCallGroup";
+export type ActivityTimelineDisclosureTone = "default" | "error" | "muted" | "success" | "warning";
+export type ActivityTimelineDisclosureItem = {
+    chips?: Array<{
+        id: string;
+        label: ReactNode;
+    }>;
+    detail?: ReactNode;
+    href?: string;
+    icon?: ReactNode;
+    id: string;
+    kind: "activity";
+    label: ReactNode;
+    meta?: ReactNode;
+    tone?: ActivityTimelineDisclosureTone;
+} | {
+    id: string;
+    kind: "divider";
+    label: string;
+} | {
+    group: ToolCallGroupData;
+    id: string;
+    kind: "tool-group";
+};
+export interface ActivityTimelineDisclosureProps extends Omit<DetailsHTMLAttributes<HTMLDetailsElement>, "children" | "open"> {
+    /** Open on first render when uncontrolled. */
+    defaultOpen?: boolean;
+    /** Normalized transcript activity, dividers, and consecutive tool-call groups. */
+    items: ActivityTimelineDisclosureItem[];
+    /** Called whenever the native disclosure requests an open-state change. */
+    onOpenChange?: (open: boolean) => void;
+    /** Controlled disclosure state. */
+    open?: boolean;
+    ref?: Ref<HTMLDetailsElement>;
+    /** Display-ready elapsed activity summary, for example "Worked for 1m 04s". */
+    summary: ReactNode;
+}
+/**
+ * Controlled disclosure for normalized transcript activity. Consumers retain
+ * protocol grouping and duration formatting; this component owns all visuals.
+ */
+export declare function ActivityTimelineDisclosure({ className, defaultOpen, items, onOpenChange, open, ref, summary, ...rest }: ActivityTimelineDisclosureProps): import("react").JSX.Element;

package/dist/components/ai/ActivityTimelineDisclosure/index.d.ts

@@ -0,0 +1 @@
+export { ActivityTimelineDisclosure, type ActivityTimelineDisclosureItem, type ActivityTimelineDisclosureProps, type ActivityTimelineDisclosureTone, } from "./ActivityTimelineDisclosure";

package/dist/components/ai/AgentControlsView/AgentControlsView.d.ts

@@ -0,0 +1,133 @@
+import { type HTMLAttributes, type ReactElement, type ReactNode, type RefObject } from "react";
+/** A display-ready option supplied by the application adapter. */
+export interface AgentControlsOption {
+    id: string;
+    label: string;
+}
+export interface AgentControlsToggleFeature {
+    icon?: ReactNode;
+    id: string;
+    label: string;
+    offLabel?: string;
+    onLabel?: string;
+    options?: never;
+    tooltip?: string;
+    type: "toggle";
+    value: boolean;
+}
+export interface AgentControlsSelectFeature {
+    icon?: ReactNode;
+    id: string;
+    label: string;
+    options: readonly AgentControlsOption[];
+    tooltip?: string;
+    type: "select";
+    value: string | null;
+}
+/** A normalized feature descriptor with no provider or protocol ownership. */
+export type AgentControlsFeature = AgentControlsToggleFeature | AgentControlsSelectFeature;
+export type AgentControlsControlId = "provider" | "thinking" | "features" | `feature-${string}`;
+export interface AgentControlsControlRenderArgs {
+    anchorRef: RefObject<HTMLButtonElement | null>;
+    compact: boolean;
+    disabled: boolean;
+    isLoading: boolean;
+    isOpen: boolean;
+    label: string;
+    onOpenChange: (open: boolean) => void;
+    options: readonly AgentControlsOption[];
+    selectedId?: string;
+    trigger: ReactElement;
+    value?: string;
+}
+export interface AgentControlsModelRenderArgs {
+    className: string;
+    compact: boolean;
+    disabled: boolean;
+    isLoading: boolean;
+    isRetrying: boolean;
+    selectedId?: string;
+    textClassName: string;
+}
+export interface AgentControlsFeatureRenderArgs {
+    compact: boolean;
+    disabled: boolean;
+    feature: AgentControlsFeature;
+    isOpen: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSelect: (optionId: string) => void;
+    onToggle: () => void;
+    optionsContent: ReactElement | null;
+    trigger: ReactElement;
+}
+export interface AgentControlsFeatureGroupRenderArgs {
+    content: ReactElement;
+    disabled: boolean;
+    isOpen: boolean;
+    onOpenChange: (open: boolean) => void;
+    trigger: ReactElement;
+}
+export interface AgentControlsViewProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "onChange"> {
+    /** Selects the compact visual arrangement. */
+    compact?: boolean;
+    /** Disables all controlled intents while retaining selected values. */
+    disabled?: boolean;
+    /** Extra application-owned control, such as the mode picker. */
+    extras?: ReactNode;
+    /** Optional compact feature-group icon supplied by the app. */
+    featureGroupIcon?: ReactNode;
+    /** Normalized feature choices. */
+    features?: readonly AgentControlsFeature[];
+    /** Current loading state for the model/provider surface. */
+    isModelLoading?: boolean;
+    /** Current provider refresh state. */
+    isRetryingModelProvider?: boolean;
+    /** Reports a request to open or close an app-owned popup/sheet. */
+    onControlOpenChange?: (controlId: AgentControlsControlId, open: boolean) => void;
+    /** Reports a normalized model selection intent for app-owned model UI. */
+    onSelectModel?: (modelId: string) => void;
+    /** Reports a normalized provider selection intent. */
+    onSelectProvider?: (providerId: string) => void;
+    /** Reports a normalized thinking selection intent. */
+    onSelectThinkingOption?: (thinkingOptionId: string) => void;
+    /** Reports a normalized feature value intent. */
+    onSetFeature?: (featureId: string, value: boolean | string) => void;
+    /** Controlled popup/sheet ownership remains in the application adapter. */
+    openControlId?: AgentControlsControlId | null;
+    /** Display fallback when a selected provider is not in the options. */
+    providerFallbackLabel?: string;
+    /** Normalized provider choices. */
+    providerOptions?: readonly AgentControlsOption[];
+    /** Supplies the compact feature sheet around the DS feature content. */
+    renderCompactFeatures?: (args: AgentControlsFeatureGroupRenderArgs) => ReactNode;
+    /** Supplies application-owned feature popup policy around DS content. */
+    renderFeature?: (args: AgentControlsFeatureRenderArgs) => ReactNode;
+    /** Supplies the application-owned model picker and its side effects. */
+    renderModel?: (args: AgentControlsModelRenderArgs) => ReactNode;
+    /** Supplies the application-owned provider popup around the DS trigger. */
+    renderProvider?: (args: AgentControlsControlRenderArgs) => ReactNode;
+    /** Supplies the application-owned thinking popup/sheet around the trigger. */
+    renderThinking?: (args: AgentControlsControlRenderArgs) => ReactNode;
+    /** Current model choice, passed to the model slot. */
+    selectedModelId?: string;
+    /** Current provider choice. */
+    selectedProviderId?: string;
+    /** Current thinking choice. */
+    selectedThinkingOptionId?: string;
+    /** Stable test id for the control group. */
+    testId?: string;
+    /** Display fallback when a selected thinking choice is not in the options. */
+    thinkingFallbackLabel?: string;
+    /** Optional compact thinking icon supplied by the app. */
+    thinkingIcon?: ReactNode;
+    /** Normalized thinking choices. */
+    thinkingOptions?: readonly AgentControlsOption[];
+}
+/**
+ * Controlled visual surface for provider, model, thinking, and feature controls.
+ *
+ * The app supplies normalized descriptors and owns stores, protocol/runtime
+ * authority, localization, keyboard policy, and popup/sheet lifecycle. Render
+ * slots let the app wrap DS-owned triggers and option content in that policy.
+ */
+export declare function AgentControlsView({ className, compact, disabled, extras, featureGroupIcon, features, isModelLoading, isRetryingModelProvider, onControlOpenChange, onSelectModel, onSelectProvider, onSelectThinkingOption, onSetFeature, openControlId, providerFallbackLabel, providerOptions, renderCompactFeatures, renderFeature, renderModel, renderProvider, renderThinking, selectedModelId, selectedProviderId, selectedThinkingOptionId, thinkingFallbackLabel, thinkingIcon, thinkingOptions, testId, ...rest }: AgentControlsViewProps): import("react").JSX.Element | null;

package/dist/components/ai/AgentControlsView/agent-controls-events.d.ts

@@ -0,0 +1,13 @@
+import { type ReactElement } from "react";
+import type { AgentControlsControlId, AgentControlsFeature, AgentControlsFeatureRenderArgs } from "./AgentControlsView";
+export declare function handleAgentControlOpenChange(controlOpenChange: (controlId: AgentControlsControlId, open: boolean) => void, controlId: AgentControlsControlId, open: boolean): void;
+export declare function handleAgentControlToggle(controlOpenChange: (controlId: AgentControlsControlId, open: boolean) => void, controlId: AgentControlsControlId, openControlId: AgentControlsControlId | null): void;
+export interface RenderAgentFeatureContext {
+    disabled: boolean;
+    isCompact: boolean;
+    onControlOpenChange: (controlId: AgentControlsControlId, open: boolean) => void;
+    onSetFeature?: (featureId: string, value: boolean | string) => void;
+    openControlId: AgentControlsControlId | null;
+    renderFeature?: (args: AgentControlsFeatureRenderArgs) => React.ReactNode;
+}
+export declare function renderAgentFeatureEntry(context: RenderAgentFeatureContext, feature: AgentControlsFeature): ReactElement;

package/dist/components/ai/AgentControlsView/agent-controls-layout.d.ts

@@ -0,0 +1,17 @@
+import type { ReactElement, ReactNode } from "react";
+import type { AgentControlsControlId } from "./AgentControlsView";
+export declare function createAgentControlOpenChange(onControlOpenChange?: (controlId: AgentControlsControlId, open: boolean) => void): (controlId: AgentControlsControlId, open: boolean) => void;
+export declare function handleCompactFeatureGroupToggle(onOpenChange: (open: boolean) => void, openControlId: string | null): void;
+export declare function renderCompactFeatureGroup({ content, disabled, featureGroupIcon, onOpenChange, openControlId, }: {
+    content: ReactElement;
+    disabled: boolean;
+    featureGroupIcon?: ReactNode;
+    onOpenChange: (open: boolean) => void;
+    openControlId: string | null;
+}): {
+    content: ReactElement;
+    disabled: boolean;
+    isOpen: boolean;
+    onOpenChange: (open: boolean) => void;
+    trigger: ReactElement;
+};

package/dist/components/ai/AgentControlsView/agent-controls-parts.d.ts

@@ -0,0 +1,29 @@
+import type { ReactElement, ReactNode, RefObject } from "react";
+import type { AgentControlsControlId, AgentControlsFeature, AgentControlsFeatureRenderArgs, AgentControlsOption, AgentControlsSelectFeature } from "./AgentControlsView";
+export declare function selectedLabel(options: readonly AgentControlsOption[] | undefined, value: string | undefined, fallback: string): string;
+export declare function controlTrigger({ ariaLabel, className, compact, disabled, expanded, icon, label, onClick, ref, testId, }: {
+    ariaLabel: string;
+    className: string;
+    compact: boolean;
+    disabled: boolean;
+    expanded: boolean;
+    icon?: ReactNode;
+    label: string;
+    onClick: () => void;
+    ref: RefObject<HTMLButtonElement | null>;
+    testId: string;
+}): ReactElement;
+export declare function featureTrigger(feature: AgentControlsFeature, compact: boolean, disabled: boolean, isOpen: boolean, onOpenChange: (open: boolean) => void, onToggle: () => void): ReactElement;
+export declare function FeatureOptions({ feature, onSelect, }: {
+    feature: AgentControlsSelectFeature;
+    onSelect: (optionId: string) => void;
+}): ReactElement;
+export declare function renderAgentFeatureContent({ disabled, feature, isCompact, onControlOpenChange, onSetFeature, openControlId, renderFeature, }: {
+    disabled: boolean;
+    feature: AgentControlsFeature;
+    isCompact: boolean;
+    onControlOpenChange: (controlId: AgentControlsControlId, open: boolean) => void;
+    onSetFeature?: (featureId: string, value: boolean | string) => void;
+    openControlId: AgentControlsControlId | null;
+    renderFeature?: (args: AgentControlsFeatureRenderArgs) => ReactNode;
+}): ReactElement;

package/dist/components/ai/AgentControlsView/index.d.ts

@@ -0,0 +1 @@
+export * from "./AgentControlsView";

package/dist/components/ai/AgentModePicker/AgentModePicker.d.ts

@@ -0,0 +1,32 @@
+import type { HTMLAttributes, ReactNode } from "react";
+/** A normalized selectable agent mode. */
+export interface AgentModePickerOption {
+    /** Optional visual identity supplied by the consumer. */
+    icon?: ReactNode;
+    /** Human-readable mode label. */
+    label: ReactNode;
+    /** Stable controlled value reported by `onChange`. */
+    value: string;
+}
+export interface AgentModePickerProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "title"> {
+    /** Disables the menu trigger while preserving its selected mode. */
+    disabled?: boolean;
+    /** Accessible label for the trigger. */
+    label?: string;
+    /** Controlled selection callback. */
+    onChange: (value: string) => void;
+    /** Normalized choices; ordering is preserved in the menu. */
+    options: readonly AgentModePickerOption[];
+    /** Accessible title announced for the menu. */
+    title?: string;
+    /** Controlled selected value. */
+    value: string | null | undefined;
+}
+/**
+ * Controlled agent-mode selection presentation.
+ *
+ * Mode availability, provider-specific visuals, keyboard shortcuts, persistence,
+ * and runtime updates remain application concerns. Consumers provide normalized
+ * options and receive only the selected value.
+ */
+export declare function AgentModePicker({ className, disabled, label, onChange, options, title, value, ...rest }: AgentModePickerProps): import("react").JSX.Element | null;

package/dist/components/ai/AgentModePicker/index.d.ts

@@ -0,0 +1 @@
+export { AgentModePicker, type AgentModePickerOption, type AgentModePickerProps, } from "./AgentModePicker";

package/dist/components/ai/AgentPanelStateView/AgentPanelStateView.d.ts

@@ -0,0 +1,30 @@
+import type { HTMLAttributes } from "react";
+export type AgentPanelStateViewState = {
+    kind: "loading";
+    description?: string;
+    title?: string;
+} | {
+    kind: "empty";
+    description?: string;
+    title: string;
+} | {
+    kind: "error";
+    message?: string;
+    title: string;
+} | {
+    kind: "unavailable";
+    description?: string;
+    detail?: string;
+    phase: "unknown-host" | "connecting" | "preparing" | "offline";
+    title: string;
+} | {
+    kind: "archiving";
+    description: string;
+    title: string;
+};
+export interface AgentPanelStateViewProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "title"> {
+    state: AgentPanelStateViewState;
+    testId?: string;
+}
+/** Controlled status visual for an agent panel's non-ready states. */
+export declare function AgentPanelStateView({ className, state, testId, ...rest }: AgentPanelStateViewProps): import("react").JSX.Element;

package/dist/components/ai/AgentPanelStateView/index.d.ts

@@ -0,0 +1 @@
+export * from "./AgentPanelStateView";

package/dist/components/ai/AgentStreamViewport/AgentStreamViewport.d.ts

@@ -0,0 +1,27 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface AgentStreamScrollAction {
+    /** Localized accessible label. */
+    ariaLabel: string;
+    /** Controlled visual supplied by the application. */
+    icon: ReactNode;
+    /** Application-owned imperative scroll intent. */
+    onPress: () => void;
+    testId?: string;
+}
+export interface AgentStreamViewportProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+    /** App-owned auxiliary content, such as permission requests or a turn footer. */
+    auxiliarySlot?: ReactNode;
+    /** Display-ready empty state shown when no stream content exists. */
+    emptySlot?: ReactNode;
+    ref?: Ref<HTMLElement>;
+    /** Controlled scroll-to-bottom intent; visibility remains app-owned. */
+    scrollToBottom?: AgentStreamScrollAction;
+    /** App-owned virtualized or mounted stream viewport. */
+    viewportSlot: ReactNode;
+}
+/**
+ * Controlled transcript canvas. The application retains virtualization,
+ * anchors, measurements, and stream data; this view owns reusable canvas,
+ * reading-column, empty, auxiliary, and scroll-action presentation.
+ */
+export declare function AgentStreamViewport({ auxiliarySlot, className, emptySlot, ref, scrollToBottom, viewportSlot, ...rest }: AgentStreamViewportProps): import("react").JSX.Element;

package/dist/components/ai/AgentStreamViewport/index.d.ts

@@ -0,0 +1 @@
+export { type AgentStreamScrollAction, AgentStreamViewport, type AgentStreamViewportProps, } from "./AgentStreamViewport";

package/dist/components/ai/ApprovalRequestCard/ApprovalRequestCard.d.ts

@@ -0,0 +1,32 @@
+import type { HTMLAttributes, Ref } from "react";
+export type ApprovalRequestStatus = "pending" | "approved" | "rejected";
+export interface ApprovalRequestCardLabels {
+    approve?: string;
+    approved?: string;
+    pending?: string;
+    reject?: string;
+    rejected?: string;
+}
+export interface ApprovalRequestCardProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Supporting explanation for the request. */
+    description: string;
+    /** Stable identifier passed back through approval intents. */
+    id: string;
+    /** Localizable UI labels. */
+    labels?: ApprovalRequestCardLabels;
+    /** Called when the user approves a pending request. */
+    onApprove?: (id: string) => void;
+    /** Called when the user rejects a pending request. */
+    onReject?: (id: string) => void;
+    ref?: Ref<HTMLDivElement>;
+    /** Current request state. Completed requests render a compact summary. */
+    status: ApprovalRequestStatus;
+    /** Concise request title. */
+    title: string;
+}
+/**
+ * Controlled decision card for an approval request. Consumers own request
+ * transport and persistence; this component owns only its visual states and
+ * emits intent callbacks using the supplied identifier.
+ */
+export declare function ApprovalRequestCard({ className, description, id, labels, onApprove, onReject, ref, status, title, ...rest }: ApprovalRequestCardProps): import("react").JSX.Element;

package/dist/components/ai/ApprovalRequestCard/index.d.ts

@@ -0,0 +1 @@
+export { ApprovalRequestCard, type ApprovalRequestCardLabels, type ApprovalRequestCardProps, type ApprovalRequestStatus, } from "./ApprovalRequestCard";

package/dist/components/ai/AssistantTranscriptMessageView/AssistantTranscriptMessageView.d.ts

@@ -0,0 +1,17 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface AssistantTranscriptMessageViewProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+    attachmentsSlot?: ReactNode;
+    body: ReactNode;
+    editedFilesSlot?: ReactNode;
+    footerSlot?: ReactNode;
+    memoryCitationsSlot?: ReactNode;
+    ref?: Ref<HTMLElement>;
+    sourcesHeader?: ReactNode;
+    sourcesSlot?: ReactNode;
+    workSlot?: ReactNode;
+}
+/**
+ * Controlled visual shell for an assistant transcript turn. Applications own
+ * transcript decoding, actions, localization, and every supplied slot.
+ */
+export declare function AssistantTranscriptMessageView({ attachmentsSlot, body, className, editedFilesSlot, footerSlot, memoryCitationsSlot, ref, sourcesHeader, sourcesSlot, workSlot, ...rest }: AssistantTranscriptMessageViewProps): import("react").JSX.Element;

package/dist/components/ai/AssistantTranscriptMessageView/index.d.ts

@@ -0,0 +1 @@
+export { AssistantTranscriptMessageView, type AssistantTranscriptMessageViewProps, } from "./AssistantTranscriptMessageView";

package/dist/components/ai/CitationDisclosure/CitationDisclosure.d.ts

@@ -0,0 +1,25 @@
+import type { DetailsHTMLAttributes, Ref } from "react";
+export interface CitationDisclosureItem {
+    detail?: string;
+    href?: string;
+    id: string;
+    label: string;
+}
+export interface CitationDisclosureProps extends Omit<DetailsHTMLAttributes<HTMLDetailsElement>, "children" | "open"> {
+    /** Open on first render when uncontrolled. */
+    defaultOpen?: boolean;
+    /** Citation rows rendered when the disclosure is expanded. */
+    items: CitationDisclosureItem[];
+    /** Called whenever the native disclosure requests an open-state change. */
+    onOpenChange?: (open: boolean) => void;
+    /** Controlled disclosure state. */
+    open?: boolean;
+    ref?: Ref<HTMLDetailsElement>;
+    /** Accessible summary shown in the disclosure trigger. */
+    summary: string;
+}
+/**
+ * A compact, native disclosure for supplemental citations. Consumers retain
+ * citation sourcing and localization while this component owns presentation.
+ */
+export declare function CitationDisclosure({ className, defaultOpen, items, onOpenChange, open, ref, summary, ...rest }: CitationDisclosureProps): import("react").JSX.Element;

package/dist/components/ai/CitationDisclosure/index.d.ts

@@ -0,0 +1 @@
+export { CitationDisclosure, type CitationDisclosureItem, type CitationDisclosureProps, } from "./CitationDisclosure";

package/dist/components/ai/ComposerInput/ComposerInput.d.ts

@@ -0,0 +1,66 @@
+import type { CSSProperties, HTMLAttributes, ReactNode, Ref } from "react";
+export type ComposerControlState = "default" | "disabled" | "loading" | "muted" | "recording";
+export interface ComposerToolbarProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Leading attachment control. The consumer owns file/menu lifecycle. */
+    attachmentControl?: ReactNode;
+    /** Normalized visual state for the attachment control. */
+    attachmentState?: ComposerControlState;
+    /** Content between the leading and trailing control groups. */
+    beforeVoiceContent?: ReactNode;
+    /** Additional app-owned controls beside the attachment control. */
+    leftContent?: ReactNode;
+    /** Additional app-owned controls beside the voice and submit controls. */
+    rightContent?: ReactNode;
+    /** Controlled submit/queue control. */
+    submitControl?: ReactNode;
+    /** Normalized visual state for the submit control. */
+    submitState?: ComposerControlState;
+    /** Controlled voice/dictation control. */
+    voiceControl?: ReactNode;
+    /** Normalized visual state for the voice control. */
+    voiceState?: ComposerControlState;
+}
+export interface ComposerInputProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "style"> {
+    /** Controlled toolbar content for the leading attachment group. */
+    attachmentControl?: ReactNode;
+    /** Content rendered above the text input, such as attachment pills. */
+    attachmentSlot?: ReactNode;
+    /** Normalized visual state for the attachment control. */
+    attachmentState?: ComposerControlState;
+    /** Content rendered before the voice control. */
+    beforeVoiceContent?: ReactNode;
+    /** Adds the shell elevation treatment used by the desktop shell. */
+    enactShell?: boolean;
+    /** Controls the surface focus treatment. */
+    focused?: boolean;
+    /** Controlled focus hint content; shortcut formatting stays in the adapter. */
+    focusHintSlot?: ReactNode;
+    /** Controlled input content. IME, focus, selection, sizing, and decorations stay in the adapter. */
+    inputSlot: ReactNode;
+    /** Additional app-owned controls in the leading toolbar group. */
+    leftContent?: ReactNode;
+    /** App-owned overlay content, such as dictation or realtime voice. */
+    overlaySlot?: ReactNode;
+    /** Keeps the overlay interactive while retaining the surface in the layout. */
+    overlayVisible?: boolean;
+    ref?: Ref<HTMLDivElement>;
+    /** Content rendered after the voice control and before submit. */
+    rightContent?: ReactNode;
+    /** Controlled submit/queue control. */
+    submitControl?: ReactNode;
+    /** Normalized visual state for the submit control. */
+    submitState?: ComposerControlState;
+    /** Inline style forwarded to the visual surface for additive host customization. */
+    surfaceStyle?: CSSProperties;
+    /** Controlled voice/dictation control. */
+    voiceControl?: ReactNode;
+    /** Normalized visual state for the voice control. */
+    voiceState?: ComposerControlState;
+}
+export declare function ComposerToolbar({ attachmentControl, attachmentState, beforeVoiceContent, className, leftContent, rightContent, submitControl, submitState, voiceControl, voiceState, ...rest }: ComposerToolbarProps): import("react").JSX.Element;
+/**
+ * Controlled composer surface. Product adapters own input and runtime
+ * behavior; this component owns the reusable surface structure, tokens, and
+ * state treatments.
+ */
+export declare function ComposerInput({ attachmentSlot, attachmentControl, attachmentState, beforeVoiceContent, className, enactShell, focused, inputSlot, focusHintSlot, leftContent, overlaySlot, overlayVisible, ref, rightContent, submitControl, submitState, surfaceStyle, voiceControl, voiceState, ...rest }: ComposerInputProps): import("react").JSX.Element;

package/dist/components/ai/ComposerInput/index.d.ts

@@ -0,0 +1 @@
+export { type ComposerControlState, ComposerInput, type ComposerInputProps, ComposerToolbar, type ComposerToolbarProps, } from "./ComposerInput";

package/dist/components/ai/ContextSourceList/ContextSourceList.d.ts

@@ -0,0 +1,21 @@
+import type { HTMLAttributes, ReactNode } from "react";
+export interface ContextSourceListItem {
+    detail?: ReactNode;
+    icon?: ReactNode;
+    id: string;
+    label: ReactNode;
+}
+export type ContextSourceListLayout = "compact" | "stacked";
+export interface ContextSourceListProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    layout?: ContextSourceListLayout;
+    onSourceSelect?: (id: string) => void;
+    selectedSourceId?: string;
+    sources?: ContextSourceListItem[];
+    testId?: string;
+}
+/**
+ * Token-backed source rows shared by compact context summaries and full source
+ * destinations. Selection is controlled and exposed with `aria-current`;
+ * interaction remains opt-in through the selection callback.
+ */
+export declare function ContextSourceList({ className, layout, onSourceSelect, selectedSourceId, sources, testId, ...rest }: ContextSourceListProps): import("react").JSX.Element | null;

package/dist/components/ai/ContextSourceList/index.d.ts

@@ -0,0 +1 @@
+export { ContextSourceList, type ContextSourceListItem, type ContextSourceListLayout, type ContextSourceListProps, } from "./ContextSourceList";