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

package/dist/svelte/components/AppletCanvas.svelte

@@ -0,0 +1,488 @@
+<script lang="ts">
+	import { listenMessagePort, type MessagePortListener } from '@vibesdotdev/kernel-rpc/messageport';
+	import type { RpcLifecycle } from '@vibesdotdev/kernel-rpc';
+	import type { InvokePipeline } from '@vibesdotdev/kernel';
+	import { onMount } from 'svelte';
+	import { APPLET_ROOT_SURFACE_METHODS, type ComponentReleaseRef } from '@vibesdotdev/applets';
+	import { createCanvasState } from '../state.svelte.js';
+	import {
+		createCorrelatedRunnerUrl,
+		createDisposeMessage,
+		createMountMessage,
+		createRunnerConnectionMessage,
+		isCapabilityRequest,
+		isDisposedAck,
+		isHeartbeat,
+		isMountedAck,
+		isRunnerBootMessage,
+		isRunnerError,
+		isStateMutation,
+		validateHandshake
+	} from '../lib/message-protocol.js';
+	import { verifyBundleBytes, verifyBundleHash } from '../lib/capability-review.js';
+	import type { JsonValue } from '@vibesdotdev/shared/types';
+	import AppletConsent from './AppletConsent.svelte';
+
+	interface Props {
+		instanceId: string;
+		release: ComponentReleaseRef;
+		capabilities: string[];
+		capabilityReasons?: Record<string, string>;
+		/** URL of the separate-site runner. Not set until consent. */
+		runnerUrl?: string;
+		/** Fetch the bundle bytes after consent. Returns the hash + bytes. */
+		fetchBundle?: () => Promise<{ hash: string; bytes: ArrayBuffer }>;
+		onApprove?: () => void | Promise<void>;
+		onReject?: () => void | Promise<void>;
+		onMutate?: (input: { scope: 'shared' | 'viewer'; operationId: string; expectedRevision: number; eventType: string; payload: JsonValue }) => Promise<void>;
+		/**
+		 * Store ids this release DECLARED, from its manifest. The frame refuses a
+		 * storage handle for anything else, so an undeclared id never reaches the
+		 * host.
+		 */
+		declaredStorageIds?: string[];
+		/**
+		 * What this applet may reach, or nothing.
+		 *
+		 * `root` is the ONE object the applet can invoke; `pipeline` is the L1
+		 * chain the applet gate hangs on — the same chain a local call runs, which
+		 * is the whole point of making this boundary a transport rather than a
+		 * protocol.
+		 *
+		 * Omitting it is a real configuration: a render-only applet. The mount
+		 * message then carries `rootRef: null`, and the frame refuses runtime calls
+		 * with a reason instead of posting invokes nobody answers.
+		 */
+		runtime?: { root: object; pipeline: InvokePipeline; lifecycle: RpcLifecycle };
+	}
+
+	let {
+		instanceId,
+		release,
+		capabilities,
+		capabilityReasons = {},
+		runnerUrl = '',
+		fetchBundle,
+		onApprove,
+		onReject,
+		onMutate,
+		declaredStorageIds = [],
+		runtime
+	}: Props = $props();
+
+	const canvas = createCanvasState();
+
+	let frame = $state<HTMLIFrameElement | null>(null);
+	let port = $state<MessagePort | null>(null);
+	let frameSrc = $state('');
+	let launchToken = '';
+	let mountNonce = '';
+	let verifiedBundle: ArrayBuffer | null = null;
+	let connectionSent = false;
+	/** The host's half of the RPC lane, when this host exposes a runtime. */
+	let rpcListener: MessagePortListener | null = null;
+	let mountSent = false;
+	let approvalInFlight = false;
+	let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+	let disposed = $state(false);
+	/** Resolved by the disposed ack so `dispose()` can stop waiting. */
+	let resolveDisposedAck: (() => void) | null = null;
+	/** Slightly longer than the runner's own 2s `__unmount` bound. */
+	const DISPOSE_ACK_TIMEOUT_MS = 2_500;
+
+	// Heartbeat timeout — if no heartbeat in 5s, mark unresponsive
+	const HEARTBEAT_TIMEOUT_MS = 5000;
+	let lastHeartbeat = 0;
+
+	function startHeartbeatWatch() {
+		lastHeartbeat = Date.now();
+		if (heartbeatTimer) clearInterval(heartbeatTimer);
+		heartbeatTimer = setInterval(() => {
+			if (Date.now() - lastHeartbeat > HEARTBEAT_TIMEOUT_MS) {
+				canvas.transitionToUnresponsive();
+				stopHeartbeat();
+			}
+		}, 1000);
+	}
+
+	function stopHeartbeat() {
+		if (heartbeatTimer) {
+			clearInterval(heartbeatTimer);
+			heartbeatTimer = null;
+		}
+	}
+
+	async function handleApprove() {
+		if (approvalInFlight) return;
+		approvalInFlight = true;
+		canvas.transitionToApproved();
+		if (!canvas.canFetchBundle) {
+			approvalInFlight = false;
+			return;
+		}
+
+		try {
+			await onApprove?.();
+			if (!fetchBundle) throw new Error('Applet bundle loader is unavailable.');
+			if (!runnerUrl) throw new Error('Applet runner is unavailable.');
+
+			// Bundle bytes do not exist in the DOM or runner before this consented
+			// fetch. The host hashes the actual bytes instead of trusting an ETag or
+			// a caller-projected digest.
+			const { hash, bytes } = await fetchBundle();
+			if (!verifyBundleHash(hash, release.bundleHash)) {
+				throw new Error('Bundle registry hash mismatch.');
+			}
+			if (!(await verifyBundleBytes(bytes, release.bundleHash))) {
+				throw new Error('Bundle byte digest mismatch.');
+			}
+			if (disposed) return;
+
+			launchToken = crypto.randomUUID();
+			mountNonce = crypto.randomUUID();
+			const correlated = createCorrelatedRunnerUrl(
+				runnerUrl,
+				launchToken,
+				window.location.origin
+			);
+			frameSrc = correlated.href;
+			verifiedBundle = bytes;
+			canvas.transitionToMounted();
+		} catch (cause) {
+			canvas.transitionToCrashed(
+				cause instanceof Error ? cause.message : String(cause)
+			);
+			throw cause;
+		} finally {
+			approvalInFlight = false;
+		}
+	}
+
+	function handleReject() {
+		void onReject?.();
+	}
+
+	function handlePortMessage(event: MessageEvent) {
+		const msg = event.data;
+
+		// DISPOSAL CLOSES BOTH LANES, not just the RPC one.
+		//
+		// `dispose()` closes the RPC listener first and then waits up to
+		// DISPOSE_ACK_TIMEOUT_MS for an ack — during which this handler was still
+		// bound, so a frame that declined to ack could keep posting
+		// `state-mutation` frames and have every one applied. The comment above
+		// `dispose()` claims the lane closes first; it closed one of two.
+		//
+		// `disposed` frames are dropped here except the ack itself, which is the
+		// one message disposal is waiting for.
+		if (disposed && !isDisposedAck(msg)) return;
+
+		if (msg?.type === 'ready') {
+			if (mountSent || !verifiedBundle) {
+				crashProtocol('Runner repeated its ready handshake.');
+				return;
+			}
+			const result = validateHandshake(msg, launchToken);
+			if (result.success) {
+				const bundle = verifiedBundle;
+				const mountMsg = createMountMessage(
+					mountNonce,
+					capabilities,
+					release.bundleHash,
+					bundle,
+					{ instanceId, release, declaredStorageIds }
+				);
+				mountSent = true;
+				verifiedBundle = null;
+				port?.postMessage(mountMsg, [bundle]);
+			} else {
+				crashProtocol(result.error ?? 'Runner handshake failed.');
+			}
+			return;
+		}
+
+		if (isMountedAck(msg, mountNonce)) {
+			canvas.transitionToRunning();
+			startHeartbeatWatch();
+			return;
+		}
+
+		if (isHeartbeat(msg)) {
+			canvas.recordHeartbeat();
+			lastHeartbeat = Date.now();
+			return;
+		}
+
+		if (isCapabilityRequest(msg)) {
+			// The trusted host owns capability review. A mediated response will be
+			// added with a capability implementation; unknown requests receive no
+			// ambient authority from this transport.
+			return;
+		}
+
+		if (isStateMutation(msg) && onMutate) {
+			void (async () => {
+				try {
+					await onMutate({
+						scope: msg.scope,
+						operationId: msg.operationId,
+						expectedRevision: msg.expectedRevision,
+						eventType: msg.eventType,
+						payload: msg.payload
+					});
+				} catch (cause) {
+					crashProtocol(cause instanceof Error ? cause.message : String(cause));
+					throw cause;
+				}
+			})();
+			return;
+		}
+
+		if (isRunnerError(msg)) {
+			if (msg.nonce && msg.nonce !== mountNonce) return;
+			crashProtocol(`${msg.code}: ${msg.message}`);
+			return;
+		}
+
+		if (isDisposedAck(msg)) {
+			// Let a pending `dispose()` stop waiting; it does the teardown itself so
+			// there is exactly one path that closes the port.
+			resolveDisposedAck?.();
+			resolveDisposedAck = null;
+		}
+	}
+
+	function handleRunnerBoot(event: MessageEvent) {
+		if (
+			connectionSent ||
+			disposed ||
+			!frame?.contentWindow ||
+			!launchToken ||
+			!isRunnerBootMessage(event, frame.contentWindow, launchToken)
+		) {
+			return;
+		}
+		const channel = new MessageChannel();
+		port = channel.port1;
+		port.onmessage = handlePortMessage;
+		port.start();
+		// The RPC lane layers on the SAME port: `listenMessagePort` attaches with
+		// addEventListener and answers only frames it recognises, while the canvas
+		// protocol keeps its own `onmessage`. Neither reads the other's traffic.
+		if (runtime) {
+			rpcListener = listenMessagePort(port, {
+				root: runtime.root,
+				// The root is the applet surface, not the runtime root: advertise its methods.
+				rootMethods: APPLET_ROOT_SURFACE_METHODS,
+				pipeline: runtime.pipeline,
+				lifecycle: runtime.lifecycle
+			});
+		}
+		connectionSent = true;
+		frame.contentWindow.postMessage(
+			createRunnerConnectionMessage(launchToken),
+			// sandbox="allow-scripts" deliberately gives the frame an opaque
+			// origin, so Window.postMessage requires "*". This envelope carries
+			// no bundle or authority; the runner authenticates source + parent
+			// origin + launch token before the consented bytes cross its port.
+			'*',
+			[channel.port2]
+		);
+	}
+
+	function crashProtocol(message: string) {
+		stopHeartbeat();
+		rpcListener?.close();
+		rpcListener = null;
+		port?.close();
+		port = null;
+		canvas.transitionToCrashed(message);
+	}
+
+	function resetAfterFailure() {
+		stopHeartbeat();
+		rpcListener?.close();
+		rpcListener = null;
+		port?.close();
+		port = null;
+		frameSrc = '';
+		launchToken = '';
+		mountNonce = '';
+		verifiedBundle = null;
+		connectionSent = false;
+		mountSent = false;
+		disposed = false;
+		canvas.reset();
+		canvas.transitionToReady();
+	}
+
+	async function dispose() {
+		if (disposed) return;
+		disposed = true;
+
+		// The RPC lane closes FIRST, before anything waits.
+		//
+		// Revocation begins here and the dispose ack is awaited for up to
+		// DISPOSE_ACK_TIMEOUT_MS. A frame that simply declines to ack and instead
+		// posts invokes had that whole window to keep writing — the one window
+		// where revocation is the entire point. `crashProtocol` and
+		// `resetAfterFailure` always did this; the NORMAL path did not.
+		rpcListener?.close();
+		rpcListener = null;
+
+		// Persist revocation BEFORE closing ports
+		canvas.transitionToRevoked();
+
+		// Send dispose, then WAIT for the ack so the applet can run `__unmount`
+		// and flush. This used to be a comment saying "in production: with
+		// timeout" and no wait at all, which made `isDisposedAck` dead code on
+		// the only path that should have used it.
+		//
+		// Bounded, because the ack is applet-dependent: the runner caps its own
+		// `__unmount` at 2s and always posts the ack afterwards, so a slightly
+		// longer deadline here waits for a well-behaved applet and does not let a
+		// hostile one delay revocation.
+		if (port) {
+			const acked = new Promise<void>((resolve) => {
+				resolveDisposedAck = resolve;
+			});
+			port.postMessage(createDisposeMessage());
+			await Promise.race([
+				acked,
+				new Promise<void>((resolve) => setTimeout(resolve, DISPOSE_ACK_TIMEOUT_MS))
+			]);
+			resolveDisposedAck = null;
+		}
+
+		// Close the port and destroy the frame
+		port?.close();
+		port = null;
+		verifiedBundle = null;
+		stopHeartbeat();
+		canvas.transitionToDisposed();
+	}
+
+	onMount(() => {
+		window.addEventListener('message', handleRunnerBoot);
+		canvas.transitionToReady();
+		return () => {
+			window.removeEventListener('message', handleRunnerBoot);
+			void dispose();
+		};
+	});
+</script>
+
+<div class="applet-canvas" data-testid="applet-canvas" data-state={canvas.state}>
+	{#if canvas.state === 'loading'}
+		<div class="loading" data-testid="loading">Loading release metadata...</div>
+	{:else if canvas.state === 'ready'}
+		<AppletConsent
+			{release}
+			{capabilities}
+			{capabilityReasons}
+			onApprove={handleApprove}
+			onReject={handleReject}
+		/>
+	{:else if canvas.state === 'approved' || canvas.state === 'mounted' || canvas.state === 'running'}
+		<div class="runner-container" data-testid="runner-container">
+			{#if runnerUrl && canvas.runnerMounted}
+				<iframe
+					bind:this={frame}
+					src={frameSrc}
+					sandbox="allow-scripts"
+					allow="accelerometer 'none'; camera 'none'; geolocation 'none'; gyroscope 'none'; microphone 'none'; payment 'none'; usb 'none'"
+					title="Applet runner"
+					data-testid="runner-frame"
+				></iframe>
+			{:else}
+				<div class="mounting" data-testid="mounting">Mounting runner...</div>
+			{/if}
+		</div>
+	{:else if canvas.state === 'crashed'}
+		<div class="error-state" data-testid="error-state">
+			<p class="error-title">Applet crashed</p>
+			<p class="error-message">{canvas.error}</p>
+			<button onclick={resetAfterFailure}>Retry</button>
+		</div>
+	{:else if canvas.state === 'unresponsive'}
+		<div class="error-state" data-testid="unresponsive-state">
+			<p class="error-title">Applet is unresponsive</p>
+			<button onclick={resetAfterFailure}>Retry</button>
+		</div>
+	{:else if canvas.state === 'revoked'}
+		<div class="revoked-state" data-testid="revoked-state">
+			<p>Capabilities revoked. Applet disposed.</p>
+		</div>
+	{:else if canvas.state === 'expired'}
+		<div class="expired-state" data-testid="expired-state">
+			<p>Launch lease expired.</p>
+		</div>
+	{:else if canvas.state === 'disposed'}
+		<div class="disposed-state" data-testid="disposed-state">
+			<p>Applet disposed.</p>
+		</div>
+	{/if}
+</div>
+
+<style>
+	.applet-canvas {
+		display: flex;
+		flex-direction: column;
+		min-height: 12rem;
+		border: 1px solid var(--applet-border, #e2e8f0);
+		border-radius: 0.5rem;
+		overflow: hidden;
+	}
+
+	.loading,
+	.mounting {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		padding: 2rem;
+		color: var(--applet-muted, #64748b);
+	}
+
+	.runner-container {
+		flex: 1;
+		min-height: 12rem;
+	}
+
+	.runner-container iframe {
+		width: 100%;
+		height: 100%;
+		border: none;
+		min-height: 12rem;
+	}
+
+	.error-state,
+	.revoked-state,
+	.expired-state,
+	.disposed-state {
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+		gap: 0.5rem;
+		padding: 2rem;
+	}
+
+	.error-title {
+		font-weight: 600;
+		color: var(--applet-error, #dc2626);
+	}
+
+	.error-message {
+		font-size: 0.875rem;
+		color: var(--applet-muted, #64748b);
+		font-family: monospace;
+	}
+
+	.error-state button {
+		padding: 0.5rem 1rem;
+		border-radius: 0.25rem;
+		border: 1px solid var(--applet-border, #e2e8f0);
+		cursor: pointer;
+		font-size: 0.875rem;
+	}
+</style>

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

@@ -0,0 +1,53 @@
+import type { RpcLifecycle } from '@vibesdotdev/kernel-rpc';
+import type { InvokePipeline } from '@vibesdotdev/kernel';
+import { type ComponentReleaseRef } from '@vibesdotdev/applets';
+import type { JsonValue } from '@vibesdotdev/shared/types';
+interface Props {
+    instanceId: string;
+    release: ComponentReleaseRef;
+    capabilities: string[];
+    capabilityReasons?: Record<string, string>;
+    /** URL of the separate-site runner. Not set until consent. */
+    runnerUrl?: string;
+    /** Fetch the bundle bytes after consent. Returns the hash + bytes. */
+    fetchBundle?: () => Promise<{
+        hash: string;
+        bytes: ArrayBuffer;
+    }>;
+    onApprove?: () => void | Promise<void>;
+    onReject?: () => void | Promise<void>;
+    onMutate?: (input: {
+        scope: 'shared' | 'viewer';
+        operationId: string;
+        expectedRevision: number;
+        eventType: string;
+        payload: JsonValue;
+    }) => Promise<void>;
+    /**
+     * Store ids this release DECLARED, from its manifest. The frame refuses a
+     * storage handle for anything else, so an undeclared id never reaches the
+     * host.
+     */
+    declaredStorageIds?: string[];
+    /**
+     * What this applet may reach, or nothing.
+     *
+     * `root` is the ONE object the applet can invoke; `pipeline` is the L1
+     * chain the applet gate hangs on — the same chain a local call runs, which
+     * is the whole point of making this boundary a transport rather than a
+     * protocol.
+     *
+     * Omitting it is a real configuration: a render-only applet. The mount
+     * message then carries `rootRef: null`, and the frame refuses runtime calls
+     * with a reason instead of posting invokes nobody answers.
+     */
+    runtime?: {
+        root: object;
+        pipeline: InvokePipeline;
+        lifecycle: RpcLifecycle;
+    };
+}
+declare const AppletCanvas: import("svelte").Component<Props, {}, "">;
+type AppletCanvas = ReturnType<typeof AppletCanvas>;
+export default AppletCanvas;
+//# sourceMappingURL=AppletCanvas.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppletCanvas.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/components/AppletCanvas.svelte.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,EAA+B,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAiB7F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAI1D,UAAU,KAAK;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,mBAAmB,CAAC;IAC7B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,WAAW,CAAA;KAAE,CAAC,CAAC;IAClE,SAAS,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,SAAS,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1J;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,cAAc,CAAC;QAAC,SAAS,EAAE,YAAY,CAAA;KAAE,CAAC;CAC9E;AAqXF,QAAA,MAAM,YAAY,2CAAwC,CAAC;AAC3D,KAAK,YAAY,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AACpD,eAAe,YAAY,CAAC"}

package/dist/svelte/components/AppletCatalog.svelte

@@ -0,0 +1,42 @@
+<script lang="ts">
+	import { Button, Card, Input, Icon } from '@vibesdotdev/kit/components';
+	import type { AppletPresentation } from '../../presentation.js';
+
+	interface Props { applets: readonly AppletPresentation[] }
+	let { applets }: Props = $props();
+	let search = $state('');
+	const visible = $derived(applets.filter(applet =>
+		`${applet.title} ${applet.description} ${applet.id}`.toLocaleLowerCase().includes(search.trim().toLocaleLowerCase())));
+</script>
+
+<section class="space-y-6" aria-label="Available applets">
+	<div class="flex flex-wrap items-end justify-between gap-4">
+		<div class="space-y-1">
+			<h1 class="text-2xl font-semibold tracking-tight">Applets</h1>
+			<p class="text-sm text-muted-foreground">Focused tools for your workspace, using your signed-in Vibes account.</p>
+		</div>
+		<Input type="search" aria-label="Find an applet" placeholder="Find an applet…" bind:value={search} class="w-full sm:max-w-xs" />
+	</div>
+	{#if visible.length}
+		<div class="grid gap-4 md:grid-cols-2 xl:grid-cols-3">
+			{#each visible as applet (applet.id)}
+				<Card.Root class="flex flex-col">
+					<Card.Header>
+						<Card.Title>{applet.title}</Card.Title>
+						<Card.Description>{applet.description}</Card.Description>
+					</Card.Header>
+					<Card.Footer class="mt-auto">
+						<Button href={`/${encodeURIComponent(applet.id)}/`} variant="outline" class="w-full justify-between">
+							Open {applet.title}<Icon icon="lucide:arrow-up-right" class="size-4" />
+						</Button>
+					</Card.Footer>
+				</Card.Root>
+			{/each}
+		</div>
+	{:else}
+		<div class="py-12 text-center" role="status">
+			<h2 class="font-medium">{search ? 'No matching applets' : 'No applets in this workspace yet'}</h2>
+			<p class="mt-2 text-sm text-muted-foreground">{search ? 'Try another name or clear the search.' : 'Create an applet from a template to make it available here.'}</p>
+		</div>
+	{/if}
+</section>

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

@@ -0,0 +1,8 @@
+import type { AppletPresentation } from '../../presentation.ts';
+interface Props {
+    applets: readonly AppletPresentation[];
+}
+declare const AppletCatalog: import("svelte").Component<Props, {}, "">;
+type AppletCatalog = ReturnType<typeof AppletCatalog>;
+export default AppletCatalog;
+//# sourceMappingURL=AppletCatalog.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppletCatalog.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/components/AppletCatalog.svelte.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAG/D,UAAU,KAAK;IAAG,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAA;CAAE;AA6C3D,QAAA,MAAM,aAAa,2CAAwC,CAAC;AAC5D,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACtD,eAAe,aAAa,CAAC"}