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

package/dist/svelte/chat-svelte.vessel.plugin.d.ts

@@ -0,0 +1,311 @@
+import * as z from 'zod/v4';
+export declare const chatWorkspaceVesselStateSchema: z.ZodObject<{
+    roomId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const chatWorkspaceVesselAppDescriptor: {
+    identity: {
+        glyph: string;
+        accent: "blue" | "amber" | "violet" | "teal" | "cyan" | "rose" | "lime" | "azure" | "neutral";
+        artworkId?: string | undefined;
+    };
+    id: string;
+    kind: "vessel/app";
+    name: string;
+    description: string;
+    owner: {
+        packageName: string;
+        entrypoint?: string | undefined;
+        specPath?: string | undefined;
+        runtimeKind?: string | undefined;
+        runtimeId?: string | undefined;
+    };
+    category: "agent" | "service" | "runtime" | "tool" | "settings" | "audit" | "feature" | "app" | "docs";
+    launch: {
+        type: "svelte-component";
+        import: string;
+        exportName?: string | undefined;
+    } | {
+        type: "vessel-surface";
+        surfaceId: string;
+        initialState?: Record<string, string | number | boolean | null> | undefined;
+    } | {
+        type: "sveltekit-route";
+        href: string;
+    } | {
+        type: "runtime-client";
+        clientId: string;
+        view: "default" | "inspector";
+    } | {
+        type: "tui-app";
+        route: string;
+    } | {
+        type: "tool";
+        toolId: string;
+    } | {
+        type: "config-manifest";
+        manifestId: string;
+    } | {
+        type: "docs-topic";
+        topicId: string;
+    } | {
+        type: "runtime-descriptor";
+        kind: string;
+        id: string;
+    } | {
+        type: "platform-component";
+        componentId: string;
+        version: string;
+        props: Record<string, unknown>;
+        origin?: string | undefined;
+    } | {
+        type: "applet-artifact";
+        artifactId: string;
+        browserRuntime: boolean;
+        componentRef?: {
+            id: string;
+            version: string;
+            props: Record<string, unknown>;
+            origin?: string | undefined;
+        } | undefined;
+    } | {
+        type: "external-url";
+        href: string;
+    };
+    availability: {
+        status: "unknown" | "unavailable" | "available" | "degraded";
+        summary: string;
+        lastCheckedAt?: string | undefined;
+    };
+    defaultWindow: {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+        minWidth: number;
+        minHeight: number;
+    };
+    tags: string[];
+    workLocations: ("browser" | "cloud" | "computer" | "vessel")[];
+    readinessAreaIds: string[];
+    setupStepIds: string[];
+    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;
+    ports?: {
+        id: string;
+        label: string;
+        direction: "output" | "input";
+        schema: {
+            mediaType: string;
+            shape: "any" | "event" | "stream" | "text" | "json" | "binary";
+            schemaId?: string | undefined;
+        };
+        multiple: boolean;
+        required: boolean;
+    }[] | undefined;
+};
+export declare const chatWorkspaceVesselReadinessDescriptor: {
+    id: string;
+    kind: "vessel/readiness-area";
+    label: string;
+    userPromise: string;
+    status: "unknown" | "ready" | "blocked" | "planned" | "needs-setup";
+    summary: string;
+    owner: {
+        packageName: string;
+        entrypoint?: string | undefined;
+        specPath?: string | undefined;
+        runtimeKind?: string | undefined;
+        runtimeId?: string | undefined;
+    };
+    targetKinds: string[];
+    evidence: ({
+        type: "runtime-query";
+        kind: string;
+        resultSummary: string;
+        id?: string | undefined;
+    } | {
+        type: "command";
+        cwd: string;
+        command: string;
+        exitCode: number;
+        summary: string;
+    } | {
+        type: "http";
+        method: string;
+        url: string;
+        status: number;
+        summary: string;
+    } | {
+        type: "screenshot";
+        path: string;
+        summary: string;
+        viewport?: string | undefined;
+    } | {
+        type: "source";
+        path: string;
+        summary: string;
+        line?: number | undefined;
+    } | {
+        type: "spec";
+        path: string;
+        summary: string;
+        heading?: string | undefined;
+    })[];
+    linkedFindingIds: string[];
+    upstreamWorkItemIds: string[];
+    proofGate: 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;
+    nextAction?: {
+        label: string;
+        href?: string | undefined;
+        command?: string | undefined;
+    } | undefined;
+};
+export declare const chatWorkspaceVesselSetupDescriptor: {
+    id: string;
+    kind: "vessel/setup-step";
+    areaId: string;
+    order: number;
+    label: string;
+    userAction: string;
+    userResult: string;
+    place: "browser" | "cloud" | "vibes" | "computer" | "vessel";
+    status: "unknown" | "ready" | "blocked" | "planned" | "needs-setup";
+    owner: {
+        packageName: string;
+        entrypoint?: string | undefined;
+        specPath?: string | undefined;
+        runtimeKind?: string | undefined;
+        runtimeId?: string | undefined;
+    };
+    evidence: ({
+        type: "runtime-query";
+        kind: string;
+        resultSummary: string;
+        id?: string | undefined;
+    } | {
+        type: "command";
+        cwd: string;
+        command: string;
+        exitCode: number;
+        summary: string;
+    } | {
+        type: "http";
+        method: string;
+        url: string;
+        status: number;
+        summary: string;
+    } | {
+        type: "screenshot";
+        path: string;
+        summary: string;
+        viewport?: string | undefined;
+    } | {
+        type: "source";
+        path: string;
+        summary: string;
+        line?: number | undefined;
+    } | {
+        type: "spec";
+        path: string;
+        summary: string;
+        heading?: string | undefined;
+    })[];
+    upstreamWorkItemIds: string[];
+    proofGate: 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;
+    nextAction?: {
+        label: string;
+        href?: string | undefined;
+        command?: string | undefined;
+    } | undefined;
+    falsifier?: string | undefined;
+};
+export declare const chatWorkspaceVesselSurfaceDescriptor: {
+    kind: "vessel/surface";
+    id: string;
+    name: string;
+    description: string;
+    label: string;
+    surfaceKind: string;
+    owner: {
+        packageName: string;
+    };
+    contract: {
+        apiVersion: string;
+        stateSchemaId: string;
+        stateSchemaVersion: number;
+        stateSchema: z.ZodObject<{
+            roomId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    };
+    activation: string;
+    execution: string;
+    requiredCapabilities: {
+        id: string;
+        selectorId: string;
+        reason: string;
+    }[];
+    optionalCapabilities: {
+        id: string;
+        selectorId: string;
+        reason: string;
+    }[];
+    primaryAudience: string;
+    secondaryAudiences: string[];
+    technicalLanguagePolicy: string;
+    promotionGate: string;
+};
+export declare const chatSvelteVesselPlugin: import("@vibesdotdev/kernel").RuntimePlugin;
+export default chatSvelteVesselPlugin;
+//# sourceMappingURL=chat-svelte.vessel.plugin.d.ts.map

package/dist/svelte/chat-svelte.vessel.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-svelte.vessel.plugin.d.ts","sourceRoot":"","sources":["../../src/svelte/chat-svelte.vessel.plugin.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAS5B,eAAO,MAAM,8BAA8B;;kBAIjC,CAAC;AAEX,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6C3C,CAAC;AAEH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAajD,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgB7C,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+B/C,CAAC;AAEH,eAAO,MAAM,sBAAsB,6CAqBjC,CAAC;AAEH,eAAe,sBAAsB,CAAC"}

package/dist/svelte/chat-svelte.vessel.plugin.js

@@ -0,0 +1,141 @@
+import { createRuntimeAsset, createRuntimePlugin, loader } from '@vibesdotdev/kernel';
+import { vesselAppDescriptorSchema, vesselReadinessAreaSchema, vesselSetupStepSchema } from '@vibesdotdev/vessel/schemas';
+import * as z from 'zod/v4';
+const chatVesselOwner = {
+    packageName: '@vibesdotdev/chat/svelte',
+    entrypoint: './vessel.plugin',
+    runtimeKind: 'runtime/client',
+    runtimeId: 'chat'
+};
+export const chatWorkspaceVesselStateSchema = z
+    .object({
+    roomId: z.string().min(1).optional()
+})
+    .strict();
+export const chatWorkspaceVesselAppDescriptor = vesselAppDescriptorSchema.parse({
+    kind: 'vessel/app',
+    id: 'workspace.chat',
+    name: 'Chat',
+    description: 'Continue account conversations with AI teammates, tools, and workspace context.',
+    owner: chatVesselOwner,
+    identity: { glyph: 'lucide:message-circle', accent: 'teal' },
+    category: 'agent',
+    launch: {
+        type: 'vessel-surface',
+        surfaceId: 'chat.workspace',
+        initialState: {}
+    },
+    availability: {
+        status: 'unknown',
+        summary: 'Chat checks account conversations and AI catalogs when opened.'
+    },
+    defaultWindow: { x: 224, y: 144, width: 900, height: 650, minWidth: 560, minHeight: 420 },
+    tags: ['chat', 'assistant', 'agents', 'account'],
+    workLocations: ['browser', 'cloud', 'vessel'],
+    readinessAreaIds: ['readiness.chat'],
+    setupStepIds: ['setup.chat.workspace'],
+    ports: [
+        {
+            id: 'in.message',
+            label: 'Message',
+            direction: 'input',
+            schema: { mediaType: 'text/plain', shape: 'text' },
+            multiple: true
+        },
+        {
+            id: 'out.default',
+            label: 'Out',
+            direction: 'output',
+            schema: { mediaType: 'application/json', shape: 'event' },
+            multiple: true
+        },
+        {
+            id: 'out.events',
+            label: 'Events',
+            direction: 'output',
+            schema: { mediaType: 'vessel/event', shape: 'event' },
+            multiple: true
+        }
+    ]
+});
+export const chatWorkspaceVesselReadinessDescriptor = vesselReadinessAreaSchema.parse({
+    kind: 'vessel/readiness-area',
+    id: 'readiness.chat',
+    label: 'Chat',
+    userPromise: 'Continue the same conversations across Vibes',
+    status: 'unknown',
+    summary: 'Chat readiness follows the signed-in account and canonical Chat runtime client.',
+    owner: chatVesselOwner,
+    targetKinds: ['runtime/client', 'chat/mode', 'ai/augment', 'tools/tool'],
+    evidence: [],
+    linkedFindingIds: [],
+    upstreamWorkItemIds: [],
+    proofGate: 'The signed-in account sees the same rooms and AI catalogs as chat.vibes.dev.'
+});
+export const chatWorkspaceVesselSetupDescriptor = vesselSetupStepSchema.parse({
+    kind: 'vessel/setup-step',
+    id: 'setup.chat.workspace',
+    areaId: 'readiness.chat',
+    order: 40,
+    label: 'Open Chat',
+    userAction: 'Open Chat and choose people, AI teammates, models, and conversation settings.',
+    userResult: 'Existing account conversations and runtime-owned AI options are available.',
+    place: 'vessel',
+    status: 'unknown',
+    owner: chatVesselOwner,
+    evidence: [],
+    upstreamWorkItemIds: [],
+    proofGate: 'Real Electron proof shows account rooms, selector options, history, send, and stream.',
+    falsifier: 'Vessel shows a local-only room list, synthetic agents, or a dead composer control.'
+});
+export const chatWorkspaceVesselSurfaceDescriptor = createRuntimeAsset({
+    kind: 'vessel/surface',
+    id: 'chat.workspace',
+    name: 'Chat workspace',
+    description: 'Account-scoped Chat surface backed by the canonical runtime client.',
+    label: 'Chat workspace',
+    surfaceKind: 'component',
+    owner: { packageName: '@vibesdotdev/chat/svelte' },
+    contract: {
+        apiVersion: '1.0.0',
+        stateSchemaId: 'chat.workspace.state',
+        stateSchemaVersion: 1,
+        stateSchema: chatWorkspaceVesselStateSchema
+    },
+    activation: 'on-open',
+    execution: 'host-trusted',
+    requiredCapabilities: [
+        {
+            id: 'runtime/client',
+            selectorId: 'chat',
+            reason: 'List, open, and send messages as the signed-in account.'
+        }
+    ],
+    optionalCapabilities: [
+        { id: 'runtime/client', selectorId: 'ai', reason: 'Enumerate available AI models.' },
+        { id: 'runtime/client', selectorId: 'tools', reason: 'Enumerate configured AI teammates.' }
+    ],
+    primaryAudience: 'workspace-user',
+    secondaryAudiences: ['host-integrator'],
+    technicalLanguagePolicy: 'hide',
+    promotionGate: 'Real signed-in Electron proof matches chat.vibes.dev rooms and catalogs.'
+});
+export const chatSvelteVesselPlugin = createRuntimePlugin({
+    id: '@vibesdotdev/chat/svelte/vessel',
+    name: 'Chat Svelte Vessel Surface',
+    description: 'Owner-declared account Chat contribution for Vessel hosts.',
+    dependencies: ['vessel'],
+    descriptors: [
+        chatWorkspaceVesselAppDescriptor,
+        chatWorkspaceVesselSurfaceDescriptor,
+        chatWorkspaceVesselReadinessDescriptor,
+        chatWorkspaceVesselSetupDescriptor
+    ],
+    loaders: [
+        loader(chatWorkspaceVesselSurfaceDescriptor.id, { kind: 'vessel/surface', scope: 'browser' }, async () => {
+            const module = await import('./components/ChatWorkspace.svelte');
+            return { impl: module.default };
+        })
+    ]
+});
+export default chatSvelteVesselPlugin;

package/dist/svelte/chat-ui-preferences.d.ts

@@ -0,0 +1,22 @@
+import { type VibesRuntime } from '@vibesdotdev/kernel';
+import { type ChatUIPreferences } from '@vibesdotdev/chat/schemas/ui';
+/**
+ * The `user.chat-ui` preferences as the kernel resolves them for the handed
+ * runtime: the config owner's typed client reads the manifest (composition
+ * merged under the stored edit, parsed by the manifest's schema). The
+ * browser contributes no resolver of its own — on a consumer browser
+ * runtime the read resolves through the projection candidate cache to the
+ * daemon's manifest. A host with no config manifests, or no `user.chat-ui`
+ * manifest, stores none.
+ */
+export declare function loadChatUiPreferences(runtime: VibesRuntime): Promise<ChatUIPreferences | null>;
+/**
+ * Load the stored preferences into the UI store, bounded by the runtime's
+ * lifecycle. A slow or failed config read keeps the defaults and reports
+ * the failure on the handed runtime — never silently read as "no stored
+ * preferences".
+ */
+export declare function applyConfiguredChatUiPreferences(runtime: VibesRuntime, options?: {
+    configTimeoutMs?: number;
+}): Promise<void>;
+//# sourceMappingURL=chat-ui-preferences.d.ts.map

package/dist/svelte/chat-ui-preferences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-ui-preferences.d.ts","sourceRoot":"","sources":["../../src/svelte/chat-ui-preferences.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGlF,OAAO,EAA2B,KAAK,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAM/F;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAQpG;AAED;;;;;GAKG;AACH,wBAAsB,gCAAgC,CACrD,OAAO,EAAE,YAAY,EACrB,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,MAAM,CAAA;CAAO,GACxC,OAAO,CAAC,IAAI,CAAC,CAcf"}

package/dist/svelte/chat-ui-preferences.js

@@ -0,0 +1,47 @@
+import { settle, valueFreeFailure } from '@vibesdotdev/kernel';
+import { getLogger } from '@vibesdotdev/logging';
+import { getVibesConfigClient } from '@vibesdotdev/config/client';
+import { ChatUIPreferencesSchema } from '@vibesdotdev/chat/schemas/ui';
+import { CHAT_UI_CONFIG_MANIFEST_ID } from "../config/chat-ui.config.descriptor.js";
+import { getChatSurface } from "./surface-client.svelte.js";
+const CONFIG_TIMEOUT_MS = 750;
+/**
+ * The `user.chat-ui` preferences as the kernel resolves them for the handed
+ * runtime: the config owner's typed client reads the manifest (composition
+ * merged under the stored edit, parsed by the manifest's schema). The
+ * browser contributes no resolver of its own — on a consumer browser
+ * runtime the read resolves through the projection candidate cache to the
+ * daemon's manifest. A host with no config manifests, or no `user.chat-ui`
+ * manifest, stores none.
+ */
+export async function loadChatUiPreferences(runtime) {
+    if (!runtime.hasKind('config/manifest'))
+        return null;
+    const client = await getVibesConfigClient(runtime);
+    const settled = await settle(() => client.read({ id: CHAT_UI_CONFIG_MANIFEST_ID, schema: ChatUIPreferencesSchema }));
+    if (settled.ok)
+        return settled.value;
+    const failure = valueFreeFailure(settled.cause);
+    if (failure.code === 'NOT_FOUND')
+        return null;
+    throw settled.cause;
+}
+/**
+ * Load the stored preferences into the UI store, bounded by the runtime's
+ * lifecycle. A slow or failed config read keeps the defaults and reports
+ * the failure on the handed runtime — never silently read as "no stored
+ * preferences".
+ */
+export async function applyConfiguredChatUiPreferences(runtime, options = {}) {
+    const settled = await settle(() => runtime.lifecycle.wait(() => loadChatUiPreferences(runtime), {
+        timeoutMs: options.configTimeoutMs ?? CONFIG_TIMEOUT_MS,
+        reason: 'chat-ui-config'
+    }));
+    if (settled.ok) {
+        getChatSurface(runtime).sync.applyUiPreferences(settled.value);
+        return;
+    }
+    getLogger('chat:ui-preferences', runtime).warn('configured chat ui preferences unavailable; keeping interface defaults', {
+        error: valueFreeFailure(settled.cause)
+    });
+}

package/dist/svelte/chat-views.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedChatExperience } from '../schemas/chat-experience.ts';
+import type { ChatViewDescriptor } from '../schemas/chat-view.ts';
+/**
+ * Resolve the views a web host can truthfully present.
+ *
+ * A configured id alone is not enough: the runtime must describe the view and
+ * the host must supply a renderer. This keeps staged rollouts from exposing
+ * placeholder tabs that look like implemented product capability.
+ */
+export declare function resolveRenderableChatViews(experience: ResolvedChatExperience, descriptors: readonly ChatViewDescriptor[], rendererIds: Iterable<string>): ChatViewDescriptor[];
+//# sourceMappingURL=chat-views.d.ts.map

package/dist/svelte/chat-views.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-views.d.ts","sourceRoot":"","sources":["../../src/svelte/chat-views.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACzC,UAAU,EAAE,sBAAsB,EAClC,WAAW,EAAE,SAAS,kBAAkB,EAAE,EAC1C,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,GAC3B,kBAAkB,EAAE,CAkBtB"}

package/dist/svelte/chat-views.js

@@ -0,0 +1,22 @@
+/**
+ * Resolve the views a web host can truthfully present.
+ *
+ * A configured id alone is not enough: the runtime must describe the view and
+ * the host must supply a renderer. This keeps staged rollouts from exposing
+ * placeholder tabs that look like implemented product capability.
+ */
+export function resolveRenderableChatViews(experience, descriptors, rendererIds) {
+    const enabledIds = new Set(experience.enabledViewIds);
+    const renderableIds = new Set(rendererIds);
+    const descriptorsById = new Map();
+    for (const descriptor of descriptors) {
+        if (!descriptorsById.has(descriptor.id))
+            descriptorsById.set(descriptor.id, descriptor);
+    }
+    return [...descriptorsById.values()]
+        .filter((descriptor) => descriptor.enabled !== false &&
+        descriptor.surfaces.includes('web') &&
+        enabledIds.has(descriptor.id) &&
+        renderableIds.has(descriptor.id))
+        .sort((left, right) => left.order - right.order || left.name.localeCompare(right.name));
+}

package/dist/svelte/command-palette/chat-source.plugin.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Chat command-palette source.
+ *
+ * Registers a `command-palette/source` so a user's past conversations are
+ * findable from the universal command palette. Browser-only: the impl calls
+ * chat-web's authenticated FTS5 search endpoint (`GET /api/chat/search`) on the
+ * current origin, so it surfaces wherever chat-web hosts the palette. Reaching
+ * chats from *other* apps needs the cross-origin auth seam and is a follow-up.
+ *
+ * Declares the `chat:` prefix via the source resolve rule: an unprefixed query
+ * still includes conversations, and `chat: foo` scopes the palette to them.
+ *
+ * Kept on a narrow subpath (`@vibesdotdev/chat/svelte/command-palette`) with no
+ * Svelte/`$state` imports so non-Svelte consumers can register it without
+ * dragging the package's reactive barrel.
+ */
+import * as z from 'zod/v4';
+import type { RuntimeRef } from '@vibesdotdev/kernel';
+import type { KindContext } from '@vibesdotdev/kernel/schemas/kind';
+import type { CommandPaletteResult, CommandPaletteSourceDescriptor, CommandPaletteSourceImplementation, SourceContext } from '@vibesdotdev/command-palette/schemas';
+import { type SearchCacheBackend } from '@vibesdotdev/command-palette/cache';
+declare const chatSearchRoomSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodNumber;
+    matchingMessages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        senderType: z.ZodOptional<z.ZodEnum<{
+            agent: "agent";
+            user: "user";
+            system: "system";
+        }>>;
+        createdAt: z.ZodNumber;
+        rank: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+/** Minimal shape of a matched conversation from `GET /api/chat/search`. */
+type ChatSearchRoom = z.infer<typeof chatSearchRoomSchema>;
+/**
+ * Map ranked conversation rows into palette results. Rows arrive relevance
+ * ordered with no per-row score, so a descending rank-based score preserves the
+ * upstream order through the federator's score sort.
+ */
+export declare function mapRoomsToResults(rooms: ChatSearchRoom[], limit: number): CommandPaletteResult[];
+/**
+ * The source implementation. Resilient by contract — the federator isolates
+ * source failures, and a graceful empty result keeps the rest of the palette
+ * clean when search is unavailable (e.g. on an origin without the chat API).
+ */
+export declare function createChatCommandPaletteSource(backend: SearchCacheBackend, runtime?: RuntimeRef): CommandPaletteSourceImplementation;
+/**
+ * Community-feed source — local-index over `/api/chat/feed` (recent posts; the
+ * endpoint has no query param, so filter client-side on content). Navigates to
+ * the post permalink `/feed/<id>`; prefixes `post:` / `feed:`.
+ */
+export declare function createFeedCommandPaletteSource(backend: SearchCacheBackend, runtime?: RuntimeRef): CommandPaletteSourceImplementation;
+export declare class ChatCommandPaletteSource implements CommandPaletteSourceImplementation {
+    private readonly implementation;
+    constructor(descriptor: CommandPaletteSourceDescriptor, context: KindContext);
+    search(query: string, context: SourceContext): Promise<CommandPaletteResult[]>;
+}
+export declare const chatCommandPaletteSourcePlugin: import("@vibesdotdev/kernel").RuntimePlugin;
+export default chatCommandPaletteSourcePlugin;
+//# sourceMappingURL=chat-source.plugin.d.ts.map

package/dist/svelte/command-palette/chat-source.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-source.plugin.d.ts","sourceRoot":"","sources":["../../../src/svelte/command-palette/chat-source.plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAKpE,OAAO,KAAK,EACX,oBAAoB,EACpB,8BAA8B,EAC9B,kCAAkC,EAClC,aAAa,EACb,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAIN,KAAK,kBAAkB,EACvB,MAAM,oCAAoC,CAAC;AAc5C,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;iBAKxB,CAAC;AAEH,2EAA2E;AAC3E,KAAK,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAgB3D;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAehG;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC7C,OAAO,EAAE,kBAAkB,EAC3B,OAAO,CAAC,EAAE,UAAU,GAClB,kCAAkC,CA6CpC;AAqCD;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC7C,OAAO,EAAE,kBAAkB,EAC3B,OAAO,CAAC,EAAE,UAAU,GAClB,kCAAkC,CAuDpC;AAQD,qBAAa,wBAAyB,YAAW,kCAAkC;IAClF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqC;gBAExD,UAAU,EAAE,8BAA8B,EAAE,OAAO,EAAE,WAAW;IAS5E,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC;CAG9E;AAeD,eAAO,MAAM,8BAA8B,6CAuBzC,CAAC;AAEH,eAAe,8BAA8B,CAAC"}