@vibesdotdev/chat 0.0.0-stage → 1.0.0-rc.1

package/dist/svelte/tool-widgets.js

@@ -0,0 +1,92 @@
+/**
+ * Chat-owned tool-card admission. Explicit runtime consumers resolve eligible
+ * tools/ui descriptors through their own resolver. Compatibility helpers also resolve against the handed runtime.
+ */
+import * as z from 'zod/v4';
+import { hasToolWidget, isUserAuthoredTool } from '@vibesdotdev/kit/components/tool-widgets';
+const TOOLS_SVELTE_PLUGIN_ID = 'tools-svelte';
+const CHAT_SVELTE_PLUGIN_ID = '@vibesdotdev/chat/svelte';
+export function canonicalToolWidgetId(name) {
+    if (name.toLowerCase() === 'docs')
+        return 'docs';
+    if (name === 'run_command')
+        return 'run-command';
+    if (name === 'web_search')
+        return 'web-search';
+    if (name.includes('.') || !name.includes('_'))
+        return name;
+    return name.replaceAll('_', '-');
+}
+export function toolWidgetAliasIds(id) {
+    const canonical = canonicalToolWidgetId(id);
+    const ids = [id, canonical];
+    if (canonical.includes('-') && !canonical.includes('.')) {
+        ids.push(canonical.replaceAll('-', '_'));
+    }
+    return [...new Set(ids.filter((value) => value.length > 0))];
+}
+export function withCanonicalToolWidgetNames(tools) {
+    return tools.map((tool) => {
+        const name = canonicalToolWidgetId(tool.name);
+        return name === tool.name ? tool : { ...tool, name };
+    });
+}
+export function chatToolWidgetKind(name, resolver) {
+    const id = canonicalToolWidgetId(name);
+    if (hasToolWidget(id, resolver))
+        return 'registered';
+    if (isUserAuthoredTool(id))
+        return 'user';
+    return 'first-party-missing';
+}
+export const toolWidgetComponentSchema = z.custom((v) => v instanceof Function);
+export const toolUiResolvedSchema = z.looseObject({
+    component: toolWidgetComponentSchema.optional(),
+    web: z
+        .looseObject({
+        component: toolWidgetComponentSchema.optional()
+    })
+        .optional(),
+    impl: z
+        .looseObject({
+        component: toolWidgetComponentSchema.optional(),
+        web: z
+            .looseObject({
+            component: toolWidgetComponentSchema.optional()
+        })
+            .optional()
+    })
+        .optional(),
+    implementation: z
+        .looseObject({
+        component: toolWidgetComponentSchema.optional(),
+        web: z
+            .looseObject({
+            component: toolWidgetComponentSchema.optional()
+        })
+            .optional()
+    })
+        .optional()
+});
+async function registerToolsSveltePlugin(runtime) {
+    if (!runtime.hasPlugin(CHAT_SVELTE_PLUGIN_ID))
+        return;
+    if (!runtime.hasPlugin('tools')) {
+        const { default: toolsBrowserPlugin } = await import('@vibesdotdev/tools/browser.plugin');
+        await runtime.registerPlugin(toolsBrowserPlugin);
+    }
+    if (runtime.hasPlugin(TOOLS_SVELTE_PLUGIN_ID))
+        return;
+    if (!runtime.hasKind('tools/ui'))
+        return;
+    const { default: toolsSveltePlugin } = await import('@vibesdotdev/tools/svelte/plugin');
+    await runtime.registerPlugin(toolsSveltePlugin);
+}
+/** Compose widget descriptors on the handed runtime; rendering resolves tools/ui directly. */
+export async function ensureChatToolWidgetsRegistered(runtime) {
+    await registerToolsSveltePlugin(runtime);
+}
+/** Compatibility entrypoint: return a resolver bound to this runtime, without copying inventory. */
+export { createRuntimeToolWidgetResolver as hydrateToolWidgetsFromRuntime } from "./runtime-tool-widgets.js";
+/** Retained for callers that used to clear the import cache; no Chat widget cache remains. */
+export function resetChatToolWidgetsForTests() { }

package/dist/svelte/tools/ManageRoomToolsDialog.svelte

