@vibesdotdev/applets 0.0.0-stage → 1.0.0-rc.3

package/dist/svelte/runnable-source.d.ts

@@ -0,0 +1,5 @@
+import type { RunnableClient } from '@vibesdotdev/runnable';
+import type { AppletRootSurface } from '../applet-root-surface.ts';
+export type AppletRunsSource = Pick<RunnableClient, 'runs' | 'snapshot' | 'watch' | 'watchCatalog' | 'describe' | 'visualizations' | 'control' | 'appendEvent'>;
+export declare function appletRunsSource(surface: Pick<AppletRootSurface, 'runtimeCall'>): AppletRunsSource;
+//# sourceMappingURL=runnable-source.d.ts.map

package/dist/svelte/runnable-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runnable-source.d.ts","sourceRoot":"","sources":["../../src/svelte/runnable-source.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAwB,MAAM,uBAAuB,CAAC;AAIlF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAGnE,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,GAAG,cAAc,GAAG,UAAU,GAAG,gBAAgB,GAAG,SAAS,GAAG,aAAa,CAAC,CAAC;AAEhK,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,iBAAiB,EAAE,aAAa,CAAC,GAAG,gBAAgB,CAuFlG"}

package/dist/svelte/runnable-source.js

@@ -0,0 +1,92 @@
+/** Runnable's canonical read/watch/control surface over the applet's admitted runtime connection. */
+import * as z from 'zod/v4';
+import { CapabilityError, CaughtFailureSchema } from '@vibesdotdev/kernel';
+import { isRpcFailure, RpcErrorSchema } from '@vibesdotdev/kernel-rpc';
+import { JsonObjectSchema, JsonValueSchema, JsonValueFromReaderSchema } from '@vibesdotdev/kernel/schemas/json';
+import { RunnableDescriptionSchema, RunnableVisualizationDescriptorSchema } from '@vibesdotdev/runnable';
+import { RunnableReadQuerySchema, RunnableSnapshotSchema, RunnableTrackedRunSchema, RunnableWatchSnapshotSchema, RunnableCatalogWatchSnapshotSchema, RunnableWatchArgumentSchema, RunnableWatchOptionsSchema } from '@vibesdotdev/runnable/schemas/runs';
+import { FailureFactsSchema } from '@vibesdotdev/runnable/schemas/outcome';
+import { appletRuntimeCallbackSchema } from "../applet-root-surface.js";
+export function appletRunsSource(surface) {
+    const remoteCall = surface.runtimeCall.bind(surface, 'runtime/client', 'runnable');
+    async function invoke(work) {
+        try {
+            return await work();
+        }
+        catch (cause) {
+            const failure = CaughtFailureSchema.parse(cause);
+            if (!isRpcFailure(failure))
+                throw failure;
+            throw new CapabilityError(failure.message, 'UNAVAILABLE', {
+                reason: 'applet-runtime-rpc-failed', cause: failure,
+                details: JsonObjectSchema.parse(JsonValueFromReaderSchema.parse({ rpc: RpcErrorSchema.parse(failure.toJSON()) }))
+            });
+        }
+    }
+    const call = (...args) => invoke(() => remoteCall(...args));
+    async function describe(id, receive) {
+        let delivered;
+        await call('describe', id, async (value) => {
+            if (delivered !== undefined)
+                throw new CapabilityError('Runnable description was delivered more than once.', 'INVALID_INPUT', {
+                    reason: 'runnable-description-delivery-repeated'
+                });
+            delivered = RunnableDescriptionSchema.parse(value);
+            if (receive)
+                await receive(delivered);
+        });
+        if (delivered === undefined)
+            throw new CapabilityError('Runnable owner returned without delivering its description.', 'UNAVAILABLE', {
+                reason: 'runnable-description-delivery-missing'
+            });
+        if (!receive)
+            return delivered;
+    }
+    const watch = async (query, listener, failureOrOptions, nativeOptions) => {
+        const options = RunnableWatchOptionsSchema.parse({
+            ...nativeOptions, ...RunnableWatchArgumentSchema.parse(failureOrOptions)
+        });
+        if (options.signal !== undefined) {
+            throw new CapabilityError('Applet watches inherit their runtime connection lifetime.', 'INVALID_INPUT', {
+                reason: 'rpc-cancellation-unsupported', retryable: false
+            });
+        }
+        const receive = async (value) => {
+            await listener(RunnableWatchSnapshotSchema.parse(value));
+        };
+        const failure = async (value) => {
+            const facts = FailureFactsSchema.parse(value);
+            if (options.onError)
+                await options.onError(facts);
+            else
+                throw new CapabilityError(facts.message, 'UNAVAILABLE', { reason: 'runnable-watch-failed', details: JsonObjectSchema.parse(facts) });
+        };
+        const projection = options.projection === undefined ? undefined : { projection: options.projection };
+        const stop = appletRuntimeCallbackSchema.parse(await call('watch', RunnableReadQuerySchema.strict().parse(query), receive, failure, ...(projection ? [projection] : [])));
+        return async () => { await invoke(() => stop()); };
+    };
+    return {
+        runs: async (query) => z.array(RunnableTrackedRunSchema).parse(await call('runs', RunnableReadQuerySchema.strict().parse(query ?? {}))),
+        snapshot: async (id) => RunnableSnapshotSchema.parse(await call('snapshot', id)),
+        describe,
+        watch,
+        watchCatalog: async (query, listener, failureOrOptions) => {
+            const options = RunnableWatchOptionsSchema.parse(RunnableWatchArgumentSchema.parse(failureOrOptions));
+            if (options.signal !== undefined)
+                throw new CapabilityError('Applet watches inherit their runtime connection lifetime.', 'INVALID_INPUT', {
+                    reason: 'rpc-cancellation-unsupported', retryable: false
+                });
+            const stop = appletRuntimeCallbackSchema.parse(await call('watchCatalog', RunnableReadQuerySchema.strict().parse(query), async (value) => { await listener(RunnableCatalogWatchSnapshotSchema.parse(value)); }, async (value) => {
+                const facts = FailureFactsSchema.parse(value);
+                if (options.onError)
+                    await options.onError(facts);
+                else
+                    throw new CapabilityError(facts.message, 'UNAVAILABLE', { reason: 'runnable-watch-failed', details: JsonObjectSchema.parse(facts) });
+            }));
+            return async () => { await invoke(() => stop()); };
+        },
+        visualizations: async (query) => z.array(RunnableVisualizationDescriptorSchema).parse(await call('visualizations', JsonValueSchema.parse(query))),
+        appendEvent: async (runId, type, payload) => { await call('appendEvent', runId, type, JsonObjectSchema.parse(payload)); },
+        control: async (input) => z.boolean().parse(await call('control', { runId: input.runId, action: input.action }))
+    };
+}

