@vibesdotdev/integrations 0.0.0-stage → 1.0.0-rc.2

package/dist/status/integration-connection.kind.d.ts

@@ -0,0 +1,55 @@
+import * as z from 'zod/v4';
+export declare const INTEGRATION_CONNECTION_KIND: "integration/connection";
+/**
+ * Open kind for provider connection behavior. A configured provider supplies
+ * or replaces connect/check behavior by declaring a descriptor of this kind
+ * for its provider id; consumers resolve it through the runtime and never
+ * branch on a provider id.
+ *
+ * The descriptor carries the provider's declared authentication/connection
+ * metadata, composed from the same owner schema the provider descriptor
+ * accepts, so declaration and resolution share one contract.
+ */
+export declare const IntegrationConnectionDescriptorSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hardware: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    capabilityId: z.ZodOptional<z.ZodString>;
+    requiredContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optionalContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    config: z.ZodOptional<z.ZodUnknown>;
+    retention: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        maxAgeDays: z.ZodOptional<z.ZodNumber>;
+        maxEntries: z.ZodOptional<z.ZodNumber>;
+        maxBytes: z.ZodOptional<z.ZodNumber>;
+        cascadeFrom: z.ZodOptional<z.ZodString>;
+        ageField: z.ZodOptional<z.ZodString>;
+        reason: z.ZodString;
+        enforcedBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    kind: z.ZodLiteral<"integration/connection">;
+    integrationId: z.ZodString;
+    connection: z.ZodObject<{
+        authMode: z.ZodOptional<z.ZodEnum<{
+            oauth: "oauth";
+            delegated: "delegated";
+            "system-config": "system-config";
+            webhook: "webhook";
+        }>>;
+        connectable: z.ZodDefault<z.ZodBoolean>;
+        checkable: z.ZodDefault<z.ZodBoolean>;
+        requiresProviderAdmin: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type IntegrationConnectionDescriptor = z.infer<typeof IntegrationConnectionDescriptorSchema>;
+/**
+ * Open kind: providers register descriptors and lazy implementation loaders
+ * for their own connection behavior. The kind declares no default — a
+ * provider that declares no connection capability has none.
+ */
+export declare const integrationConnectionKind: import("@vibesdotdev/kernel").RuntimeKindDescriptorRecord<unknown>;
+//# sourceMappingURL=integration-connection.kind.d.ts.map

package/dist/status/integration-connection.kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-connection.kind.d.ts","sourceRoot":"","sources":["../../src/status/integration-connection.kind.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAK5B,eAAO,MAAM,2BAA2B,EAAG,wBAAiC,CAAC;AAE7E;;;;;;;;;GASG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKhD,CAAC;AAEH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAEpG;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,oEAGpC,CAAC"}

package/dist/status/integration-connection.kind.js

@@ -0,0 +1,31 @@
+import * as z from 'zod/v4';
+import { createRuntimeKind } from '@vibesdotdev/kernel/factory';
+import { RuntimeDescriptorSchema } from '@vibesdotdev/kernel/schemas/descriptor';
+import { IntegrationConnectionMetadataSchema } from "../schemas/integration-connection.js";
+export const INTEGRATION_CONNECTION_KIND = 'integration/connection';
+/**
+ * Open kind for provider connection behavior. A configured provider supplies
+ * or replaces connect/check behavior by declaring a descriptor of this kind
+ * for its provider id; consumers resolve it through the runtime and never
+ * branch on a provider id.
+ *
+ * The descriptor carries the provider's declared authentication/connection
+ * metadata, composed from the same owner schema the provider descriptor
+ * accepts, so declaration and resolution share one contract.
+ */
+export const IntegrationConnectionDescriptorSchema = RuntimeDescriptorSchema.extend({
+    kind: z.literal(INTEGRATION_CONNECTION_KIND),
+    /** The `integration/provider` descriptor id this connection serves. */
+    integrationId: z.string().min(1),
+    connection: IntegrationConnectionMetadataSchema
+});
+/**
+ * Open kind: providers register descriptors and lazy implementation loaders
+ * for their own connection behavior. The kind declares no default — a
+ * provider that declares no connection capability has none.
+ */
+export const integrationConnectionKind = createRuntimeKind({
+    id: INTEGRATION_CONNECTION_KIND,
+    descriptorSchema: IntegrationConnectionDescriptorSchema
+});
+//# sourceMappingURL=integration-connection.kind.js.map

package/dist/status/integration-connection.kind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-connection.kind.js","sourceRoot":"","sources":["../../src/status/integration-connection.kind.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AACjF,OAAO,EAAE,mCAAmC,EAAE,MAAM,sCAAsC,CAAC;AAE3F,MAAM,CAAC,MAAM,2BAA2B,GAAG,wBAAiC,CAAC;AAE7E;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,qCAAqC,GAAG,uBAAuB,CAAC,MAAM,CAAC;IACnF,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,2BAA2B,CAAC;IAC5C,uEAAuE;IACvE,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAChC,UAAU,EAAE,mCAAmC;CAC/C,CAAC,CAAC;AAIH;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,iBAAiB,CAAC;IAC1D,EAAE,EAAE,2BAA2B;IAC/B,gBAAgB,EAAE,qCAAqC;CACvD,CAAC,CAAC"}

package/dist/status/integration-connection.queries.d.ts

@@ -0,0 +1,25 @@
+import type { RuntimeRef } from '@vibesdotdev/kernel';
+import type { IntegrationConnectionCapability } from './integration-connection.capability.ts';
+import { type IntegrationConnectionMetadata, type IntegrationConnectionStatus } from '../schemas/integration-connection.ts';
+import type { IntegrationProviderDescriptor } from '../schemas/integration-descriptor.ts';
+type ProviderWithConnection = Pick<IntegrationProviderDescriptor, 'id' | 'connection'>;
+/**
+ * The declared connection metadata for a provider, resolved through the
+ * runtime. A composed `integration/connection` descriptor (the provider's own
+ * behavior, which a host plugin can supply or replace) wins over the
+ * metadata the provider descriptor itself declares. Absence stays absence:
+ * undeclared means no connect and no check — never an inference from the
+ * provider id, category or credential shape.
+ */
+export declare function resolveIntegrationConnectionMetadata(runtime: RuntimeRef, provider: ProviderWithConnection): Promise<IntegrationConnectionMetadata | null>;
+/**
+ * Connection status for one provider through its composed capability. A
+ * provider with no declared connection behavior refuses with `UNAVAILABLE` /
+ * `integration-connection-unsupported`; a capability's own refusal propagates
+ * with its typed code and reason.
+ */
+export declare function integrationConnectionStatus(runtime: RuntimeRef, integrationId: string): Promise<IntegrationConnectionStatus>;
+/** Resolve the composed connection capability for a provider id, if any. */
+export declare function resolveIntegrationConnection(runtime: RuntimeRef, integrationId: string): Promise<IntegrationConnectionCapability | null>;
+export {};
+//# sourceMappingURL=integration-connection.queries.d.ts.map

package/dist/status/integration-connection.queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-connection.queries.d.ts","sourceRoot":"","sources":["../../src/status/integration-connection.queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAOtD,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,wCAAwC,CAAC;AAE9F,OAAO,EAGN,KAAK,6BAA6B,EAClC,KAAK,2BAA2B,EAChC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,sCAAsC,CAAC;AAE1F,KAAK,sBAAsB,GAAG,IAAI,CAAC,6BAA6B,EAAE,IAAI,GAAG,YAAY,CAAC,CAAC;AAEvF;;;;;;;GAOG;AACH,wBAAsB,oCAAoC,CACzD,OAAO,EAAE,UAAU,EACnB,QAAQ,EAAE,sBAAsB,GAC9B,OAAO,CAAC,6BAA6B,GAAG,IAAI,CAAC,CAI/C;AAED;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAChD,OAAO,EAAE,UAAU,EACnB,aAAa,EAAE,MAAM,GACnB,OAAO,CAAC,2BAA2B,CAAC,CAItC;AAED,4EAA4E;AAC5E,wBAAsB,4BAA4B,CACjD,OAAO,EAAE,UAAU,EACnB,aAAa,EAAE,MAAM,GACnB,OAAO,CAAC,+BAA+B,GAAG,IAAI,CAAC,CA4BjD"}

package/dist/status/integration-connection.queries.js

@@ -0,0 +1,65 @@
+import { INTEGRATION_CONNECTION_KIND, IntegrationConnectionDescriptorSchema } from "./integration-connection.kind.js";
+import { integrationConnectionUnsupported } from "./integration-connection.capability.js";
+import { parseIntegrationBoundary } from "../schemas/boundary.js";
+import { IntegrationConnectRequestResultSchema, IntegrationConnectionStatusSchema } from "../schemas/integration-connection.js";
+/**
+ * The declared connection metadata for a provider, resolved through the
+ * runtime. A composed `integration/connection` descriptor (the provider's own
+ * behavior, which a host plugin can supply or replace) wins over the
+ * metadata the provider descriptor itself declares. Absence stays absence:
+ * undeclared means no connect and no check — never an inference from the
+ * provider id, category or credential shape.
+ */
+export async function resolveIntegrationConnectionMetadata(runtime, provider) {
+    const capability = await declaredConnectionDescriptor(runtime, provider.id);
+    if (capability)
+        return capability.connection;
+    return provider.connection ?? null;
+}
+/**
+ * Connection status for one provider through its composed capability. A
+ * provider with no declared connection behavior refuses with `UNAVAILABLE` /
+ * `integration-connection-unsupported`; a capability's own refusal propagates
+ * with its typed code and reason.
+ */
+export async function integrationConnectionStatus(runtime, integrationId) {
+    const capability = await resolveIntegrationConnection(runtime, integrationId);
+    if (!capability)
+        throw integrationConnectionUnsupported(integrationId);
+    return capability.status();
+}
+/** Resolve the composed connection capability for a provider id, if any. */
+export async function resolveIntegrationConnection(runtime, integrationId) {
+    const declared = await declaredConnectionDescriptor(runtime, integrationId);
+    if (!declared)
+        return null;
+    const implementation = await runtime
+        .query(INTEGRATION_CONNECTION_KIND)
+        .withId(declared.id)
+        .resolve();
+    return {
+        status: async () => {
+            if (!declared.connection.checkable) {
+                throw integrationConnectionUnsupported(integrationId);
+            }
+            return parseIntegrationBoundary(IntegrationConnectionStatusSchema, await implementation.status());
+        },
+        requestConnect: async () => {
+            if (!declared.connection.connectable) {
+                throw integrationConnectionUnsupported(integrationId);
+            }
+            return parseIntegrationBoundary(IntegrationConnectRequestResultSchema, await implementation.requestConnect());
+        }
+    };
+}
+async function declaredConnectionDescriptor(runtime, integrationId) {
+    if (!runtime.hasKind(INTEGRATION_CONNECTION_KIND))
+        return null;
+    const candidates = await runtime
+        .query(INTEGRATION_CONNECTION_KIND)
+        .enabled()
+        .descriptorsAsync();
+    return (candidates.find((candidate) => IntegrationConnectionDescriptorSchema.safeParse(candidate).success &&
+        candidate.integrationId === integrationId) ?? null);
+}
+//# sourceMappingURL=integration-connection.queries.js.map

package/dist/status/integration-connection.queries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-connection.queries.js","sourceRoot":"","sources":["../../src/status/integration-connection.queries.ts"],"names":[],"mappings":"AACA,OAAO,EACN,2BAA2B,EAC3B,qCAAqC,EAErC,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,gCAAgC,EAAE,MAAM,wCAAwC,CAAC;AAE1F,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EACN,qCAAqC,EACrC,iCAAiC,EAGjC,MAAM,sCAAsC,CAAC;AAK9C;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,oCAAoC,CACzD,OAAmB,EACnB,QAAgC;IAEhC,MAAM,UAAU,GAAG,MAAM,4BAA4B,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;IAC5E,IAAI,UAAU;QAAE,OAAO,UAAU,CAAC,UAAU,CAAC;IAC7C,OAAO,QAAQ,CAAC,UAAU,IAAI,IAAI,CAAC;AACpC,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAChD,OAAmB,EACnB,aAAqB;IAErB,MAAM,UAAU,GAAG,MAAM,4BAA4B,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;IAC9E,IAAI,CAAC,UAAU;QAAE,MAAM,gCAAgC,CAAC,aAAa,CAAC,CAAC;IACvE,OAAO,UAAU,CAAC,MAAM,EAAE,CAAC;AAC5B,CAAC;AAED,4EAA4E;AAC5E,MAAM,CAAC,KAAK,UAAU,4BAA4B,CACjD,OAAmB,EACnB,aAAqB;IAErB,MAAM,QAAQ,GAAG,MAAM,4BAA4B,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;IAC5E,IAAI,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC3B,MAAM,cAAc,GAAG,MAAM,OAAO;SAClC,KAAK,CAAmE,2BAA2B,CAAC;SACpG,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;SACnB,OAAO,EAAE,CAAC;IAEZ,OAAO;QACN,MAAM,EAAE,KAAK,IAAI,EAAE;YAClB,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;gBACpC,MAAM,gCAAgC,CAAC,aAAa,CAAC,CAAC;YACvD,CAAC;YACD,OAAO,wBAAwB,CAC9B,iCAAiC,EACjC,MAAM,cAAc,CAAC,MAAM,EAAE,CAC7B,CAAC;QACH,CAAC;QACD,cAAc,EAAE,KAAK,IAAI,EAAE;YAC1B,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;gBACtC,MAAM,gCAAgC,CAAC,aAAa,CAAC,CAAC;YACvD,CAAC;YACD,OAAO,wBAAwB,CAC9B,qCAAqC,EACrC,MAAM,cAAc,CAAC,cAAc,EAAE,CACrC,CAAC;QACH,CAAC;KACD,CAAC;AACH,CAAC;AAED,KAAK,UAAU,4BAA4B,CAC1C,OAAmB,EACnB,aAAqB;IAErB,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,2BAA2B,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/D,MAAM,UAAU,GAAG,MAAM,OAAO;SAC9B,KAAK,CAAkC,2BAA2B,CAAC;SACnE,OAAO,EAAE;SACT,gBAAgB,EAAE,CAAC;IACrB,OAAO,CACN,UAAU,CAAC,IAAI,CACd,CAAC,SAAS,EAAE,EAAE,CACb,qCAAqC,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,OAAO;QAClE,SAAS,CAAC,aAAa,KAAK,aAAa,CAC1C,IAAI,IAAI,CACT,CAAC;AACH,CAAC"}

package/dist/svelte/components/IntegrationsCatalog.svelte

@@ -0,0 +1,201 @@
+<script lang="ts">
+	import { onMount } from 'svelte';
+	import { createRuntimeClientStore, getRuntimeSvelteContext } from '@vibesdotdev/surface-sveltekit/svelte/state';
+	import { CapabilityError, settle } from '@vibesdotdev/kernel';
+	import { Badge, Button, Card, Skeleton } from '@vibesdotdev/kit/components';
+	import { EmptyState } from '@vibesdotdev/kit/components/layout';
+	import type { IntegrationProviderDescriptor } from '../../schemas/integration-descriptor.js';
+	import { integrationsCatalogState, type IntegrationsCatalogState } from '../state.svelte.js';
+	import type { IntegrationsCatalogProps } from '../types.js';
+
+	let {
+		providers,
+		title = 'Connections',
+		description = 'Integration providers available to this runtime.',
+		emptyTitle = 'No integration providers available',
+		emptyDescription = 'Provider plugins appear here when they are composed into the current runtime.',
+		connectLabel = 'Connect'
+	}: IntegrationsCatalogProps = $props();
+
+	const runtimeStore = getRuntimeSvelteContext();
+	const stateStore = createRuntimeClientStore<IntegrationsCatalogState>({
+		id: 'integrations-catalog-state',
+		runtimeStore,
+		resolve: async () => integrationsCatalogState(await runtimeStore.load())
+	});
+	onMount(() => {
+		void settle(() => stateStore.load());
+		return () => stateStore.dispose();
+	});
+
+	const catalogState = $derived(stateStore.client);
+	const catalogProviders = $derived(providers ?? catalogState?.providers ?? []);
+	const stateBacked = $derived(providers === undefined);
+	let pendingProviderId = $state<string | null>(null);
+	let connectableProviders = $state<Set<string>>(new Set());
+	let actionError = $state<CapabilityError | null>(null);
+	let availabilityGeneration = 0;
+
+	$effect(() => {
+		const candidates = catalogProviders;
+		const generation = ++availabilityGeneration;
+		connectableProviders = new Set();
+
+		if (candidates.length > 0) {
+			void updateConnectionAvailability(candidates, generation);
+		}
+
+		return () => {
+			if (availabilityGeneration === generation) availabilityGeneration++;
+		};
+	});
+
+	function label(value: string): string {
+		return value
+			.split('-')
+			.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+			.join(' ');
+	}
+
+	async function updateConnectionAvailability(
+		candidates: IntegrationProviderDescriptor[],
+		generation: number
+	): Promise<void> {
+		const result = await settle(async () => {
+			const state = catalogState ?? await stateStore.load();
+			const availability = await Promise.all(candidates.map(async (provider) =>
+				(await state.canRequestConnection(provider)) ? provider.id : undefined
+			));
+			return availability.filter((providerId): providerId is string => providerId !== undefined);
+		});
+
+		if (generation !== availabilityGeneration) return;
+		if (!result.ok) {
+			const cause = result.cause;
+			actionError = cause instanceof CapabilityError
+				? cause
+				: new CapabilityError('The integration connection could not be started.', 'UNAVAILABLE', {
+					reason: 'integration-connect-availability-failed',
+					cause
+				});
+			return;
+		}
+
+		connectableProviders = new Set(result.value);
+	}
+
+	async function requestConnection(providerId: string): Promise<void> {
+		const provider = catalogProviders.find((candidate) => candidate.id === providerId);
+		if (!provider || !connectableProviders.has(providerId)) return;
+
+		pendingProviderId = providerId;
+		actionError = null;
+		const result = await settle(async () => {
+			const state = catalogState ?? await stateStore.load();
+			return state.requestConnection(provider);
+		});
+		if (!result.ok) {
+			const cause = result.cause;
+			actionError = cause instanceof CapabilityError
+				? cause
+				: new CapabilityError('The integration connection could not be started.', 'UNAVAILABLE', {
+					reason: 'integration-connect-request-failed',
+					cause
+				});
+		} else if ('refused' in result.value) {
+			actionError = new CapabilityError(
+				'The integration connection request was refused.',
+				result.value.code,
+				{ reason: result.value.reason }
+			);
+		}
+		pendingProviderId = null;
+	}
+</script>
+
+<section class="space-y-5" aria-labelledby="integrations-catalog-title">
+	<header class="space-y-1">
+		<h2 id="integrations-catalog-title" class="text-2xl font-semibold tracking-tight">{title}</h2>
+		<p class="text-sm text-muted-foreground">{description}</p>
+		<p class="text-xs text-muted-foreground">
+			Provider availability comes from the catalog. Connect appears only when this runtime resolves a connection capability; it does not report connection state.
+		</p>
+	</header>
+
+	{#if stateBacked && (catalogState?.error || stateStore.error)}
+		<div
+			role="alert"
+			class="rounded-lg border border-destructive/30 bg-destructive/10 p-4 text-sm text-destructive"
+		>
+			{catalogState?.error ?? 'The integration catalog could not be loaded.'}
+		</div>
+	{/if}
+
+	{#if actionError}
+		<div
+			role="alert"
+			class="rounded-lg border border-destructive/30 bg-destructive/10 p-4 text-sm text-destructive"
+		>
+			{actionError.message}
+		</div>
+	{/if}
+
+	{#if stateBacked && catalogState?.loading && !catalogState?.initialized}
+		<div class="grid gap-4 md:grid-cols-2 xl:grid-cols-3" aria-label="Loading integration providers">
+			{#each Array(3) as _}
+				<Card.Root class="shadow-none">
+					<Card.Header class="space-y-3">
+						<Skeleton class="h-5 w-2/3" />
+						<Skeleton class="h-4 w-full" />
+					</Card.Header>
+					<Card.Content>
+						<Skeleton class="h-9 w-24" />
+					</Card.Content>
+				</Card.Root>
+			{/each}
+		</div>
+	{:else if catalogProviders.length === 0}
+		<EmptyState
+			icon="lucide:plug"
+			title={emptyTitle}
+			description={emptyDescription}
+		/>
+	{:else}
+		<div class="grid gap-4 md:grid-cols-2 xl:grid-cols-3">
+			{#each catalogProviders as provider (provider.id)}
+				<Card.Root class="flex h-full flex-col shadow-none">
+					<Card.Header class="space-y-3">
+						<div class="flex items-start justify-between gap-3">
+							<div class="min-w-0">
+								<Card.Title class="truncate text-base">{provider.name}</Card.Title>
+								<Card.Description class="mt-1 line-clamp-3">
+									{provider.description ?? 'No provider description supplied.'}
+								</Card.Description>
+							</div>
+							<Badge variant={provider.enabled === false ? 'outline' : 'secondary'}>
+								{provider.enabled === false ? 'Disabled' : 'Available'}
+							</Badge>
+						</div>
+						<div class="flex flex-wrap gap-2">
+							<Badge variant="outline">{label(provider.category)}</Badge>
+							<Badge variant="outline">{label(provider.provider)}</Badge>
+						</div>
+					</Card.Header>
+
+					{#if connectableProviders.has(provider.id)}
+						<Card.Content class="mt-auto pt-0">
+							<Button
+								size="sm"
+								onclick={() => void requestConnection(provider.id)}
+								disabled={pendingProviderId !== null}
+								aria-label={connectLabel + ' ' + provider.name}
+							>
+								{pendingProviderId === provider.id ? 'Opening…' : connectLabel}
+							</Button>
+						</Card.Content>
+					{/if}
+				</Card.Root>
+			{/each}
+		</div>
+	{/if}
+</section>

package/dist/svelte/components/IntegrationsCatalog.svelte.d.ts

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

package/dist/svelte/components/IntegrationsCatalog.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntegrationsCatalog.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/components/IntegrationsCatalog.svelte.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AA+L5D,QAAA,MAAM,mBAAmB,8DAAwC,CAAC;AAClE,KAAK,mBAAmB,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAClE,eAAe,mBAAmB,CAAC"}

package/dist/svelte/components/IntegrationsLoader.svelte

@@ -0,0 +1,46 @@
+<script lang="ts">
+	import { CapabilityError, settle } from '@vibesdotdev/kernel';
+	import { onMount } from 'svelte';
+	import type {
+		IntegrationCategory,
+		IntegrationProviderDescriptor
+	} from '../../schemas/integration-descriptor.js';
+	import { getRuntimeSvelteContext } from '@vibesdotdev/surface-sveltekit/svelte/state';
+	import { integrationsCatalogState } from '../state.svelte.js';
+
+	type Props = {
+		initialProviders?: IntegrationProviderDescriptor[];
+		includeDisabled?: boolean;
+		category?: IntegrationCategory;
+		provider?: string;
+		refresh?: boolean;
+	};
+
+	let {
+		initialProviders,
+		includeDisabled = false,
+		category,
+		provider,
+		refresh = false
+	}: Props = $props();
+
+	// Captured at component init: Svelte context is unavailable after mount.
+	const runtimeStore = getRuntimeSvelteContext();
+
+ let failure = $state<CapabilityError | null>(null);
+ onMount(() => {
+  void settle(async () => {
+   const runtime = await runtimeStore.load();
+   const state = await integrationsCatalogState(runtime);
+   await state.init({ runtime, initialProviders, includeDisabled, category, provider, refresh });
+  }).then((result) => {
+   if (!result.ok) failure = new CapabilityError('The integration catalog could not be initialized.', 'UNAVAILABLE', {
+    reason: 'integration-catalog-init-failed', cause: result.cause
+   });
+  });
+ });
+</script>
+
+{#if failure}
+ <p role="alert">{failure.message}</p>
+{/if}

package/dist/svelte/components/IntegrationsLoader.svelte.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationCategory, IntegrationProviderDescriptor } from '../../schemas/integration-descriptor.ts';
+type Props = {
+    initialProviders?: IntegrationProviderDescriptor[];
+    includeDisabled?: boolean;
+    category?: IntegrationCategory;
+    provider?: string;
+    refresh?: boolean;
+};
+declare const IntegrationsLoader: import("svelte").Component<Props, {}, "">;
+type IntegrationsLoader = ReturnType<typeof IntegrationsLoader>;
+export default IntegrationsLoader;
+//# sourceMappingURL=IntegrationsLoader.svelte.d.ts.map

package/dist/svelte/components/IntegrationsLoader.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntegrationsLoader.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/components/IntegrationsLoader.svelte.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,mBAAmB,EACnB,6BAA6B,EAC7B,MAAM,yCAAyC,CAAC;AAKjD,KAAK,KAAK,GAAG;IACZ,gBAAgB,CAAC,EAAE,6BAA6B,EAAE,CAAC;IACnD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,mBAAmB,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAwCH,QAAA,MAAM,kBAAkB,2CAAwC,CAAC;AACjE,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAChE,eAAe,kBAAkB,CAAC"}

package/dist/svelte/connect-action.d.ts

@@ -0,0 +1,20 @@
+import type { RuntimeRef } from '@vibesdotdev/kernel';
+import type { IntegrationConnectionProvider } from './types.ts';
+/**
+ * Availability requires a connectable declaration and a resolvable runtime
+ * implementation. Catalog metadata by itself never grants connection authority.
+ */
+export declare function canRequestIntegrationConnection(runtime: RuntimeRef, provider: IntegrationConnectionProvider): Promise<boolean>;
+/**
+ * Request a connection through the provider's declared runtime capability.
+ * Implementations retain host authorization and return a schema-validated,
+ * typed outcome.
+ */
+export declare function requestIntegrationConnection(runtime: RuntimeRef, provider: IntegrationConnectionProvider): Promise<{
+    refused: true;
+    code: "UNAVAILABLE" | "PERMISSION_DENIED" | "INVALID_INPUT";
+    reason: string;
+} | {
+    accepted: true;
+}>;
+//# sourceMappingURL=connect-action.d.ts.map

package/dist/svelte/connect-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-action.d.ts","sourceRoot":"","sources":["../../src/svelte/connect-action.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAMtD,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAEhE;;;GAGG;AACH,wBAAsB,+BAA+B,CACpD,OAAO,EAAE,UAAU,EACnB,QAAQ,EAAE,6BAA6B,GACrC,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED;;;;GAIG;AACH,wBAAsB,4BAA4B,CACjD,OAAO,EAAE,UAAU,EACnB,QAAQ,EAAE,6BAA6B;;;;;;GAiBvC"}

package/dist/svelte/connect-action.js

@@ -0,0 +1,40 @@
+import { IntegrationConnectRequestResultSchema } from "../schemas/integration-connection.js";
+import { resolveIntegrationConnection, resolveIntegrationConnectionMetadata } from "../status/integration-connection.queries.js";
+/**
+ * Availability requires a connectable declaration and a resolvable runtime
+ * implementation. Catalog metadata by itself never grants connection authority.
+ */
+export async function canRequestIntegrationConnection(runtime, provider) {
+    if (provider.enabled === false)
+        return false;
+    const metadata = await resolveIntegrationConnectionMetadata(runtime, provider);
+    if (metadata?.connectable !== true)
+        return false;
+    return (await resolveIntegrationConnection(runtime, provider.id)) !== null;
+}
+/**
+ * Request a connection through the provider's declared runtime capability.
+ * Implementations retain host authorization and return a schema-validated,
+ * typed outcome.
+ */
+export async function requestIntegrationConnection(runtime, provider) {
+    if (provider.enabled === false) {
+        return refusal('integration-provider-disabled');
+    }
+    const metadata = await resolveIntegrationConnectionMetadata(runtime, provider);
+    if (metadata?.connectable !== true) {
+        return refusal('integration-connection-unsupported');
+    }
+    const capability = await resolveIntegrationConnection(runtime, provider.id);
+    if (!capability) {
+        return refusal('integration-connection-unsupported');
+    }
+    return capability.requestConnect();
+}
+function refusal(reason) {
+    return IntegrationConnectRequestResultSchema.parse({
+        refused: true,
+        code: 'UNAVAILABLE',
+        reason
+    });
+}

package/dist/svelte/docs/integrations-svelte.catalog.docs.descriptor.d.ts

@@ -0,0 +1,4 @@
+import type { DocsTopicDescriptor } from '@vibesdotdev/docs-contracts';
+declare const descriptor: DocsTopicDescriptor;
+export default descriptor;
+//# sourceMappingURL=integrations-svelte.catalog.docs.descriptor.d.ts.map

package/dist/svelte/docs/integrations-svelte.catalog.docs.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrations-svelte.catalog.docs.descriptor.d.ts","sourceRoot":"","sources":["../../../src/svelte/docs/integrations-svelte.catalog.docs.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAqBvE,QAAA,MAAM,UAAU,EAAE,mBAUjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/svelte/docs/integrations-svelte.catalog.docs.descriptor.js

@@ -0,0 +1,30 @@
+const body = [
+    "# Integration catalog Svelte surface",
+    "",
+    "Use the catalog loader and component to present provider descriptors registered with the active runtime.",
+    "",
+    "```svelte",
+    "<script lang=\"ts\">",
+    "  import { IntegrationsCatalog, IntegrationsLoader } from '@vibesdotdev/integrations/svelte';",
+    "</script>",
+    "",
+    "<IntegrationsLoader />",
+    "<IntegrationsCatalog connectLabel=\"Link account\" />",
+    "```",
+    "",
+    "Compose the browser plugin with the provider's browser-scoped connection plugin. A Connect button appears only when this runtime resolves an enabled provider's declared `integration/connection` implementation. Catalog metadata alone does not grant authority, and the component does not construct URLs or handle credentials.",
+    "",
+    "The connection implementation retains host authorization. Accepted requests and typed refusals are returned through the runtime; refusals preserve their code and reason. The renderer catalog projection keeps only public labels, availability, and declared connection metadata, never private configuration, credential references, OAuth endpoints, base URLs, or operations.",
+].join('\n');
+const descriptor = {
+    kind: 'docs/topic',
+    id: "integrations-svelte.catalog",
+    title: "Integration Catalog Svelte Surface",
+    summary: "Render public provider metadata and invoke only resolved connection capabilities.",
+    body: { type: 'markdown', sourceType: 'raw', source: body },
+    tags: ["integrations", "svelte", "catalog", "runtime-client"],
+    surfaces: ["web", "in-app"],
+    hardware: ["consumer", "cloud"],
+    enabled: true
+};
+export default descriptor;

package/dist/svelte/index.d.ts

@@ -0,0 +1,12 @@
+export { default as IntegrationsCatalog } from './components/IntegrationsCatalog.svelte';
+export { default as IntegrationsLoader } from './components/IntegrationsLoader.svelte';
+export { canRequestIntegrationConnection, requestIntegrationConnection } from './connect-action.ts';
+export { integrationsCatalogState } from './state.svelte.ts';
+export type { IntegrationsCatalogState, IntegrationsCatalogStateInitOptions } from './state.svelte.ts';
+export { loadIntegrationsCatalog } from './runtime.ts';
+export type { IntegrationsCatalogOptions } from './runtime.ts';
+export { loadIntegrationsCatalogData } from './loaders.ts';
+export type { IntegrationsCatalogData } from './loaders.ts';
+export type { IntegrationConnectionProvider, IntegrationsCatalogProps } from './types.ts';
+export { integrationsSveltePlugin } from './integrations-svelte.plugin.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/svelte/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AACzF,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AACvF,OAAO,EACN,+BAA+B,EAC/B,4BAA4B,EAC5B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,YAAY,EACX,wBAAwB,EACxB,mCAAmC,EACnC,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACvD,YAAY,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAC3D,YAAY,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAE5D,YAAY,EACX,6BAA6B,EAC7B,wBAAwB,EACxB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC"}

package/dist/svelte/index.js

@@ -0,0 +1,7 @@
+export { default as IntegrationsCatalog } from './components/IntegrationsCatalog.svelte';
+export { default as IntegrationsLoader } from './components/IntegrationsLoader.svelte';
+export { canRequestIntegrationConnection, requestIntegrationConnection } from "./connect-action.js";
+export { integrationsCatalogState } from "./state.svelte.js";
+export { loadIntegrationsCatalog } from "./runtime.js";
+export { loadIntegrationsCatalogData } from "./loaders.js";
+export { integrationsSveltePlugin } from "./integrations-svelte.plugin.js";

package/dist/svelte/integrations-svelte.plugin.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Discoverability plugin for the Svelte projection.
+ *
+ * It has no hard dependency on the base plugin: docs can register before the
+ * provider catalog is composed, while the runtime helper produces the honest
+ * missing-owner error if a consumer tries to load data too early.
+ */
+export declare const integrationsSveltePlugin: import("@vibesdotdev/kernel").RuntimePlugin;
+export default integrationsSveltePlugin;
+//# sourceMappingURL=integrations-svelte.plugin.d.ts.map

package/dist/svelte/integrations-svelte.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrations-svelte.plugin.d.ts","sourceRoot":"","sources":["../../src/svelte/integrations-svelte.plugin.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,6CAKnC,CAAC;AAEH,eAAe,wBAAwB,CAAC"}

package/dist/svelte/integrations-svelte.plugin.js

@@ -0,0 +1,16 @@
+import { createRuntimePlugin } from '@vibesdotdev/kernel';
+import integrationsSvelteCatalogDocsDescriptor from "./docs/integrations-svelte.catalog.docs.descriptor.js";
+/**
+ * Discoverability plugin for the Svelte projection.
+ *
+ * It has no hard dependency on the base plugin: docs can register before the
+ * provider catalog is composed, while the runtime helper produces the honest
+ * missing-owner error if a consumer tries to load data too early.
+ */
+export const integrationsSveltePlugin = createRuntimePlugin({
+    id: 'integrations/svelte',
+    name: 'Integrations Svelte',
+    description: 'Svelte surface for the descriptor-backed integration catalog',
+    descriptors: [integrationsSvelteCatalogDocsDescriptor]
+});
+export default integrationsSveltePlugin;