@@ -0,0 +1,171 @@
+<script lang="ts">
+	import * as Dialog from '@vibesdotdev/kit/components/ui/dialog';
+	import { Button } from '@vibesdotdev/kit/components/ui/button';
+	import { Icon } from '@vibesdotdev/kit/components/icon';
+	import { Spinner } from '@vibesdotdev/kit/components/ui/spinner';
+	import { getVibesChatClient } from '@vibesdotdev/chat/client';
+	import { getRuntimeSvelteContext } from '@vibesdotdev/surface-sveltekit/svelte/state';
+	import ToolPolicyToggles from '@vibesdotdev/tools/svelte/ToolPolicyToggles.svelte';
+	import type { ToolSummary } from '@vibesdotdev/tools/ui/svelte-views';
+	import * as z from 'zod/v4';
+	import { resolveToolCatalog } from '@vibesdotdev/tools/svelte/runtime';
+	import { settleSurfaceWork, type SurfaceRefusal } from './surface-outcome.js';
+	import {
+		applyRoomToolOverride,
+		emptyRoomToolPolicy,
+		nextRoomMetadataWithToolPolicy,
+		readRoomToolPolicy,
+		toolOverridesFromPolicy,
+		type RoomToolPolicy
+	} from './manage-room-tools-policy.js';
+
+	// Failures show these fixed lines, never the failure's own text (see surface-outcome.ts).
+	const LOAD_REFUSAL: SurfaceRefusal = {
+		message: 'Failed to load tools configuration',
+		reason: 'room-tools-load-failed'
+	};
+	const SAVE_REFUSAL: SurfaceRefusal = {
+		message: 'Failed to update AI action',
+		reason: 'room-tools-save-failed'
+	};
+	const ROOM_MISSING_MESSAGE = 'This conversation could not be loaded.';
+
+	const OpenEventDetailSchema = z.record(z.string(), z.unknown());
+	type OpenEventDetail = z.infer<typeof OpenEventDetailSchema>;
+
+	let {
+		open = $bindable(false),
+		roomId = null,
+		eventDetail = undefined,
+		onNotice = (_message: string) => {},
+		onError = (_message: string) => {}
+	}: {
+		open?: boolean;
+		roomId?: string | null;
+		eventDetail?: OpenEventDetail;
+		onNotice?: (message: string) => void;
+		onError?: (message: string) => void;
+	} = $props();
+
+	const runtimeStore = getRuntimeSvelteContext();
+
+	let loading = $state(false);
+	let tools = $state<ToolSummary[]>([]);
+	let policy = $state<RoomToolPolicy>(emptyRoomToolPolicy(''));
+	let savingToolId = $state<string | null>(null);
+
+	const eventRoomId = $derived.by(() => {
+		const parsed = z.string().trim().min(1).safeParse(eventDetail?.roomId);
+		return parsed.success ? parsed.data : null;
+	});
+	const resolvedRoomId = $derived(roomId?.trim() || eventRoomId);
+	const toolIds = $derived(tools.map((tool) => tool.id));
+	const overrides = $derived(toolOverridesFromPolicy(policy, toolIds));
+
+	async function openRoom(targetRoomId: string) {
+		const chat = await getVibesChatClient(await runtimeStore.load());
+		await chat.load();
+		return chat.rooms.get(targetRoomId);
+	}
+
+	async function readToolsAndRoom(targetRoomId: string) {
+		const catalog = await resolveToolCatalog(await runtimeStore.load());
+		const room = await openRoom(targetRoomId);
+		return { tools: catalog.tools.filter((tool) => tool.isActive !== false), room };
+	}
+
+	async function loadToolsAndPolicy(targetRoomId: string) {
+		loading = true;
+		try {
+			const settled = await settleSurfaceWork(() => readToolsAndRoom(targetRoomId), LOAD_REFUSAL);
+			const room = settled.value?.room;
+			if (settled.value && room) {
+				tools = settled.value.tools;
+				policy = readRoomToolPolicy(room.data);
+				return;
+			}
+			tools = [];
+			policy = emptyRoomToolPolicy(targetRoomId);
+			onError(settled.failed ? settled.failed.message : ROOM_MISSING_MESSAGE);
+		} finally {
+			loading = false;
+		}
+	}
+
+	/** Save the next policy on the room; false when the room is gone. */
+	async function saveRoomPolicy(targetRoomId: string, nextPolicy: RoomToolPolicy): Promise<boolean> {
+		const room = await openRoom(targetRoomId);
+		if (!room) return false;
+		await room.save({ metadata: nextRoomMetadataWithToolPolicy(room.data.metadata, nextPolicy) });
+		return true;
+	}
+
+	async function toggleTool(toolId: string, enabled: boolean) {
+		const targetRoomId = resolvedRoomId;
+		if (!targetRoomId) return;
+		savingToolId = toolId;
+		const nextPolicy = { ...applyRoomToolOverride(policy, toolId, enabled), roomId: targetRoomId };
+		try {
+			const settled = await settleSurfaceWork(
+				() => saveRoomPolicy(targetRoomId, nextPolicy),
+				SAVE_REFUSAL
+			);
+			if (settled.value) {
+				policy = nextPolicy;
+				onNotice(enabled ? 'AI action enabled' : 'AI action disabled');
+				return;
+			}
+			onError(settled.failed ? settled.failed.message : ROOM_MISSING_MESSAGE);
+		} finally {
+			savingToolId = null;
+		}
+	}
+
+	$effect(() => {
+		if (!open || !resolvedRoomId) return;
+		void loadToolsAndPolicy(resolvedRoomId);
+	});
+</script>
+
+<Dialog.Root bind:open>
+	<Dialog.Content class="max-w-xl">
+		<Dialog.Header>
+			<Dialog.Title class="flex items-center gap-2 font-semibold">
+				<Icon icon="lucide:shield-alert" class="text-primary h-5 w-5" />
+				Manage AI actions
+			</Dialog.Title>
+			<Dialog.Description>
+				Choose which actions AI teammates can use in this conversation.
+			</Dialog.Description>
+		</Dialog.Header>
+
+		<div class="space-y-4">
+			{#if !resolvedRoomId}
+				<div class="py-12 text-center text-sm text-muted-foreground">
+					AI actions can be managed after the conversation starts.
+				</div>
+			{:else if loading}
+				<div class="flex items-center justify-center py-12">
+					<Spinner class="text-muted-foreground size-6" />
+				</div>
+			{:else if tools.length === 0}
+				<div class="py-12 text-center text-sm text-muted-foreground">
+					No AI actions are available yet.
+				</div>
+			{:else}
+				<div class="max-h-[350px] overflow-y-auto pr-1">
+					<ToolPolicyToggles
+						{tools}
+						{overrides}
+						loadingToolId={savingToolId}
+						onToggle={toggleTool}
+					/>
+				</div>
+			{/if}
+		</div>
+
+		<Dialog.Footer>
+			<Button variant="outline" onclick={() => (open = false)}>Close</Button>
+		</Dialog.Footer>
+	</Dialog.Content>
+</Dialog.Root>

package/dist/svelte/tools/ManageRoomToolsDialog.svelte.d.ts

@@ -0,0 +1,10 @@
+declare const ManageRoomToolsDialog: import("svelte").Component<{
+    open?: boolean;
+    roomId?: string | null;
+    eventDetail?: Record<string, unknown>;
+    onNotice?: (message: string) => void;
+    onError?: (message: string) => void;
+}, {}, "open">;
+type ManageRoomToolsDialog = ReturnType<typeof ManageRoomToolsDialog>;
+export default ManageRoomToolsDialog;
+//# sourceMappingURL=ManageRoomToolsDialog.svelte.d.ts.map

package/dist/svelte/tools/ManageRoomToolsDialog.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManageRoomToolsDialog.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/tools/ManageRoomToolsDialog.svelte.ts"],"names":[],"mappings":"AAyLA,QAAA,MAAM,qBAAqB;WAvIlB,OAAO;aACL,MAAM,GAAG,IAAI;;eAEX,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;cAC1B,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;cAmI8B,CAAC;AACpE,KAAK,qBAAqB,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACtE,eAAe,qBAAqB,CAAC"}

package/dist/svelte/tools/descriptors.d.ts

@@ -0,0 +1,65 @@
+export declare const manageToolsDialogWidgetDescriptor: {
+    id: string;
+    kind: "chat/dialog.widget";
+    dialog: string;
+    requiresRoom: boolean;
+    surfaces: string[];
+    name?: string | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    hardware?: string[] | undefined;
+    enabled?: boolean | undefined;
+    priority?: number | undefined;
+    capabilityId?: string | undefined;
+    requiredContext?: string[] | undefined;
+    optionalContext?: string[] | undefined;
+    config?: unknown;
+    retention?: string | {
+        reason: string;
+        maxAgeDays?: number | undefined;
+        maxEntries?: number | undefined;
+        maxBytes?: number | undefined;
+        cascadeFrom?: string | undefined;
+        ageField?: string | undefined;
+        enforcedBy?: string | undefined;
+    } | undefined;
+    actionId?: string | undefined;
+    event?: string | undefined;
+    implementationId?: string | undefined;
+};
+export declare const manageToolsComposerActionDescriptor: {
+    id: string;
+    kind: "chat/composer.action";
+    icon: string;
+    requiresRoom: boolean;
+    requiresAgent: boolean;
+    surfaces: string[];
+    name?: string | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    hardware?: string[] | undefined;
+    enabled?: boolean | undefined;
+    priority?: number | undefined;
+    capabilityId?: string | undefined;
+    requiredContext?: string[] | undefined;
+    optionalContext?: string[] | undefined;
+    config?: unknown;
+    retention?: string | {
+        reason: string;
+        maxAgeDays?: number | undefined;
+        maxEntries?: number | undefined;
+        maxBytes?: number | undefined;
+        cascadeFrom?: string | undefined;
+        ageField?: string | undefined;
+        enforcedBy?: string | undefined;
+    } | undefined;
+    label?: string | undefined;
+    command?: string | undefined;
+    dialog?: string | undefined;
+    widgetId?: string | undefined;
+    event?: string | undefined;
+    insertText?: string | undefined;
+    roomMode?: "standard" | "multi" | undefined;
+};
+export declare const manageToolsDialogWidgetLoader: import("@vibesdotdev/kernel").AssetLoader;
+//# sourceMappingURL=descriptors.d.ts.map

package/dist/svelte/tools/descriptors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptors.d.ts","sourceRoot":"","sources":["../../../src/svelte/tools/descriptors.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS5C,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS9C,CAAC;AAEH,eAAO,MAAM,6BAA6B,2CAIzC,CAAC"}

package/dist/svelte/tools/descriptors.js

@@ -0,0 +1,24 @@
+import { loader } from '@vibesdotdev/kernel';
+import { createChatDialogWidgetDescriptor } from "../dialog-widgets.js";
+import { createChatComposerActionDescriptor } from "../composer-actions.js";
+export const manageToolsDialogWidgetDescriptor = createChatDialogWidgetDescriptor({
+    id: 'tools.chat.dialog.manage-room',
+    name: 'Manage AI actions dialog',
+    description: 'Dialog widget for managing room-scoped tool policy from chat',
+    dialog: 'tools',
+    actionId: 'tools.manage-room',
+    event: 'chat:open-tools',
+    requiresRoom: true,
+    priority: 50
+});
+export const manageToolsComposerActionDescriptor = createChatComposerActionDescriptor({
+    id: 'tools.manage-room',
+    name: 'Manage AI actions',
+    description: 'Choose which tools are available in this conversation',
+    icon: 'lucide:sliders-horizontal',
+    command: 'tools',
+    dialog: 'tools',
+    widgetId: manageToolsDialogWidgetDescriptor.id,
+    priority: 50
+});
+export const manageToolsDialogWidgetLoader = loader(manageToolsDialogWidgetDescriptor.id, { kind: 'chat/dialog.widget', scope: 'browser' }, () => import('./ManageRoomToolsDialog.svelte'));

package/dist/svelte/tools/manage-room-tools-policy.d.ts

@@ -0,0 +1,26 @@
+/** Room-scoped tool policy stored on chat room metadata. */
+import * as z from 'zod/v4';
+export declare const ROOM_TOOL_POLICY_METADATA_KEY = "toolPolicy";
+/** A chat room's metadata (and a policy's own metadata): free-form JSON fields. */
+declare const RoomMetadataSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type RoomMetadata = z.infer<typeof RoomMetadataSchema>;
+export interface RoomToolPolicy {
+    roomId: string;
+    allowed: string[];
+    denied: string[];
+    requireApproval: string[];
+    metadata?: RoomMetadata;
+}
+export interface RoomToolPolicySource {
+    id: string;
+    metadata?: RoomMetadata | null;
+}
+export declare function emptyRoomToolPolicy(roomId: string): RoomToolPolicy;
+export declare function readRoomToolPolicy(room: RoomToolPolicySource): RoomToolPolicy;
+export declare function toolOverridesFromPolicy(policy: RoomToolPolicy, toolIds: readonly string[]): Record<string, {
+    enabled: boolean;
+}>;
+export declare function applyRoomToolOverride(policy: RoomToolPolicy, toolId: string, enabled: boolean): RoomToolPolicy;
+export declare function nextRoomMetadataWithToolPolicy(metadata: RoomMetadata | null | undefined, policy: RoomToolPolicy): RoomMetadata;
+export {};
+//# sourceMappingURL=manage-room-tools-policy.d.ts.map

package/dist/svelte/tools/manage-room-tools-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manage-room-tools-policy.d.ts","sourceRoot":"","sources":["../../../src/svelte/tools/manage-room-tools-policy.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAE5D,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,eAAO,MAAM,6BAA6B,eAAe,CAAC;AAE1D,mFAAmF;AACnF,QAAA,MAAM,kBAAkB,wCAAoC,CAAC;AAC7D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,MAAM,WAAW,cAAc;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,EAAE,YAAY,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;CAC/B;AAUD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAOlE;AAiBD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,oBAAoB,GAAG,cAAc,CAiC7E;AAED,wBAAgB,uBAAuB,CACtC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,SAAS,MAAM,EAAE,GACxB,MAAM,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAUtC;AAED,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,GACd,cAAc,CAehB;AAED,wBAAgB,8BAA8B,CAC7C,QAAQ,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,EACzC,MAAM,EAAE,cAAc,GACpB,YAAY,CASd"}

package/dist/svelte/tools/manage-room-tools-policy.js

@@ -0,0 +1,96 @@
+/** Room-scoped tool policy stored on chat room metadata. */
+import * as z from 'zod/v4';
+import { settleNow } from '@vibesdotdev/kernel';
+export const ROOM_TOOL_POLICY_METADATA_KEY = 'toolPolicy';
+/** A chat room's metadata (and a policy's own metadata): free-form JSON fields. */
+const RoomMetadataSchema = z.record(z.string(), z.unknown());
+export function emptyRoomToolPolicy(roomId) {
+    return {
+        roomId,
+        allowed: [],
+        denied: [],
+        requireApproval: []
+    };
+}
+const itemSchema = z.string().trim().min(1);
+function parseStringList(val) {
+    const parsed = z.array(z.unknown()).safeParse(val);
+    if (!parsed.success)
+        return [];
+    const result = [];
+    for (const item of parsed.data) {
+        const itemParsed = itemSchema.safeParse(item);
+        if (itemParsed.success)
+            result.push(itemParsed.data);
+    }
+    return result;
+}
+const roomIdSchema = z.string().trim().min(1);
+export function readRoomToolPolicy(room) {
+    const settled = settleNow(() => {
+        const parsedMetadata = RoomMetadataSchema.safeParse(room.metadata);
+        if (!parsedMetadata.success)
+            return emptyRoomToolPolicy(room.id);
+        const raw = parsedMetadata.data[ROOM_TOOL_POLICY_METADATA_KEY];
+        const parsedPolicy = RoomMetadataSchema.safeParse(raw);
+        if (!parsedPolicy.success)
+            return emptyRoomToolPolicy(room.id);
+        const obj = parsedPolicy.data;
+        const roomIdParsed = roomIdSchema.safeParse(obj.roomId);
+        const roomId = roomIdParsed.success ? roomIdParsed.data : room.id;
+        const allowed = parseStringList(obj.allowed);
+        const denied = parseStringList(obj.denied);
+        const requireApproval = parseStringList(obj.requireApproval);
+        let metadata;
+        const parsedInnerMeta = RoomMetadataSchema.safeParse(obj.metadata);
+        if (parsedInnerMeta.success) {
+            metadata = parsedInnerMeta.data;
+        }
+        return {
+            roomId,
+            allowed,
+            denied,
+            requireApproval,
+            metadata
+        };
+    });
+    return settled.ok ? settled.value : emptyRoomToolPolicy(room.id);
+}
+export function toolOverridesFromPolicy(policy, toolIds) {
+    const denied = new Set(policy.denied);
+    const allowed = new Set(policy.allowed);
+    const hasAllowList = policy.allowed.length > 0;
+    return Object.fromEntries(toolIds.map((toolId) => [
+        toolId,
+        { enabled: hasAllowList ? allowed.has(toolId) && !denied.has(toolId) : !denied.has(toolId) }
+    ]));
+}
+export function applyRoomToolOverride(policy, toolId, enabled) {
+    const denied = new Set(policy.denied);
+    const allowed = new Set(policy.allowed);
+    if (enabled) {
+        denied.delete(toolId);
+        if (policy.allowed.length > 0)
+            allowed.add(toolId);
+    }
+    else {
+        denied.add(toolId);
+        allowed.delete(toolId);
+    }
+    return {
+        ...policy,
+        allowed: [...allowed],
+        denied: [...denied]
+    };
+}
+export function nextRoomMetadataWithToolPolicy(metadata, policy) {
+    const stored = {
+        roomId: policy.roomId,
+        allowed: [...policy.allowed],
+        denied: [...policy.denied],
+        requireApproval: [...policy.requireApproval]
+    };
+    if (policy.metadata)
+        stored.metadata = policy.metadata;
+    return { ...metadata, [ROOM_TOOL_POLICY_METADATA_KEY]: stored };
+}

package/dist/svelte/tools/surface-outcome.d.ts

@@ -0,0 +1,21 @@
+import { CapabilityError, type CapabilityErrorCode } from '@vibesdotdev/kernel';
+/** The refusal a failed piece of surface work becomes. */
+export interface SurfaceRefusal {
+    /** The line a surface may show the user; it is the refusal's whole message. */
+    readonly message: string;
+    /** The stable kebab-case reason naming which work failed. */
+    readonly reason: string;
+    /** The taxonomy code; `UNAVAILABLE` when omitted. */
+    readonly code?: CapabilityErrorCode;
+}
+/** How one piece of surface work settled. */
+export type SurfaceSettled<Value> = {
+    readonly value: Value;
+    readonly failed?: undefined;
+} | {
+    readonly value?: undefined;
+    readonly failed: CapabilityError;
+};
+/** Run `work`, settling a rejection (or a throw) into the caller's {@link SurfaceRefusal}. */
+export declare function settleSurfaceWork<Value>(work: () => Promise<Value>, refusal: SurfaceRefusal): Promise<SurfaceSettled<Value>>;
+//# sourceMappingURL=surface-outcome.d.ts.map

package/dist/svelte/tools/surface-outcome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-outcome.d.ts","sourceRoot":"","sources":["../../../src/svelte/tools/surface-outcome.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAuB,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAErG,0DAA0D;AAC1D,MAAM,WAAW,cAAc;IAC9B,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qDAAqD;IACrD,QAAQ,CAAC,IAAI,CAAC,EAAE,mBAAmB,CAAC;CACpC;AAED,6CAA6C;AAC7C,MAAM,MAAM,cAAc,CAAC,KAAK,IAC7B;IAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAA;CAAE,GACtD;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAA;CAAE,CAAC;AAEpE,8FAA8F;AAC9F,wBAAsB,iBAAiB,CAAC,KAAK,EAC5C,IAAI,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,EAC1B,OAAO,EAAE,cAAc,GACrB,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAYhC"}

package/dist/svelte/tools/surface-outcome.js

@@ -0,0 +1,16 @@
+import { CapabilityError, CaughtFailureSchema } from '@vibesdotdev/kernel';
+/** Run `work`, settling a rejection (or a throw) into the caller's {@link SurfaceRefusal}. */
+export async function settleSurfaceWork(work, refusal) {
+    try {
+        return { value: await work() };
+    }
+    catch (error) {
+        const failure = CaughtFailureSchema.parse(error);
+        return {
+            failed: new CapabilityError(refusal.message, refusal.code ?? 'UNAVAILABLE', {
+                reason: refusal.reason,
+                cause: failure
+            })
+        };
+    }
+}

package/dist/svelte/types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared view-types for `@vibesdotdev/chat/svelte`.
+ *
+ * Types here are NOT derived from `chat` zod schemas; they are
+ * presentation-layer view-types specific to components that compose
+ * multiple chat domain entities.
+ */
+import type { UserChatFolder, UnifiedChatRoom } from '@vibesdotdev/chat';
+export interface ChatFolderTreeNode {
+    folder: UserChatFolder;
+    rooms: UnifiedChatRoom[];
+    children: ChatFolderTreeNode[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/svelte/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/svelte/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzE,MAAM,WAAW,kBAAkB;IAClC,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB,QAAQ,EAAE,kBAAkB,EAAE,CAAC;CAC/B"}

package/dist/svelte/types.js

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

package/dist/svelte/ui/ChatMessagesAction.svelte

@@ -0,0 +1,8 @@
+<script lang="ts">
+	import type { ChatMessagesActionProps } from './chat-messages.props.js';
+	import { Button } from '@vibesdotdev/kit/components/ui/button';
+
+	let { value = $bindable(undefined), disabled = false }: ChatMessagesActionProps = $props();
+</script>
+
+<Button type="button" variant="ghost" size="sm" {disabled}>Messages</Button>

package/dist/svelte/ui/ChatMessagesAction.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { ChatMessagesActionProps } from './chat-messages.props.ts';
+declare const ChatMessagesAction: import("svelte").Component<ChatMessagesActionProps, {}, "value">;
+type ChatMessagesAction = ReturnType<typeof ChatMessagesAction>;
+export default ChatMessagesAction;
+//# sourceMappingURL=ChatMessagesAction.svelte.d.ts.map

package/dist/svelte/ui/ChatMessagesAction.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatMessagesAction.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/ui/ChatMessagesAction.svelte.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAcxE,QAAA,MAAM,kBAAkB,kEAAwC,CAAC;AACjE,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAChE,eAAe,kBAAkB,CAAC"}

package/dist/svelte/ui/ChatMessagesBadge.svelte

@@ -0,0 +1,11 @@
+<script lang="ts">
+	import type { ChatMessagesBadgeProps } from './chat-messages.props.js';
+
+	let { value, compact = false, onClick, onClear }: ChatMessagesBadgeProps = $props();
+</script>
+
+{#if value}
+	<span class="inline-flex items-center rounded-full bg-secondary px-2 py-0.5 text-xs" role="status">
+		Messages
+	</span>
+{/if}

package/dist/svelte/ui/ChatMessagesBadge.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { ChatMessagesBadgeProps } from './chat-messages.props.ts';
+declare const ChatMessagesBadge: import("svelte").Component<ChatMessagesBadgeProps, {}, "">;
+type ChatMessagesBadge = ReturnType<typeof ChatMessagesBadge>;
+export default ChatMessagesBadge;
+//# sourceMappingURL=ChatMessagesBadge.svelte.d.ts.map

package/dist/svelte/ui/ChatMessagesBadge.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatMessagesBadge.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/ui/ChatMessagesBadge.svelte.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAgBvE,QAAA,MAAM,iBAAiB,4DAAwC,CAAC;AAChE,KAAK,iBAAiB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC9D,eAAe,iBAAiB,CAAC"}

package/dist/svelte/ui/ChatMessagesForm.svelte

@@ -0,0 +1,7 @@
+<script lang="ts">
+	import type { ChatMessagesFormProps } from './chat-messages.props.js';
+
+	let { value = $bindable(undefined), disabled = false }: ChatMessagesFormProps = $props();
+</script>
+
+<div class="text-muted-foreground text-sm">Messages context form (not yet implemented)</div>

package/dist/svelte/ui/ChatMessagesForm.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { ChatMessagesFormProps } from './chat-messages.props.ts';
+declare const ChatMessagesForm: import("svelte").Component<ChatMessagesFormProps, {}, "value">;
+type ChatMessagesForm = ReturnType<typeof ChatMessagesForm>;
+export default ChatMessagesForm;
+//# sourceMappingURL=ChatMessagesForm.svelte.d.ts.map

package/dist/svelte/ui/ChatMessagesForm.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatMessagesForm.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/ui/ChatMessagesForm.svelte.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAYtE,QAAA,MAAM,gBAAgB,gEAAwC,CAAC;AAC/D,KAAK,gBAAgB,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC5D,eAAe,gBAAgB,CAAC"}