package/dist/svelte/serve-index.svelte

@@ -0,0 +1,39 @@
+<script lang="ts">
+	import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@vibesdotdev/kit/svelte';
+	import { Badge } from '@vibesdotdev/kit/svelte';
+	import { Button } from '@vibesdotdev/kit/svelte';
+
+	let { applets = [] }: { applets?: { id: string; entry: string }[] } = $props();
+</script>
+
+<div class="shell">
+	<Card class="w-full max-w-md">
+		<CardHeader>
+			<CardTitle>Local applets</CardTitle>
+			<CardDescription>One server, every project under /applet/&#123;id&#125;/</CardDescription>
+		</CardHeader>
+		<CardContent class="list">
+			{#if applets.length === 0}
+				<p class="empty">No applet projects yet — create one under .vibes/applets/.</p>
+			{:else}
+				{#each applets as a (a.id)}
+					<a class="row" href="/applet/{a.id}/">
+						<Button variant="outline" class="row-btn">
+							<span class="row-id">{a.id}</span>
+							<Badge variant="secondary">{a.entry}</Badge>
+						</Button>
+					</a>
+				{/each}
+			{/if}
+		</CardContent>
+	</Card>
+</div>
+
+<style>
+	.shell { min-height: 100vh; display: flex; align-items: center; justify-content: center; padding: 24px; }
+	.shell :global(.list) { display: flex; flex-direction: column; gap: 8px; }
+	.row { text-decoration: none; }
+	.shell :global(.row-btn) { width: 100%; display: flex; justify-content: space-between; align-items: center; }
+	.row-id { font-family: ui-monospace, Menlo, monospace; font-size: 13px; }
+	.empty { font-size: 13px; opacity: 0.7; }
+</style>

package/dist/svelte/serve-index.svelte.d.ts

@@ -0,0 +1,10 @@
+type $$ComponentProps = {
+    applets?: {
+        id: string;
+        entry: string;
+    }[];
+};
+declare const ServeIndex: import("svelte").Component<$$ComponentProps, {}, "">;
+type ServeIndex = ReturnType<typeof ServeIndex>;
+export default ServeIndex;
+//# sourceMappingURL=serve-index.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serve-index.svelte.d.ts","sourceRoot":"","sources":["../../src/svelte/serve-index.svelte.ts"],"names":[],"mappings":"AAOC,KAAK,gBAAgB,GAAI;IAAE,OAAO,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,CAAC;AAoCxE,QAAA,MAAM,UAAU,sDAAwC,CAAC;AACzD,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AAChD,eAAe,UAAU,CAAC"}

package/dist/svelte/state.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { CanvasState } from './lib/canvas-lifecycle.ts';
+export declare function createCanvasState(): {
+    readonly state: CanvasState;
+    readonly consented: boolean;
+    readonly runnerMounted: boolean;
+    readonly heartbeatCount: number;
+    readonly error: string | null;
+    readonly canMountRunner: boolean;
+    readonly canFetchBundle: boolean;
+    readonly isTerminal: boolean;
+    readonly isErrorState: boolean;
+    transitionToReady(): void;
+    transitionToApproved(): void;
+    transitionToMounted(): void;
+    transitionToRunning(): void;
+    recordHeartbeat(): void;
+    transitionToCrashed(error: string): void;
+    transitionToUnresponsive(): void;
+    transitionToRevoked(): void;
+    transitionToExpired(): void;
+    transitionToDisposed(): void;
+    /** Reset to a fresh loading context (for re-mount after dispose). */
+    reset(): void;
+};
+export type CanvasStateStore = ReturnType<typeof createCanvasState>;
+//# sourceMappingURL=state.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state.svelte.d.ts","sourceRoot":"","sources":["../../src/svelte/state.svelte.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAiB,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE5E,wBAAgB,iBAAiB;oBAIlB,WAAW;wBAGP,OAAO;4BAGH,OAAO;6BAGN,MAAM;oBAGf,MAAM,GAAG,IAAI;6BAGJ,OAAO;6BAGP,OAAO;yBAGX,OAAO;2BAGL,OAAO;;;;;;+BAkBA,MAAM;;;;;IAejC,qEAAqE;;EAKtE;AAED,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/svelte/state.svelte.js

@@ -0,0 +1,74 @@
+/**
+ * Reactive canvas state — runes wrapper over the pure lifecycle module.
+ *
+ * Components import this to get reactive access to the canvas state.
+ * Pure logic (transitions, guards) lives in `./lib/canvas-lifecycle.ts`.
+ */
+import { untrack } from 'svelte';
+import * as lifecycle from "./lib/canvas-lifecycle.js";
+export function createCanvasState() {
+    let ctx = $state(lifecycle.createCanvasContext());
+    return {
+        get state() {
+            return ctx.state;
+        },
+        get consented() {
+            return ctx.consented;
+        },
+        get runnerMounted() {
+            return ctx.runnerMounted;
+        },
+        get heartbeatCount() {
+            return ctx.heartbeatCount;
+        },
+        get error() {
+            return ctx.error;
+        },
+        get canMountRunner() {
+            return lifecycle.canMountRunner(ctx);
+        },
+        get canFetchBundle() {
+            return lifecycle.canFetchBundle(ctx);
+        },
+        get isTerminal() {
+            return lifecycle.isTerminal(ctx);
+        },
+        get isErrorState() {
+            return lifecycle.isErrorState(ctx);
+        },
+        transitionToReady() {
+            ctx = untrack(() => lifecycle.transitionToReady(ctx));
+        },
+        transitionToApproved() {
+            ctx = untrack(() => lifecycle.transitionToApproved(ctx));
+        },
+        transitionToMounted() {
+            ctx = untrack(() => lifecycle.transitionToMounted(ctx));
+        },
+        transitionToRunning() {
+            ctx = untrack(() => lifecycle.transitionToRunning(ctx));
+        },
+        recordHeartbeat() {
+            ctx = untrack(() => lifecycle.recordHeartbeat(ctx));
+        },
+        transitionToCrashed(error) {
+            ctx = untrack(() => lifecycle.transitionToCrashed(ctx, error));
+        },
+        transitionToUnresponsive() {
+            ctx = untrack(() => lifecycle.transitionToUnresponsive(ctx));
+        },
+        transitionToRevoked() {
+            ctx = untrack(() => lifecycle.transitionToRevoked(ctx));
+        },
+        transitionToExpired() {
+            ctx = untrack(() => lifecycle.transitionToExpired(ctx));
+        },
+        transitionToDisposed() {
+            ctx = untrack(() => lifecycle.transitionToDisposed(ctx));
+        },
+        /** Reset to a fresh loading context (for re-mount after dispose). */
+        reset() {
+            ctx = lifecycle.createCanvasContext();
+        }
+    };
+}

package/dist/svelte/styles.css

@@ -0,0 +1,4 @@
+@import '@vibesdotdev/runnable/svelte/styles.css';
+@import '@vibesdotdev/tools/svelte/styles.css';
+
+@source "./";

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

@@ -0,0 +1,148 @@
+<script lang="ts">
+	/**
+	 * First-party widget for `applet`: create, list, get, update-source,
+	 * templates, and adopt — not a JSON dump.
+	 */
+	import { Badge } from '@vibesdotdev/kit/components/ui/badge';
+	import { Icon } from '@vibesdotdev/kit/components/icon';
+	import {
+		ToolCard,
+		ToolCardBody,
+		type ToolWidgetProps
+	} from '@vibesdotdev/kit/components/tool-widgets';
+	import {
+		APPLET_TOOL_CARD_LIST_LIMIT,
+		APPLET_TOOL_ICON,
+		projectAppletToolCard
+	} from './applet-tool-card.js';
+
+	let { tool, compact = false }: ToolWidgetProps = $props();
+
+	const model = $derived(projectAppletToolCard(tool.input, tool.output));
+	const listedApplets = $derived(model.applets.slice(0, APPLET_TOOL_CARD_LIST_LIMIT));
+	const listedTemplates = $derived(model.templates.slice(0, APPLET_TOOL_CARD_LIST_LIMIT));
+	const listedAdoptions = $derived(model.adoptions.slice(0, APPLET_TOOL_CARD_LIST_LIMIT));
+	const pending = $derived(tool.output === undefined || tool.output === null);
+</script>
+
+<ToolCard {tool} {compact} title={model.title} icon={APPLET_TOOL_ICON}>
+	{#snippet children()}
+		<ToolCardBody {compact}>
+			<div class="flex flex-wrap items-center gap-1.5">
+				{#if model.action}
+					<Badge variant="outline" class="text-caption">{model.action}</Badge>
+				{/if}
+				{#if model.applet?.status}
+					<Badge variant="secondary" class="text-caption">{model.applet.status}</Badge>
+				{/if}
+				{#if model.applet?.store}
+					<Badge variant="outline" class="text-caption">{model.applet.store}</Badge>
+				{/if}
+			</div>
+
+			{#if pending && !tool.error}
+				<p class="text-muted-foreground italic">Working…</p>
+			{/if}
+
+			{#if model.message}
+				<p class="text-muted-foreground">{model.message}</p>
+			{/if}
+
+			{#if model.instanceId}
+				<p class="font-mono text-caption text-muted-foreground">instance {model.instanceId}</p>
+			{/if}
+
+			{#if model.instanceWarning}
+				<p class="text-muted-foreground">{model.instanceWarning}</p>
+			{/if}
+
+			{#if model.applet}
+				<div class="space-y-1">
+					{#if model.applet.componentRef}
+						<p class="truncate font-mono text-caption text-muted-foreground">
+							{model.applet.componentRef}
+						</p>
+					{/if}
+					{#if model.applet.url}
+						<a
+							href={model.applet.url}
+							class="break-all font-mono text-foreground underline-offset-2 hover:underline"
+							target="_blank"
+							rel="noopener noreferrer">{model.applet.url}</a
+						>
+					{/if}
+				</div>
+			{/if}
+
+			{#if listedApplets.length}
+				<ul class="space-y-1.5">
+					{#each listedApplets as row (row.id)}
+						<li class="flex min-w-0 items-center gap-2">
+							<Icon icon="lucide:app-window" class="size-3.5 shrink-0 text-muted-foreground" />
+							<span class="min-w-0 flex-1 truncate font-medium">{row.summary || row.id}</span>
+							{#if row.status}
+								<span class="shrink-0 text-caption text-muted-foreground">{row.status}</span>
+							{/if}
+						</li>
+					{/each}
+				</ul>
+				{#if model.applets.length > APPLET_TOOL_CARD_LIST_LIMIT}
+					<p class="text-muted-foreground">
+						{model.applets.length - APPLET_TOOL_CARD_LIST_LIMIT} more
+					</p>
+				{/if}
+			{/if}
+
+			{#if listedTemplates.length}
+				<ul class="space-y-1.5">
+					{#each listedTemplates as row (row.id)}
+						<li class="min-w-0">
+							<div class="flex min-w-0 items-center gap-2">
+								<Icon
+									icon="lucide:layout-template"
+									class="size-3.5 shrink-0 text-muted-foreground"
+								/>
+								<span class="min-w-0 flex-1 truncate font-medium">{row.name}</span>
+							</div>
+							{#if row.description}
+								<p class="ml-5 line-clamp-2 text-caption text-muted-foreground">
+									{row.description}
+								</p>
+							{/if}
+						</li>
+					{/each}
+				</ul>
+				{#if model.templates.length > APPLET_TOOL_CARD_LIST_LIMIT}
+					<p class="text-muted-foreground">
+						{model.templates.length - APPLET_TOOL_CARD_LIST_LIMIT} more
+					</p>
+				{/if}
+			{/if}
+
+			{#if listedAdoptions.length}
+				<ul class="space-y-1.5">
+					{#each listedAdoptions as row (`${row.sourceAppletId}:${row.adoptedAppletId}`)}
+						<li class="min-w-0">
+							<p class="truncate font-mono text-caption">
+								{row.sourceAppletId} → {row.adoptedAppletId}
+							</p>
+							{#if row.url}
+								<a
+									href={row.url}
+									class="break-all font-mono text-caption text-muted-foreground underline-offset-2 hover:underline"
+									target="_blank"
+									rel="noopener noreferrer">{row.url}</a
+								>
+							{/if}
+						</li>
+					{/each}
+				</ul>
+				{#if model.adoptions.length > APPLET_TOOL_CARD_LIST_LIMIT}
+					<p class="text-muted-foreground">
+						{model.adoptions.length - APPLET_TOOL_CARD_LIST_LIMIT} more
+					</p>
+				{/if}
+			{/if}
+		</ToolCardBody>
+	{/snippet}
+</ToolCard>

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppletToolCard.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/tool-widgets/AppletToolCard.svelte.ts"],"names":[],"mappings":"AASA,OAAO,EAGL,KAAK,eAAe,EACpB,MAAM,0CAA0C,CAAC;AAsInD,QAAA,MAAM,cAAc,qDAAwC,CAAC;AAC7D,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AACxD,eAAe,cAAc,CAAC"}

package/dist/svelte/tool-widgets/applet-tool-card.d.ts

@@ -0,0 +1,41 @@
+export declare const APPLET_TOOL_ID = "applet";
+export declare const APPLET_TOOL_ICON = "lucide:app-window";
+export declare const APPLET_TOOL_CARD_LIST_LIMIT = 8;
+declare const ACTIONS: readonly ["create", "list", "get", "update-source", "templates", "adopt"];
+export type AppletToolAction = (typeof ACTIONS)[number];
+export declare function isAppletToolAction(value: string): value is AppletToolAction;
+export type AppletCardRow = {
+    id: string;
+    summary: string;
+    status: string;
+    store: string;
+    url: string;
+    componentRef: string;
+    visibility: string;
+};
+export type AppletTemplateRow = {
+    id: string;
+    name: string;
+    description: string;
+    componentRef: string;
+};
+export type AppletAdoptionRow = {
+    sourceAppletId: string;
+    adoptedAppletId: string;
+    url: string;
+};
+export type AppletToolCardModel = {
+    action: string;
+    known: boolean;
+    title: string;
+    applet: AppletCardRow | null;
+    applets: AppletCardRow[];
+    templates: AppletTemplateRow[];
+    adoptions: AppletAdoptionRow[];
+    instanceId: string;
+    instanceWarning: string;
+    message: string;
+};
+export declare function projectAppletToolCard(input: unknown, output: unknown): AppletToolCardModel;
+export {};
+//# sourceMappingURL=applet-tool-card.d.ts.map

package/dist/svelte/tool-widgets/applet-tool-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applet-tool-card.d.ts","sourceRoot":"","sources":["../../../src/svelte/tool-widgets/applet-tool-card.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,cAAc,WAAW,CAAC;AACvC,eAAO,MAAM,gBAAgB,sBAAsB,CAAC;AACpD,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C,QAAA,MAAM,OAAO,2EAA4E,CAAC;AAC1F,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAIxD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,gBAAgB,CAE3E;AAED,MAAM,MAAM,aAAa,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAC/B,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CAChB,CAAC;AAgHF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,mBAAmB,CA2D1F"}

package/dist/svelte/tool-widgets/applet-tool-card.js

@@ -0,0 +1,167 @@
+/**
+ * Projection for the first-party `applet` Kit ToolCard.
+ *
+ * Pure so titles and rows can be proven without mounting Svelte. The widget is
+ * a thin view over this model.
+ */
+import * as z from 'zod/v4';
+export const APPLET_TOOL_ID = 'applet';
+export const APPLET_TOOL_ICON = 'lucide:app-window';
+export const APPLET_TOOL_CARD_LIST_LIMIT = 8;
+const ACTIONS = ['create', 'list', 'get', 'update-source', 'templates', 'adopt'];
+const actionSet = new Set(ACTIONS);
+export function isAppletToolAction(value) {
+    return actionSet.has(value);
+}
+const appletRowSchema = z.object({
+    id: z.string().min(1),
+    summary: z.string().optional().default(''),
+    status: z.string().optional().default(''),
+    store: z.string().optional().default(''),
+    url: z.string().optional().default(''),
+    componentRef: z.string().optional().default(''),
+    visibility: z.string().optional().default('')
+});
+const templateRowSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    description: z.string().optional().default(''),
+    componentRef: z.string().optional().default('')
+});
+const adoptionRowSchema = z.object({
+    sourceAppletId: z.string().min(1),
+    adoptedAppletId: z.string().min(1),
+    url: z.string().optional().default('')
+});
+const appletToolCardInputSchema = z.object({
+    action: z.string().optional(),
+    title: z.string().optional()
+}).passthrough();
+const appletToolCardOutputSchema = z.object({
+    action: z.string().optional(),
+    applet: appletRowSchema.optional().nullable(),
+    applets: z.array(z.unknown()).optional(),
+    templates: z.array(z.unknown()).optional(),
+    adoptions: z.array(z.unknown()).optional(),
+    instanceId: z.string().optional().default(''),
+    instanceWarning: z.string().optional().default(''),
+    message: z.string().optional().default('')
+}).passthrough();
+function inferAction(inputAction, output) {
+    if (inputAction)
+        return inputAction;
+    if (output?.templates !== undefined)
+        return 'templates';
+    if (output?.adoptions !== undefined)
+        return 'adopt';
+    if (output?.applets !== undefined)
+        return 'list';
+    if (output?.applet)
+        return 'get';
+    return '';
+}
+function countLabel(count, singular, plural, empty) {
+    if (count <= 0)
+        return empty;
+    if (count === 1)
+        return `1 ${singular}`;
+    return `${count} ${plural}`;
+}
+function titleFor(action, model, pending, inputTitle) {
+    if (pending) {
+        switch (action) {
+            case 'create':
+                return inputTitle ? `Creating ${inputTitle}` : 'Creating applet';
+            case 'list':
+                return 'Listing applets';
+            case 'get':
+                return 'Loading applet';
+            case 'update-source':
+                return 'Updating applet';
+            case 'templates':
+                return 'Loading templates';
+            case 'adopt':
+                return 'Adopting applet';
+            default:
+                return 'Applets';
+        }
+    }
+    switch (action) {
+        case 'create':
+            return model.applet?.summary || inputTitle || 'Created applet';
+        case 'list':
+            return countLabel(model.applets.length, 'applet', 'applets', 'No applets');
+        case 'get':
+            return model.applet?.summary || 'Applet';
+        case 'update-source':
+            return model.applet?.summary || 'Updated applet';
+        case 'templates':
+            return countLabel(model.templates.length, 'template', 'templates', 'No templates');
+        case 'adopt':
+            return (model.message ||
+                (model.adoptions.length
+                    ? countLabel(model.adoptions.length, 'applet adopted', 'applets adopted', 'No applets adopted')
+                    : model.applet?.summary) ||
+                'Adopt applet');
+        default:
+            return model.applet?.summary || model.message || 'Applets';
+    }
+}
+export function projectAppletToolCard(input, output) {
+    const parsedInput = appletToolCardInputSchema.safeParse(input);
+    const parsedOutput = appletToolCardOutputSchema.nullable().optional().safeParse(output);
+    let inputData = null;
+    if (parsedInput.success) {
+        inputData = parsedInput.data;
+    }
+    let outputData = null;
+    let pending = true;
+    if (parsedOutput.success) {
+        outputData = parsedOutput.data ?? null;
+        pending = parsedOutput.data === undefined || parsedOutput.data === null;
+    }
+    const action = inferAction(inputData?.action, outputData);
+    const applet = outputData?.applet ?? null;
+    const applets = [];
+    if (outputData?.applets) {
+        for (const item of outputData.applets) {
+            const parsed = appletRowSchema.safeParse(item);
+            if (parsed.success)
+                applets.push(parsed.data);
+        }
+    }
+    const templates = [];
+    if (outputData?.templates) {
+        for (const item of outputData.templates) {
+            const parsed = templateRowSchema.safeParse(item);
+            if (parsed.success)
+                templates.push(parsed.data);
+        }
+    }
+    const adoptions = [];
+    if (outputData?.adoptions) {
+        for (const item of outputData.adoptions) {
+            const parsed = adoptionRowSchema.safeParse(item);
+            if (parsed.success)
+                adoptions.push(parsed.data);
+        }
+    }
+    const instanceId = outputData?.instanceId ?? '';
+    const instanceWarning = outputData?.instanceWarning ?? '';
+    const message = outputData?.message ?? '';
+    const fields = {
+        applet,
+        applets,
+        templates,
+        adoptions,
+        instanceId,
+        instanceWarning,
+        message
+    };
+    return {
+        action,
+        known: isAppletToolAction(action),
+        title: titleFor(action, fields, pending, inputData?.title ?? ''),
+        ...fields
+    };
+}

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

@@ -0,0 +1,3 @@
+export { default as AppletToolCard } from './AppletToolCard.svelte';
+export { APPLET_TOOL_CARD_LIST_LIMIT, APPLET_TOOL_ICON, APPLET_TOOL_ID, isAppletToolAction, projectAppletToolCard, type AppletAdoptionRow, type AppletCardRow, type AppletTemplateRow, type AppletToolAction, type AppletToolCardModel } from './applet-tool-card.ts';
+//# 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,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EACN,2BAA2B,EAC3B,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,qBAAqB,EACrB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,MAAM,uBAAuB,CAAC"}

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

@@ -0,0 +1,2 @@
+export { default as AppletToolCard } from './AppletToolCard.svelte';
+export { APPLET_TOOL_CARD_LIST_LIMIT, APPLET_TOOL_ICON, APPLET_TOOL_ID, isAppletToolAction, projectAppletToolCard } from "./applet-tool-card.js";

package/dist/templates/index.d.ts

@@ -0,0 +1,2 @@
+export { APPLET_TEMPLATE_KIND, AppletTemplateDescriptorSchema, appletTemplateKind, type AppletTemplateDescriptor } from './template.kind.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/templates/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,oBAAoB,EACpB,8BAA8B,EAC9B,kBAAkB,EAClB,KAAK,wBAAwB,EAC7B,MAAM,oBAAoB,CAAC"}

package/dist/templates/index.js

@@ -0,0 +1,2 @@
+export { APPLET_TEMPLATE_KIND, AppletTemplateDescriptorSchema, appletTemplateKind } from "./template.kind.js";
+//# sourceMappingURL=index.js.map