@vibesdotdev/kit 0.0.0-stage → 1.0.0-rc.4

package/dist/lib/components/tool-widgets/tool-meta.js

@@ -0,0 +1,232 @@
+/**
+ * Shared presentation metadata for tool-call widgets: status → badge,
+ * tool id → icon / title, plus small formatting helpers. Bespoke widgets and
+ * the default card both read from here so every surface stays aligned.
+ */
+import * as z from 'zod/v4';
+import { settleNow } from '../../attempt';
+import { failureClass } from '../../failure-class';
+import { kitLogger } from '../../kit-logger';
+const logger = kitLogger('vibeskit-tool-widgets');
+const ToolFailureEnvelope = z.object({ ok: z.literal(false), error: z.string() });
+/** Own keys only: `toString`, `constructor` and friends are not tool ids. */
+function isTableKey(table, key) {
+    return Object.hasOwn(table, key);
+}
+function isToolText(value) {
+    return typeof value === 'string';
+}
+function isStructuredPayload(value) {
+    return value !== null && typeof value === 'object';
+}
+const STATUS_META = {
+    pending: { label: 'Pending', variant: 'outline' },
+    awaiting_approval: { label: 'Awaiting approval', variant: 'outline' },
+    running: { label: 'Running', variant: 'outline' },
+    streaming: { label: 'Running', variant: 'outline' },
+    completed: { label: 'Completed', variant: 'secondary' },
+    complete: { label: 'Completed', variant: 'secondary' },
+    failed: { label: 'Failed', variant: 'destructive' },
+    error: { label: 'Failed', variant: 'destructive' },
+    denied: { label: 'Denied', variant: 'destructive' },
+    // Cancellation and a lost host are terminal but not destructive user
+    // failures. Keep them legible without painting the whole history red.
+    cancelled: { label: 'Cancelled', variant: 'secondary' },
+    interrupted: { label: 'Interrupted', variant: 'secondary' },
+    timeout: { label: 'Timed out', variant: 'warning' }
+};
+export function toolStatusMeta(status) {
+    if (!status)
+        return null;
+    return isTableKey(STATUS_META, status) ? STATUS_META[status] : null;
+}
+const TOOL_ICONS = {
+    'web-search': 'lucide:search',
+    web_search: 'lucide:search',
+    search: 'lucide:search',
+    knowledge: 'lucide:book-open',
+    'context7-search': 'lucide:book-marked',
+    'context7-docs': 'lucide:book-marked',
+    'ingest-from-chat': 'lucide:import',
+    calculate: 'lucide:calculator',
+    'workspace-fs': 'lucide:folder',
+    'workspace-search': 'lucide:file-search',
+    'workspace-lsp': 'lucide:braces',
+    'workspace-lock': 'lucide:lock',
+    'workspace-rules': 'lucide:scroll-text',
+    codemod: 'lucide:wand-sparkles',
+    'ai-generate': 'lucide:sparkles',
+    'generate-image': 'lucide:image',
+    'ai-ocr-document': 'lucide:scan-text',
+    fetch: 'lucide:globe',
+    'api-request': 'lucide:globe',
+    'firecrawl-crawl': 'lucide:globe',
+    'firecrawl-scrape': 'lucide:globe',
+    'firecrawl-search': 'lucide:search',
+    reasoning: 'lucide:brain',
+    'agent-execution': 'lucide:bot',
+    'spawn-subagent': 'lucide:bot',
+    'run-command': 'lucide:terminal',
+    'file-read': 'lucide:file-text',
+    'file-write': 'lucide:file-pen-line',
+    git: 'lucide:git-branch',
+    'sandbox-execute': 'lucide:terminal',
+    'execute-code': 'lucide:terminal',
+    'code-execution-submit': 'lucide:terminal',
+    browser: 'lucide:globe',
+    desktop: 'lucide:monitor',
+    email: 'lucide:mail',
+    marshal: 'lucide:compass',
+    presence: 'lucide:sparkle',
+    awareness: 'lucide:radar',
+    'dashboard-stats': 'lucide:chart-line',
+    docs: 'lucide:book',
+    'tool-help': 'lucide:circle-help',
+    session: 'lucide:layers',
+    'session-todo': 'lucide:list-checks',
+    'session-scratchpad': 'lucide:notebook-pen',
+    'session-collaborate': 'lucide:users-round',
+    'session-workspace': 'lucide:folder-git-2',
+    'chat-room': 'lucide:messages-square',
+    'workbench-codegen': 'lucide:code'
+};
+export function iconForTool(name) {
+    if (!name)
+        return 'lucide:wrench';
+    return isTableKey(TOOL_ICONS, name) ? TOOL_ICONS[name] : 'lucide:wrench';
+}
+const TOOL_TITLES = {
+    'ai-generate': 'Generate',
+    'generate-image': 'Generate Image',
+    'ai-ocr-document': 'OCR Document',
+    'workspace-fs': 'Workspace Files',
+    'workspace-search': 'Code Search',
+    'workspace-lsp': 'Language Server',
+    'run-command': 'Run Command',
+    'file-read': 'Read File',
+    'file-write': 'Write File',
+    git: 'Git',
+    'sandbox-execute': 'Sandbox',
+    'web-search': 'Web Search',
+    web_search: 'Web Search',
+    'agent-execution': 'Run Agent',
+    'tool-help': 'Tool Help',
+    'dashboard-stats': 'Dashboard Stats',
+    'context7-search': 'Context7',
+    'context7-docs': 'Context7 Docs',
+    // Dotted runtime tool ids. Without these a card reads as its internal
+    // identifier — a millwork estimator was shown "Casework.Sharepoint.LocatebidFolder"
+    // mid-bid. Cards name the WORK, in the words the user would use.
+    'storage.browse': 'Browse Files',
+    'storage.search': 'Find Files',
+    'storage.copy': 'Copy File',
+    'document.read': 'Read Document',
+    'document.view': 'Look at Drawing',
+    'casework.drawings.find': 'Find Drawings',
+    'casework.documents.source': 'Open Drawing',
+    'casework.sharepoint.locateBidFolder': 'Find Bid Folder',
+    'casework.bidIntake.run': 'Set Up Job',
+    'casework.estimate.calculate': 'Price Estimate',
+    'casework.estimate.prepare': 'Save Estimate Draft',
+    'casework.estimate.profile.update': 'Update Shop Rates',
+    'casework.estimate.exportQuickBooks': 'Send to QuickBooks',
+    'casework.job.create': 'Create Job',
+    'casework.job.validate': 'Check Job Readiness',
+    'casework.job.setCustomer': 'Set Customer',
+    'casework.customers.search': 'Find Customer',
+    'casework.ask': 'Question for You',
+    'quickbooks.items.search': 'Find Catalog Item'
+};
+export function humanizeToolName(name) {
+    if (!name)
+        return 'Tool';
+    // Dotted runtime ids (`casework.sharepoint.locateBidFolder`) used to come out as
+    // "Casework.Sharepoint.LocatebidFolder" — the dots survived and camelCase was
+    // flattened. Drop the owning namespace, split camelCase, and title-case, so an
+    // unmapped tool still reads as words rather than as an identifier.
+    const segments = name.split('.').filter(Boolean);
+    const meaningful = segments.length > 2 ? segments.slice(1) : segments;
+    return meaningful
+        .join(' ')
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/[-_]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+export function titleForTool(name) {
+    return isTableKey(TOOL_TITLES, name) ? TOOL_TITLES[name] : humanizeToolName(name);
+}
+export function formatToolData(value) {
+    if (value === undefined || value === null)
+        return '';
+    if (isToolText(value))
+        return value;
+    const serialized = settleNow(() => JSON.stringify(value, null, 2));
+    if (serialized.ok)
+        return serialized.value ?? '';
+    logger.warn('Tool data serialization failed', { reason: failureClass(serialized.error) });
+    return 'Tool data could not be displayed.';
+}
+/** Language for the default card's CodeViewer. Objects/arrays and JSON strings use json. */
+export function toolBlobLanguage(raw, value) {
+    if (isStructuredPayload(value))
+        return 'json';
+    const trimmed = raw.trim();
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+        (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        return 'json';
+    }
+    return 'plaintext';
+}
+/**
+ * True when the output blob would only echo the failure the ToolCard chrome
+ * already shows: the agent loop's `{ok:false, error}` envelope with the same
+ * message. Callers skip the redundant blob (the input blob stays — it shows
+ * what was attempted).
+ */
+export function isRedundantFailureOutput(output, error) {
+    if (!error)
+        return false;
+    const envelope = ToolFailureEnvelope.safeParse(output);
+    return envelope.success && envelope.data.error === error;
+}
+export function approvalCopy(tool) {
+    const approval = tool.approval;
+    if (!approval)
+        return null;
+    if (approval.decision === 'denied') {
+        return approval.reason ? `Approval denied: ${approval.reason}` : 'Approval denied';
+    }
+    if (approval.decision === 'timeout')
+        return 'Approval request timed out';
+    if (approval.decision === 'approved')
+        return 'Approved';
+    if (approval.required && (!approval.decision || approval.decision === 'pending')) {
+        return 'Awaiting approval';
+    }
+    return null;
+}
+export function formatDuration(durationMs) {
+    if (durationMs === undefined || durationMs <= 0)
+        return '';
+    if (durationMs < 1000)
+        return `${Math.round(durationMs)}ms`;
+    return `${Math.round(durationMs / 100) / 10}s`;
+}
+/**
+ * Render model for the tool card's evaluation line.
+ *
+ * `absent` (and missing) evaluation yields null: the card is the
+ * deterministic tool. Everything else renders the producer's summary
+ * plus its scorecard chips; `degraded` flags the amber treatment.
+ */
+export function toolEvaluationLine(evaluation) {
+    if (!evaluation || evaluation.status === 'absent')
+        return null;
+    return {
+        summary: evaluation.summary,
+        chips: evaluation.chips ?? [],
+        degraded: evaluation.status === 'degraded'
+    };
+}

package/dist/lib/components/tool-widgets/tool-widget-context.d.ts

@@ -0,0 +1,14 @@
+import type { ToolWidgetActions } from './types.js';
+/**
+ * Presentation supplied by ToolCallRenderer to the widget mounted beneath it.
+ *
+ * The object stays stable while its getters read live renderer props. This lets
+ * existing widgets keep composing ToolCard without having to forward every
+ * host-owned presentation region through an intermediate component.
+ */
+export interface ToolWidgetPresentation {
+    readonly actions?: ToolWidgetActions;
+}
+export declare function getToolWidgetPresentation(): ToolWidgetPresentation;
+export declare function setToolWidgetPresentation(context: ToolWidgetPresentation): ToolWidgetPresentation;
+export declare function hasToolWidgetPresentation(): boolean;

package/dist/lib/components/tool-widgets/tool-widget-context.js

@@ -0,0 +1,14 @@
+import { getContext, hasContext, setContext } from 'svelte';
+const TOOL_WIDGET_PRESENTATION_KEY = Symbol('tool-widget-presentation');
+export function getToolWidgetPresentation() {
+    if (!hasContext(TOOL_WIDGET_PRESENTATION_KEY)) {
+        throw new Error('ToolWidgetPresentation context has not been set');
+    }
+    return getContext(TOOL_WIDGET_PRESENTATION_KEY);
+}
+export function setToolWidgetPresentation(context) {
+    return setContext(TOOL_WIDGET_PRESENTATION_KEY, context);
+}
+export function hasToolWidgetPresentation() {
+    return hasContext(TOOL_WIDGET_PRESENTATION_KEY);
+}

package/dist/lib/components/tool-widgets/types.d.ts

@@ -0,0 +1,90 @@
+import type { Snippet } from 'svelte';
+/**
+ * Presentational contract for tool-call widgets.
+ *
+ * Intentionally surface- and schema-agnostic: chat, the messenger dock, and
+ * any other consumer map their own tool-call shape onto `ToolCallView` before
+ * handing it to a widget. Keeping vibeskit free of any chat / ai-schema
+ * dependency is what lets the widget layer live in the kit and be reused by
+ * every `-svelte` surface.
+ */
+export type ToolWidgetStatus = 'pending' | 'awaiting_approval' | 'running' | 'completed' | 'failed' | 'denied';
+export interface ToolWidgetApproval {
+    required?: boolean;
+    decision?: 'approved' | 'denied' | 'timeout' | 'pending';
+    reason?: string;
+}
+/** Judge outcome for a tool call that consumed structured evaluation. */
+export type ToolCallEvaluationStatus = 'refined' | 'abstained' | 'absent' | 'degraded';
+/**
+ * Evaluation line for a tool that judged candidates (`evaluate()`).
+ *
+ * Plain view data — no ai-schema dependency (see module contract).
+ * Producers build `summary`/`chips` with the ai-side formatters and
+ * pass the strings through. `absent` renders nothing: the card is the
+ * deterministic tool. `modelId`/`source` name the bound default; null
+ * when no judge spoke.
+ */
+export interface ToolCallEvaluationView {
+    status: ToolCallEvaluationStatus;
+    /** Battery id, e.g. `context.compact`. */
+    batteryId: string;
+    /** Bound judge model id, or null when no judge spoke. */
+    modelId: string | null;
+    /** Calibrated native vs JSON-mode adapted answers. */
+    source: 'native' | 'adapted' | null;
+    /** Preformatted one-line verdict. */
+    summary: string;
+    /** Preformatted scorecard chips for this battery. */
+    chips?: string[];
+}
+export interface ToolCallView {
+    /** Stable id for this call (e.g. the provider `tool_call_id`). */
+    id?: string;
+    /** Canonical tool id, e.g. `web-search`, `ai-generate`. Drives icon/title/widget lookup. */
+    name: string;
+    /** Optional human title override; falls back to a humanized `name`. */
+    title?: string;
+    /** Lifecycle status. Unknown strings render as a neutral state. */
+    status?: ToolWidgetStatus | string;
+    /** Tool arguments. */
+    input?: unknown;
+    /** Tool result. */
+    output?: unknown;
+    /** Error message when the call failed. */
+    error?: string;
+    /** Human-in-the-loop approval state, when the tool is gated. */
+    approval?: ToolWidgetApproval;
+    /** Wall-clock duration, when known. */
+    durationMs?: number;
+    /** ISO timestamp of the last update. */
+    timestamp?: string;
+    /** Structured-evaluation verdict, when the tool judged candidates. */
+    evaluation?: ToolCallEvaluationView;
+}
+/** Host-owned controls rendered in a tool card's header. */
+export type ToolWidgetActions = Snippet<[ToolCallView]>;
+/** A renderer state that needs host- or Kit-owned presentation. */
+export type ToolWidgetFallbackState = {
+    kind: 'unregistered-user';
+} | {
+    kind: 'first-party-missing';
+} | {
+    kind: 'loading';
+} | {
+    kind: 'load-failed';
+    error: unknown;
+};
+/** Infrastructure states rendered by ToolWidgetStateCard. */
+export type ToolWidgetInfrastructureState = Exclude<ToolWidgetFallbackState, {
+    kind: 'unregistered-user';
+}>;
+/** Host-owned fallback content for an unresolved or failed widget import. */
+export type ToolWidgetFallback = Snippet<[ToolCallView, ToolWidgetFallbackState]>;
+export interface ToolWidgetProps {
+    tool: ToolCallView;
+    /** Dense layout for tight surfaces (dock, compact chat). */
+    compact?: boolean;
+    /** Optional host controls (for example, cancel or retry) rendered by the widget's card shell. */
+    actions?: ToolWidgetActions;
+}

package/dist/lib/components/tool-widgets/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/components/ui/accordion/accordion-content.svelte

@@ -0,0 +1,15 @@
+<script lang="ts">import { Accordion as AccordionPrimitive } from "bits-ui";
+import { cn } from "../../../utils.js";
+let { ref = $bindable(null), class: className, children, ...restProps } = $props();
+</script>
+
+<AccordionPrimitive.Content
+	bind:ref
+	data-slot="accordion-content"
+	class="overflow-hidden text-sm data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down"
+	{...restProps}
+>
+	<div class={cn('pt-0 pb-4', className)}>
+		{@render children?.()}
+	</div>
+</AccordionPrimitive.Content>

package/dist/lib/components/ui/accordion/accordion-content.svelte.d.ts

@@ -0,0 +1,4 @@
+import { Accordion as AccordionPrimitive } from 'bits-ui';
+declare const AccordionContent: import("svelte").Component<Omit<AccordionPrimitive.ContentProps, "child">, {}, "ref">;
+type AccordionContent = ReturnType<typeof AccordionContent>;
+export default AccordionContent;

package/dist/lib/components/ui/accordion/accordion-item.svelte

@@ -0,0 +1,11 @@
+<script lang="ts">import { Accordion as AccordionPrimitive } from "bits-ui";
+import { cn } from "../../../utils.js";
+let { ref = $bindable(null), class: className, ...restProps } = $props();
+</script>
+
+<AccordionPrimitive.Item
+	bind:ref
+	data-slot="accordion-item"
+	class={cn('border-b last:border-b-0', className)}
+	{...restProps}
+/>

package/dist/lib/components/ui/accordion/accordion-item.svelte.d.ts

@@ -0,0 +1,4 @@
+import { Accordion as AccordionPrimitive } from 'bits-ui';
+declare const AccordionItem: import("svelte").Component<AccordionPrimitive.ItemProps, {}, "ref">;
+type AccordionItem = ReturnType<typeof AccordionItem>;
+export default AccordionItem;

package/dist/lib/components/ui/accordion/accordion-trigger.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">import { Accordion as AccordionPrimitive } from "bits-ui";
+import { Icon } from "../../icon";
+import { cn } from "../../../utils.js";
+let { ref = $bindable(null), class: className, level = 3, children, ...restProps } = $props();
+</script>
+
+<AccordionPrimitive.Header {level} class="flex">
+	<AccordionPrimitive.Trigger
+		data-slot="accordion-trigger"
+		bind:ref
+		class={cn(
+			'flex flex-1 items-start justify-between gap-4 rounded-md py-4 text-start text-sm font-medium transition-all outline-none hover:underline focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 [&[data-state=open]>svg]:rotate-180',
+			className
+		)}
+		{...restProps}
+	>
+		{@render children?.()}
+		<Icon
+			icon="lucide:chevron-down"
+			class="pointer-events-none size-4 shrink-0 translate-y-0.5 text-muted-foreground transition-transform duration-200"
+		/>
+	</AccordionPrimitive.Trigger>
+</AccordionPrimitive.Header>

package/dist/lib/components/ui/accordion/accordion-trigger.svelte.d.ts

@@ -0,0 +1,8 @@
+import { Accordion as AccordionPrimitive } from 'bits-ui';
+import { type WithoutChild } from '../../../utils.js';
+type $$ComponentProps = WithoutChild<AccordionPrimitive.TriggerProps> & {
+    level?: AccordionPrimitive.HeaderProps['level'];
+};
+declare const AccordionTrigger: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type AccordionTrigger = ReturnType<typeof AccordionTrigger>;
+export default AccordionTrigger;

package/dist/lib/components/ui/accordion/accordion.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">import { Accordion as AccordionPrimitive } from "bits-ui";
+let { ref = $bindable(null), type = "single", value = $bindable(), onValueChange, ...restProps } = $props();
+</script>
+
+{#if type === 'multiple'}
+	<AccordionPrimitive.Root
+		bind:ref
+		type="multiple"
+		bind:value={value as AccordionMultipleProps['value']}
+		onValueChange={onValueChange as AccordionMultipleProps['onValueChange']}
+		data-slot="accordion"
+		{...restProps}
+	/>
+{:else}
+	<AccordionPrimitive.Root
+		bind:ref
+		type="single"
+		bind:value={value as AccordionSingleProps['value']}
+		onValueChange={onValueChange as AccordionSingleProps['onValueChange']}
+		data-slot="accordion"
+		{...restProps}
+	/>
+{/if}

package/dist/lib/components/ui/accordion/accordion.svelte.d.ts

@@ -0,0 +1,16 @@
+import { Accordion as AccordionPrimitive } from 'bits-ui';
+import type { WithoutChild } from '../../../utils.js';
+type AccordionSingleProps = Omit<WithoutChild<Extract<AccordionPrimitive.RootProps, {
+    type: 'single';
+}>>, 'type'> & {
+    type?: 'single';
+};
+type AccordionMultipleProps = Omit<WithoutChild<Extract<AccordionPrimitive.RootProps, {
+    type: 'multiple';
+}>>, 'type'> & {
+    type?: 'multiple';
+};
+type AccordionProps = AccordionSingleProps | AccordionMultipleProps;
+declare const Accordion: import("svelte").Component<AccordionProps, {}, "value" | "ref">;
+type Accordion = ReturnType<typeof Accordion>;
+export default Accordion;

package/dist/lib/components/ui/accordion/index.d.ts

@@ -0,0 +1,5 @@
+import Root from './accordion.svelte';
+import Content from './accordion-content.svelte';
+import Item from './accordion-item.svelte';
+import Trigger from './accordion-trigger.svelte';
+export { Root, Content, Item, Trigger, Root as Accordion, Content as AccordionContent, Item as AccordionItem, Trigger as AccordionTrigger };

package/dist/lib/components/ui/accordion/index.js

@@ -0,0 +1,7 @@
+import Root from './accordion.svelte';
+import Content from './accordion-content.svelte';
+import Item from './accordion-item.svelte';
+import Trigger from './accordion-trigger.svelte';
+export { Root, Content, Item, Trigger, 
+//
+Root as Accordion, Content as AccordionContent, Item as AccordionItem, Trigger as AccordionTrigger };

package/dist/lib/components/ui/alert/alert-description.svelte

@@ -0,0 +1,15 @@
+<script lang="ts">import { cn } from "../../../utils.js";
+let { ref = $bindable(null), class: className, children, ...restProps } = $props();
+</script>
+
+<div
+	bind:this={ref}
+	data-slot="alert-description"
+	class={cn(
+		'col-start-2 grid justify-items-start gap-1 text-sm text-muted-foreground [&_p]:leading-relaxed',
+		className
+	)}
+	{...restProps}
+>
+	{@render children?.()}
+</div>

package/dist/lib/components/ui/alert/alert-description.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { HTMLAttributes } from 'svelte/elements';
+import { type WithElementRef } from '../../../utils.js';
+declare const AlertDescription: import("svelte").Component<WithElementRef<HTMLAttributes<HTMLDivElement>>, {}, "ref">;
+type AlertDescription = ReturnType<typeof AlertDescription>;
+export default AlertDescription;

package/dist/lib/components/ui/alert/alert-title.svelte

@@ -0,0 +1,12 @@
+<script lang="ts">import { cn } from "../../../utils.js";
+let { ref = $bindable(null), class: className, children, ...restProps } = $props();
+</script>
+
+<div
+	bind:this={ref}
+	data-slot="alert-title"
+	class={cn('col-start-2 line-clamp-1 min-h-4 font-medium tracking-tight', className)}
+	{...restProps}
+>
+	{@render children?.()}
+</div>

package/dist/lib/components/ui/alert/alert-title.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { HTMLAttributes } from 'svelte/elements';
+import { type WithElementRef } from '../../../utils.js';
+declare const AlertTitle: import("svelte").Component<WithElementRef<HTMLAttributes<HTMLDivElement>>, {}, "ref">;
+type AlertTitle = ReturnType<typeof AlertTitle>;
+export default AlertTitle;

package/dist/lib/components/ui/alert/alert.svelte

@@ -0,0 +1,14 @@
+<script lang="ts">import { cn } from "../../../utils.js";
+import { alertVariants } from "./alert.variants.js";
+let { ref = $bindable(null), class: className, variant = "default", role = "alert", children, ...restProps } = $props();
+</script>
+
+<div
+	bind:this={ref}
+	data-slot="alert"
+	class={cn(alertVariants({ variant }), className)}
+	{role}
+	{...restProps}
+>
+	{@render children?.()}
+</div>

package/dist/lib/components/ui/alert/alert.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { HTMLAttributes } from 'svelte/elements';
+import { type WithElementRef } from '../../../utils.js';
+import { type AlertVariant } from './alert.variants.ts';
+type $$ComponentProps = WithElementRef<HTMLAttributes<HTMLDivElement>> & {
+    variant?: AlertVariant;
+};
+declare const Alert: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type Alert = ReturnType<typeof Alert>;
+export default Alert;

package/dist/lib/components/ui/alert/alert.variants.d.ts

@@ -0,0 +1,21 @@
+import { type VariantProps } from 'tailwind-variants';
+export declare const alertVariants: import("tailwind-variants").TVReturnType<{
+    variant: {
+        default: "bg-card text-card-foreground";
+        destructive: "text-destructive bg-card *:data-[slot=alert-description]:text-destructive/90 [&>svg]:text-current";
+        warning: "text-warning border-warning/40 bg-warning/10 *:data-[slot=alert-description]:text-warning/90 [&>svg]:text-current";
+    };
+}, undefined, "relative grid w-full grid-cols-[0_1fr] items-start gap-y-0.5 rounded-lg border px-4 py-3 text-sm has-[>svg]:grid-cols-[calc(var(--spacing)*4)_1fr] has-[>svg]:gap-x-3 [&>svg]:size-4 [&>svg]:translate-y-0.5 [&>svg]:text-current", {
+    variant: {
+        default: "bg-card text-card-foreground";
+        destructive: "text-destructive bg-card *:data-[slot=alert-description]:text-destructive/90 [&>svg]:text-current";
+        warning: "text-warning border-warning/40 bg-warning/10 *:data-[slot=alert-description]:text-warning/90 [&>svg]:text-current";
+    };
+}, undefined, import("tailwind-variants").TVReturnTypeLike<{
+    variant: {
+        default: "bg-card text-card-foreground";
+        destructive: "text-destructive bg-card *:data-[slot=alert-description]:text-destructive/90 [&>svg]:text-current";
+        warning: "text-warning border-warning/40 bg-warning/10 *:data-[slot=alert-description]:text-warning/90 [&>svg]:text-current";
+    };
+}, undefined>>;
+export type AlertVariant = VariantProps<typeof alertVariants>['variant'];

package/dist/lib/components/ui/alert/alert.variants.js

@@ -0,0 +1,14 @@
+import { tv } from 'tailwind-variants';
+export const alertVariants = tv({
+    base: 'relative grid w-full grid-cols-[0_1fr] items-start gap-y-0.5 rounded-lg border px-4 py-3 text-sm has-[>svg]:grid-cols-[calc(var(--spacing)*4)_1fr] has-[>svg]:gap-x-3 [&>svg]:size-4 [&>svg]:translate-y-0.5 [&>svg]:text-current',
+    variants: {
+        variant: {
+            default: 'bg-card text-card-foreground',
+            destructive: 'text-destructive bg-card *:data-[slot=alert-description]:text-destructive/90 [&>svg]:text-current',
+            warning: 'text-warning border-warning/40 bg-warning/10 *:data-[slot=alert-description]:text-warning/90 [&>svg]:text-current'
+        }
+    },
+    defaultVariants: {
+        variant: 'default'
+    }
+});

package/dist/lib/components/ui/alert/index.d.ts

@@ -0,0 +1,18 @@
+import Root from './alert.svelte';
+import Description from './alert-description.svelte';
+import Title from './alert-title.svelte';
+export { alertVariants, type AlertVariant } from './alert.variants.ts';
+declare const Alert: import("svelte").Component<import("svelte/elements").HTMLAttributes<HTMLDivElement> & {
+    ref?: HTMLElement | null | undefined;
+} & {
+    variant?: import("./alert.variants.ts").AlertVariant;
+}, {}, "ref"> & {
+    Root: import("svelte").Component<import("svelte/elements").HTMLAttributes<HTMLDivElement> & {
+        ref?: HTMLElement | null | undefined;
+    } & {
+        variant?: import("./alert.variants.ts").AlertVariant;
+    }, {}, "ref">;
+    Description: import("svelte").Component<import("../../../utils.ts").WithElementRef<import("svelte/elements").HTMLAttributes<HTMLDivElement>>, {}, "ref">;
+    Title: import("svelte").Component<import("../../../utils.ts").WithElementRef<import("svelte/elements").HTMLAttributes<HTMLDivElement>>, {}, "ref">;
+};
+export { Root, Description, Title, Alert, Description as AlertDescription, Title as AlertTitle };

package/dist/lib/components/ui/alert/index.js

@@ -0,0 +1,13 @@
+import Root from './alert.svelte';
+import Description from './alert-description.svelte';
+import Title from './alert-title.svelte';
+export { alertVariants } from "./alert.variants.js";
+// Dual export: <Alert> renders Root, <Alert.Title> accesses the namespace.
+const Alert = Object.assign(Root, {
+    Root,
+    Description,
+    Title
+});
+export { Root, Description, Title, Alert, 
+//
+Description as AlertDescription, Title as AlertTitle };

package/dist/lib/components/ui/alert-dialog/alert-dialog-action.svelte

@@ -0,0 +1,12 @@
+<script lang="ts">import { AlertDialog as AlertDialogPrimitive } from "bits-ui";
+import { buttonVariants } from "../button/index.js";
+import { cn } from "../../../utils.js";
+let { ref = $bindable(null), class: className, ...restProps } = $props();
+</script>
+
+<AlertDialogPrimitive.Action
+	bind:ref
+	data-slot="alert-dialog-action"
+	class={cn(buttonVariants(), className)}
+	{...restProps}
+/>

package/dist/lib/components/ui/alert-dialog/alert-dialog-action.svelte.d.ts

@@ -0,0 +1,4 @@
+import { AlertDialog as AlertDialogPrimitive } from 'bits-ui';
+declare const AlertDialogAction: import("svelte").Component<AlertDialogPrimitive.TriggerProps, {}, "ref">;
+type AlertDialogAction = ReturnType<typeof AlertDialogAction>;
+export default AlertDialogAction;