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

package/dist/svelte/tool-widgets/ComponentsToolCard.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentsToolCard.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/tool-widgets/ComponentsToolCard.svelte.ts"],"names":[],"mappings":"AAQA,OAAO,EAGL,KAAK,eAAe,EACpB,MAAM,0CAA0C,CAAC;AAkJnD,QAAA,MAAM,kBAAkB,qDAAwC,CAAC;AACjE,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAChE,eAAe,kBAAkB,CAAC"}

package/dist/svelte/tool-widgets/IntegrationOperationToolCard.svelte

@@ -0,0 +1,76 @@
+<script lang="ts">
+	/**
+	 * First-party widget for `integration-operation`: connected API call + payload.
+	 */
+	import { CodeViewer } from '@vibesdotdev/kit/components/code';
+	import { Badge } from '@vibesdotdev/kit/components/ui/badge';
+	import {
+		ToolCard,
+		ToolCardBody,
+		approvalCopy,
+		formatToolData,
+		toolBlobLanguage,
+		type ToolWidgetProps
+	} from '@vibesdotdev/kit/components/tool-widgets';
+	import {
+		integrationLabel,
+		integrationOperationCardTitle,
+		primitiveFields
+	} from './presentation.js';
+	import { rec, text } from './utils.js';
+
+	let { tool, compact = false }: ToolWidgetProps = $props();
+
+	const input = $derived(rec(tool.input));
+	const output = $derived(rec(tool.output));
+	const title = $derived(integrationOperationCardTitle(input, output));
+	const integrationId = $derived(text(input?.integrationId) || text(output?.integrationId));
+	const operationId = $derived(text(input?.operationId) || text(output?.operationId));
+	const payload = $derived(output && 'data' in output ? output.data : output);
+	const fields = $derived(primitiveFields(payload));
+	const json = $derived(fields.length === 0 ? formatToolData(payload) : '');
+	const approval = $derived(approvalCopy(tool));
+</script>
+
+<ToolCard {tool} {compact} {title} icon="lucide:plug">
+	{#snippet children()}
+		<ToolCardBody {compact}>
+			<div class="flex flex-wrap items-center gap-1.5">
+				{#if integrationId}
+					<Badge variant="secondary" class="max-w-full truncate text-caption">
+						{integrationLabel(integrationId)}
+					</Badge>
+				{/if}
+				{#if operationId}
+					<Badge variant="outline" class="max-w-full truncate font-mono text-caption">
+						{operationId}
+					</Badge>
+				{/if}
+			</div>
+
+			{#if approval}
+				<p class="text-xs text-muted-foreground">{approval}</p>
+			{/if}
+
+			{#if fields.length}
+				<dl class="grid grid-cols-[auto_1fr] gap-x-3 gap-y-1 text-xs">
+					{#each fields as field (field.key)}
+						<dt class="text-muted-foreground">{field.key}</dt>
+						<dd class="min-w-0 truncate font-medium text-foreground">{field.value}</dd>
+					{/each}
+				</dl>
+			{:else if json}
+				<CodeViewer
+					code={json}
+					language={toolBlobLanguage(json, payload)}
+					appearance="system"
+					maxHeight="16rem"
+					minHeight="0"
+					showLineNumbers={false}
+				/>
+			{:else if output && !tool.error && !approval}
+				<p class="text-xs text-muted-foreground italic">No payload returned.</p>
+			{/if}
+		</ToolCardBody>
+	{/snippet}
+</ToolCard>

package/dist/svelte/tool-widgets/IntegrationOperationToolCard.svelte.d.ts

@@ -0,0 +1,5 @@
+import { type ToolWidgetProps } from '@vibesdotdev/kit/components/tool-widgets';
+declare const IntegrationOperationToolCard: import("svelte").Component<ToolWidgetProps, {}, "">;
+type IntegrationOperationToolCard = ReturnType<typeof IntegrationOperationToolCard>;
+export default IntegrationOperationToolCard;
+//# sourceMappingURL=IntegrationOperationToolCard.svelte.d.ts.map

package/dist/svelte/tool-widgets/IntegrationOperationToolCard.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntegrationOperationToolCard.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/tool-widgets/IntegrationOperationToolCard.svelte.ts"],"names":[],"mappings":"AAQA,OAAO,EAML,KAAK,eAAe,EACpB,MAAM,0CAA0C,CAAC;AAmEnD,QAAA,MAAM,4BAA4B,qDAAwC,CAAC;AAC3E,KAAK,4BAA4B,GAAG,UAAU,CAAC,OAAO,4BAA4B,CAAC,CAAC;AACpF,eAAe,4BAA4B,CAAC"}

package/dist/svelte/tool-widgets/StorageInspectorToolCard.svelte

@@ -0,0 +1,133 @@
+<script lang="ts">
+	/**
+	 * First-party widget for `storage-inspector`: list manifests or query a table.
+	 */
+	import { CodeViewer } from '@vibesdotdev/kit/components/code';
+	import { Badge } from '@vibesdotdev/kit/components/ui/badge';
+	import { Icon } from '@vibesdotdev/kit/components/icon';
+	import {
+		ToolCard,
+		ToolCardBody,
+		formatToolData,
+		toolBlobLanguage,
+		type ToolWidgetProps
+	} from '@vibesdotdev/kit/components/tool-widgets';
+	import {
+		TOOL_CARD_LIST_LIMIT,
+		inspectQueryData,
+		manifestsFromOutput,
+		rowHeadline,
+		storageInspectorCardTitle
+	} from './presentation.js';
+	import { rec, text } from './utils.js';
+
+	let { tool, compact = false }: ToolWidgetProps = $props();
+
+	const input = $derived(rec(tool.input));
+	const output = $derived(rec(tool.output));
+	const action = $derived(text(input?.action) || text(output?.action));
+	const title = $derived(storageInspectorCardTitle(input, output));
+	const manifests = $derived(manifestsFromOutput(output));
+	const shownManifests = $derived(manifests.slice(0, TOOL_CARD_LIST_LIMIT));
+	const manifestId = $derived(text(output?.manifestId) || text(input?.manifestId));
+	const dataType = $derived(text(output?.dataType));
+	const queried = $derived(inspectQueryData(output?.data));
+	const shownRows = $derived(
+		queried.kind === 'rows' ? queried.rows.slice(0, TOOL_CARD_LIST_LIMIT) : []
+	);
+	const json = $derived(
+		queried.kind === 'value' && queried.value !== undefined && queried.value !== null
+			? formatToolData(queried.value)
+			: ''
+	);
+</script>
+
+<ToolCard {tool} {compact} {title} icon="lucide:database">
+	{#snippet children()}
+		<ToolCardBody {compact}>
+			<div class="flex flex-wrap items-center gap-1.5">
+				{#if action}
+					<Badge variant="outline" class="text-caption">{action}</Badge>
+				{/if}
+				{#if manifestId}
+					<span class="truncate font-mono text-caption text-muted-foreground">{manifestId}</span>
+				{/if}
+				{#if dataType}
+					<Badge variant="secondary" class="text-caption">{dataType}</Badge>
+				{/if}
+				{#if queried.kind === 'rows'}
+					<span class="text-caption text-muted-foreground">{queried.total} rows</span>
+				{/if}
+			</div>
+
+			{#if action === 'query'}
+				{#if queried.kind === 'rows'}
+					{#if shownRows.length}
+						<ul class="space-y-1">
+							{#each shownRows as row, i (text(row.id) || i)}
+								{@const headline = rowHeadline(row)}
+								<li class="min-w-0">
+									<div class="flex items-center gap-2">
+										<Icon icon="lucide:table" class="size-3.5 shrink-0 text-muted-foreground" />
+										<span class="min-w-0 flex-1 truncate text-xs font-medium text-foreground">
+											{headline.title}
+										</span>
+									</div>
+									{#if headline.meta}
+										<p class="ml-5 truncate font-mono text-caption text-muted-foreground">
+											{headline.meta}
+										</p>
+									{/if}
+								</li>
+							{/each}
+						</ul>
+						{#if queried.rows.length > TOOL_CARD_LIST_LIMIT}
+							<p class="text-caption text-muted-foreground">
+								+{queried.rows.length - TOOL_CARD_LIST_LIMIT} more
+							</p>
+						{/if}
+					{:else}
+						<p class="text-xs text-muted-foreground italic">No rows returned.</p>
+					{/if}
+				{:else if json}
+					<CodeViewer
+						code={json}
+						language={toolBlobLanguage(json, queried.kind === 'value' ? queried.value : null)}
+						appearance="system"
+						maxHeight="16rem"
+						minHeight="0"
+						showLineNumbers={false}
+					/>
+				{:else if output && !tool.error}
+					<p class="text-xs text-muted-foreground italic">No data returned.</p>
+				{/if}
+			{:else if shownManifests.length}
+				<ul class="space-y-1.5">
+					{#each shownManifests as manifest (manifest.id)}
+						<li class="flex min-w-0 items-start gap-2">
+							<Icon icon="lucide:table-2" class="mt-0.5 size-3.5 shrink-0 text-muted-foreground" />
+							<span class="min-w-0 flex-1">
+								<span class="block truncate text-xs font-medium text-foreground"
+									>{manifest.name}</span
+								>
+								<span class="block truncate font-mono text-caption text-muted-foreground">
+									{manifest.id}
+								</span>
+							</span>
+							{#if manifest.dataType}
+								<Badge variant="outline" class="shrink-0 text-caption">{manifest.dataType}</Badge>
+							{/if}
+						</li>
+					{/each}
+				</ul>
+				{#if manifests.length > TOOL_CARD_LIST_LIMIT}
+					<p class="text-caption text-muted-foreground">
+						+{manifests.length - TOOL_CARD_LIST_LIMIT} more
+					</p>
+				{/if}
+			{:else if output && !tool.error}
+				<p class="text-xs text-muted-foreground italic">No storage manifests registered.</p>
+			{/if}
+		</ToolCardBody>
+	{/snippet}
+</ToolCard>

package/dist/svelte/tool-widgets/StorageInspectorToolCard.svelte.d.ts

@@ -0,0 +1,5 @@
+import { type ToolWidgetProps } from '@vibesdotdev/kit/components/tool-widgets';
+declare const StorageInspectorToolCard: import("svelte").Component<ToolWidgetProps, {}, "">;
+type StorageInspectorToolCard = ReturnType<typeof StorageInspectorToolCard>;
+export default StorageInspectorToolCard;
+//# sourceMappingURL=StorageInspectorToolCard.svelte.d.ts.map

package/dist/svelte/tool-widgets/StorageInspectorToolCard.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageInspectorToolCard.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/tool-widgets/StorageInspectorToolCard.svelte.ts"],"names":[],"mappings":"AASA,OAAO,EAKL,KAAK,eAAe,EACpB,MAAM,0CAA0C,CAAC;AA2HnD,QAAA,MAAM,wBAAwB,qDAAwC,CAAC;AACvE,KAAK,wBAAwB,GAAG,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC5E,eAAe,wBAAwB,CAAC"}

package/dist/svelte/tool-widgets/index.d.ts

@@ -0,0 +1,4 @@
+export { default as ComponentsToolCard } from './ComponentsToolCard.svelte';
+export { default as IntegrationOperationToolCard } from './IntegrationOperationToolCard.svelte';
+export { default as StorageInspectorToolCard } from './StorageInspectorToolCard.svelte';
+//# sourceMappingURL=index.d.ts.map

package/dist/svelte/tool-widgets/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/svelte/tool-widgets/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AAChG,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,mCAAmC,CAAC"}

package/dist/svelte/tool-widgets/index.js

@@ -0,0 +1,3 @@
+export { default as ComponentsToolCard } from './ComponentsToolCard.svelte';
+export { default as IntegrationOperationToolCard } from './IntegrationOperationToolCard.svelte';
+export { default as StorageInspectorToolCard } from './StorageInspectorToolCard.svelte';

package/dist/svelte/tool-widgets/presentation.d.ts

@@ -0,0 +1,22 @@
+export declare const TOOL_CARD_LIST_LIMIT = 8;
+import { type ToolPresentationInput, type ToolRecord, type ComponentCardRow, type VersionCardRow, type ManifestCardRow, type InspectedQueryData } from '../../schemas/tool-presentation.ts';
+export type { ComponentCardRow, VersionCardRow, ManifestCardRow, InspectedQueryData } from '../../schemas/tool-presentation.ts';
+export declare function parseComponentRow(value: ToolPresentationInput): ComponentCardRow | null;
+export declare function componentsFromOutput(output: ToolRecord | null): ComponentCardRow[];
+export declare function versionsFromOutput(output: ToolRecord | null): VersionCardRow[];
+export declare function componentsCardTitle(input: ToolRecord | null, output: ToolRecord | null): string;
+export declare function visibilityVariant(visibility: string): 'success' | 'info' | 'outline' | 'secondary';
+export declare function manifestsFromOutput(output: ToolRecord | null): ManifestCardRow[];
+export declare function inspectQueryData(data: ToolPresentationInput): InspectedQueryData;
+export declare function storageInspectorCardTitle(input: ToolRecord | null, output: ToolRecord | null): string;
+export declare function rowHeadline(row: ToolRecord): {
+    title: string;
+    meta: string;
+};
+export declare function integrationLabel(id: string): string;
+export declare function integrationOperationCardTitle(input: ToolRecord | null, output: ToolRecord | null): string;
+export declare function primitiveFields(value: ToolPresentationInput): {
+    key: string;
+    value: string;
+}[];
+//# sourceMappingURL=presentation.d.ts.map

package/dist/svelte/tool-widgets/presentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation.d.ts","sourceRoot":"","sources":["../../../src/svelte/tool-widgets/presentation.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,IAAE,CAAC;AAEpC,OAAO,EAEN,KAAK,qBAAqB,EAAC,KAAK,UAAU,EAAC,KAAK,gBAAgB,EAAC,KAAK,cAAc,EAAC,KAAK,eAAe,EAAC,KAAK,kBAAkB,EACjI,MAAM,oCAAoC,CAAC;AAC5C,YAAY,EAAE,gBAAgB,EAAC,cAAc,EAAC,eAAe,EAAC,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAE7H,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,qBAAqB,GAAG,gBAAgB,GAAC,IAAI,CAgBrF;AAED,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,UAAU,GAAC,IAAI,GACrB,gBAAgB,EAAE,CASpB;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,GAAC,IAAI,GAAG,cAAc,EAAE,CAgB5E;AAED,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,UAAU,GAAC,IAAI,EACtB,MAAM,EAAE,UAAU,GAAC,IAAI,GACrB,MAAM,CAuBR;AAED,wBAAgB,iBAAiB,CAChC,UAAU,EAAE,MAAM,GAChB,SAAS,GAAC,MAAM,GAAC,SAAS,GAAC,WAAW,CAKxC;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,UAAU,GAAC,IAAI,GAAG,eAAe,EAAE,CAkB9E;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,qBAAqB,GAAG,kBAAkB,CAchF;AAED,wBAAgB,yBAAyB,CACxC,KAAK,EAAE,UAAU,GAAC,IAAI,EACtB,MAAM,EAAE,UAAU,GAAC,IAAI,GACrB,MAAM,CASR;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,UAAU;;;EAW1C;AAED,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,wBAAgB,6BAA6B,CAC5C,KAAK,EAAE,UAAU,GAAC,IAAI,EACtB,MAAM,EAAE,UAAU,GAAC,IAAI,GACrB,MAAM,CAQR;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,qBAAqB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAW9F"}

package/dist/svelte/tool-widgets/presentation.js

@@ -0,0 +1,182 @@
+import { countLabel, rec, text } from "./utils.js";
+export const TOOL_CARD_LIST_LIMIT = 8;
+import { ToolPrimitiveSchema, ToolNumberSchema } from "../../schemas/tool-presentation.js";
+export function parseComponentRow(value) {
+    const row = rec(value);
+    if (!row)
+        return null;
+    const id = text(row.id);
+    const name = text(row.name);
+    const slug = text(row.slug);
+    if (!id && !name && !slug)
+        return null;
+    return {
+        id,
+        slug,
+        name: name || slug || id,
+        description: text(row.description),
+        visibility: text(row.visibility),
+        publishedVersion: text(row.publishedVersion) || text(row.version),
+        editorUrl: text(row.editorUrl)
+    };
+}
+export function componentsFromOutput(output) {
+    if (!output)
+        return [];
+    if (Array.isArray(output.components)) {
+        return output.components
+            .map(parseComponentRow)
+            .filter((row) => row !== null);
+    }
+    const single = parseComponentRow(output.component);
+    return single ? [single] : [];
+}
+export function versionsFromOutput(output) {
+    if (!output || !Array.isArray(output.versions))
+        return [];
+    return output.versions
+        .map((item) => {
+        const row = rec(item);
+        if (!row)
+            return null;
+        const version = text(row.version);
+        if (!version)
+            return null;
+        return {
+            version,
+            publishedAt: text(row.publishedAt),
+            bundleHash: text(row.bundleHash),
+            warningCount: Array.isArray(row.compileWarnings) ? row.compileWarnings.length : 0
+        };
+    })
+        .filter((row) => row !== null);
+}
+export function componentsCardTitle(input, output) {
+    const action = text(input?.action) || text(output?.action);
+    const rows = componentsFromOutput(output);
+    const primary = rows[0];
+    const componentRef = text(output?.componentRef);
+    const versionCount = versionsFromOutput(output).length;
+    switch (action) {
+        case 'list':
+            return output ? `Listed ${countLabel(rows.length, 'component')}` : 'Listing components';
+        case 'get':
+            return primary?.name || 'Opened component';
+        case 'create':
+            return primary?.name ? `Created ${primary.name}` : 'Created component';
+        case 'update':
+            return primary?.name ? `Updated ${primary.name}` : 'Updated component';
+        case 'publish':
+            return componentRef ? `Published ${componentRef}` : 'Published component';
+        case 'versions':
+            return output ? countLabel(versionCount, 'version') : 'Component versions';
+        default:
+            return primary?.name || 'Components';
+    }
+}
+export function visibilityVariant(visibility) {
+    if (visibility === 'public')
+        return 'success';
+    if (visibility === 'org')
+        return 'info';
+    if (visibility === 'private')
+        return 'outline';
+    return 'secondary';
+}
+export function manifestsFromOutput(output) {
+    if (!output || !Array.isArray(output.manifests))
+        return [];
+    return output.manifests
+        .map((item) => {
+        const row = rec(item);
+        if (!row)
+            return null;
+        const id = text(row.id);
+        if (!id)
+            return null;
+        return {
+            id,
+            name: text(row.name) || id,
+            description: text(row.description),
+            dataType: text(row.dataType),
+            scope: text(row.scope),
+            namespace: text(row.namespace)
+        };
+    })
+        .filter((row) => row !== null);
+}
+export function inspectQueryData(data) {
+    if (data === undefined || data === null)
+        return { kind: 'value', value: data };
+    if (Array.isArray(data)) {
+        const rows = data.map(rec).filter((row) => row !== null);
+        if (rows.length === data.length)
+            return { kind: 'rows', rows, total: rows.length };
+        return { kind: 'value', value: data };
+    }
+    const obj = rec(data);
+    if (!obj)
+        return { kind: 'value', value: data };
+    const list = Array.isArray(obj.items) ? obj.items : Array.isArray(obj.results) ? obj.results : null;
+    if (!list)
+        return { kind: 'value', value: data };
+    const rows = list.map(rec).filter((row) => row !== null);
+    const total = ToolNumberSchema.safeParse(obj.total);
+    return { kind: 'rows', rows, total: total.success ? total.data : rows.length };
+}
+export function storageInspectorCardTitle(input, output) {
+    const action = text(input?.action) || text(output?.action);
+    const manifestId = text(output?.manifestId) || text(input?.manifestId);
+    if (action === 'query')
+        return manifestId ? `Queried ${manifestId}` : 'Queried storage';
+    if (action === 'list-manifests' || !action) {
+        if (output)
+            return `Listed ${countLabel(manifestsFromOutput(output).length, 'manifest')}`;
+        return 'Listing storage manifests';
+    }
+    return 'Storage inspector';
+}
+export function rowHeadline(row) {
+    const title = text(row.name) || text(row.title) || text(row.id) || text(row.slug) || text(row.key) || 'Record';
+    const skip = new Set(['name', 'title']);
+    const parts = [];
+    for (const [key, value] of Object.entries(row)) {
+        if (skip.has(key) || !ToolPrimitiveSchema.safeParse(value).success)
+            continue;
+        parts.push(`${key} ${String(value)}`);
+        if (parts.length >= 3)
+            break;
+    }
+    return { title, meta: parts.join(' · ') };
+}
+export function integrationLabel(id) {
+    return id.replace(/^integration\./, '');
+}
+export function integrationOperationCardTitle(input, output) {
+    const operationId = text(input?.operationId) || text(output?.operationId);
+    const integrationId = text(input?.integrationId) || text(output?.integrationId);
+    const name = integrationId ? integrationLabel(integrationId) : '';
+    if (operationId && name)
+        return `${operationId} on ${name}`;
+    if (operationId)
+        return operationId;
+    if (name)
+        return `Connected ${name}`;
+    return 'Connected API operation';
+}
+export function primitiveFields(value) {
+    const row = rec(value);
+    if (!row)
+        return [];
+    const fields = [];
+    for (const [key, nested] of Object.entries(row)) {
+        if (nested === undefined || nested === null)
+            continue;
+        if (!ToolPrimitiveSchema.safeParse(nested).success)
+            return [];
+        fields.push({ key, value: String(nested) });
+        if (fields.length > 12)
+            break;
+    }
+    return fields;
+}

package/dist/svelte/tool-widgets/utils.d.ts

@@ -0,0 +1,5 @@
+import { type ToolPresentationInput, type ToolRecord } from '../../schemas/tool-presentation.ts';
+export declare function rec(value: ToolPresentationInput): ToolRecord | null;
+export declare function text(value: ToolPresentationInput): string;
+export declare function countLabel(count: number, singular: string, plural?: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/svelte/tool-widgets/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/svelte/tool-widgets/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,qBAAqB,EAAC,KAAK,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAEhI,wBAAgB,GAAG,CAAC,KAAK,EAAE,qBAAqB,GAAG,UAAU,GAAC,IAAI,CAGjE;AAED,wBAAgB,IAAI,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,CAGzD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAC,QAAQ,EAAE,MAAM,EAAC,MAAM,SAAe,GAAG,MAAM,CAEvF"}

package/dist/svelte/tool-widgets/utils.js

@@ -0,0 +1,12 @@
+import { ToolRecordSchema, ToolTextSchema } from "../../schemas/tool-presentation.js";
+export function rec(value) {
+    const result = ToolRecordSchema.safeParse(value);
+    return result.success ? result.data : null;
+}
+export function text(value) {
+    const result = ToolTextSchema.safeParse(value);
+    return result.success ? result.data : '';
+}
+export function countLabel(count, singular, plural = `${singular}s`) {
+    return count === 1 ? `1 ${singular}` : `${count} ${plural}`;
+}

package/dist/tools/components.descriptor.d.ts

@@ -0,0 +1,177 @@
+import * as z from 'zod/v4';
+export declare const ComponentsActionInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"list">;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+        org: "org";
+    }>>;
+    slug: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"get">;
+    componentId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    slug: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    manifest: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        props: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        surfaces: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        shadowDom: z.ZodDefault<z.ZodBoolean>;
+        extra: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+        org: "org";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"update">;
+    componentId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    source: z.ZodOptional<z.ZodString>;
+    manifest: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        props: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        surfaces: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        shadowDom: z.ZodDefault<z.ZodBoolean>;
+        extra: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+        org: "org";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"publish">;
+    componentId: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"versions">;
+    componentId: z.ZodString;
+}, z.core.$strip>], "action">;
+/** Wire-envelope: no top-level ok; domain fields vary by action; failures throw. */
+export declare const ComponentsActionOutputSchema: z.ZodObject<{
+    componentRef: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type ComponentsActionInput = z.infer<typeof ComponentsActionInputSchema>;
+export type ComponentsActionOutput = z.infer<typeof ComponentsActionOutputSchema>;
+declare const _default: {
+    readonly kind: "tools/tool";
+    readonly id: "components";
+    readonly name: "Components";
+    readonly description: "Create, edit, publish, and list platform Components — user-authored Svelte components compiled and versioned by the platform. To use a published component as an HQ applet, take publish result.componentRef and call applet create { componentRef, title }; HQ renders it cross-origin only when visibility is public.";
+    readonly mcpDescription: "Author platform Components. Publish, then call applet create { componentRef, title }. Cross-origin HQ rendering requires public component visibility.";
+    readonly hardware: readonly ["consumer", "cloud"];
+    readonly purpose: ["direct", "worker", "mcp", "agent"];
+    readonly category: "platform";
+    readonly subcategory: "components";
+    readonly tags: readonly ["platform", "components", "ui", "registry", "write"];
+    readonly safety: "write";
+    readonly requiresApproval: false;
+    readonly schemas: {
+        readonly input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            action: z.ZodLiteral<"list">;
+            visibility: z.ZodOptional<z.ZodEnum<{
+                public: "public";
+                private: "private";
+                org: "org";
+            }>>;
+            slug: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            offset: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            action: z.ZodLiteral<"get">;
+            componentId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            action: z.ZodLiteral<"create">;
+            slug: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            source: z.ZodOptional<z.ZodString>;
+            manifest: z.ZodOptional<z.ZodObject<{
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                icon: z.ZodOptional<z.ZodString>;
+                capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                props: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                surfaces: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                shadowDom: z.ZodDefault<z.ZodBoolean>;
+                extra: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+            visibility: z.ZodOptional<z.ZodEnum<{
+                public: "public";
+                private: "private";
+                org: "org";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            action: z.ZodLiteral<"update">;
+            componentId: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            source: z.ZodOptional<z.ZodString>;
+            manifest: z.ZodOptional<z.ZodObject<{
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                icon: z.ZodOptional<z.ZodString>;
+                capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                props: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                surfaces: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                shadowDom: z.ZodDefault<z.ZodBoolean>;
+                extra: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+            visibility: z.ZodOptional<z.ZodEnum<{
+                public: "public";
+                private: "private";
+                org: "org";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            action: z.ZodLiteral<"publish">;
+            componentId: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            action: z.ZodLiteral<"versions">;
+            componentId: z.ZodString;
+        }, z.core.$strip>], "action">;
+        readonly output: z.ZodObject<{
+            componentRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        readonly defaultAction: "list";
+    };
+    readonly examples: [{
+        readonly description: "Create a draft component";
+        readonly input: {
+            readonly action: "create";
+            readonly slug: "usage-chart";
+            readonly name: "Usage Chart";
+            readonly source: "<script>let { total = 0 } = $props();</script>\n<strong>{total}</strong>";
+        };
+    }, {
+        readonly description: "Publish a public component, then create an HQ applet from its componentRef";
+        readonly input: {
+            readonly action: "publish";
+            readonly componentId: "4f6b2c1e-0000-0000-0000-000000000000";
+        };
+        readonly notes: "Compiles server-side and returns componentRef. Feed it into applet create { componentRef, title }; the component visibility must be public for HQ cross-origin rendering.";
+    }, {
+        readonly description: "List your components";
+        readonly input: {
+            readonly action: "list";
+            readonly limit: 20;
+        };
+    }];
+};
+export default _default;
+//# sourceMappingURL=components.descriptor.d.ts.map

package/dist/tools/components.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.descriptor.d.ts","sourceRoot":"","sources":["../../src/tools/components.descriptor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AA0E5B,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAOtC,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElF,wBAyCG"}