@elizaos/plugin-local-inference 2.0.0-beta.1 → 2.0.11-beta.7

package/src/services/vision/cloud-fallback.test.ts

@@ -0,0 +1,243 @@
+/**
+ * IMAGE_DESCRIPTION fallback chain tests.
+ *
+ * Exercises the local→cloud→vast wrappers in isolation. The wrappers are
+ * pure functions over an injected `fetch`, so we never touch global env
+ * here — every knob is passed in via options.
+ *
+ * What we assert:
+ *  - Local success: cloud `fetch` is never called.
+ *  - Local fallback: cloud `fetch` is invoked with the right URL/body/auth.
+ *  - Cloud 5xx: the cloud-wrapped handler re-emits a `{kind:"fallback"}` so
+ *    the vast layer can take over; vast `fetch` is then invoked.
+ *  - Both unavailable (no token / no key): the original local fallback
+ *    propagates unchanged so an outer layer (or the runtime) can act.
+ */
+
+import type {
+	ImageDescriptionParams,
+	ImageDescriptionResult,
+} from "@elizaos/core";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	type LocalImageDescriptionHandler,
+	type LocalVisionOutcome,
+	wrapImageDescriptionHandlerWithCloudFallback,
+} from "./cloud-fallback";
+import { wrapImageDescriptionHandlerWithVastFallback } from "./vast-fallback";
+
+// Quarantine the env vars the wrappers read so a developer machine that
+// happens to have ELIZA_CLOUD_TOKEN / ELIZA_VAST_* exported doesn't make the
+// "unconfigured" assertions flake into a real outbound HTTP call.
+const ENV_KEYS = [
+	"ELIZA_CLOUD_TOKEN",
+	"ELIZA_CLOUD_API_KEY",
+	"ELIZA_CLOUD_BASE_URL",
+	"ELIZA_VAST_BASE_URL",
+	"ELIZA_VAST_API_KEY",
+] as const;
+const savedEnv: Record<string, string | undefined> = {};
+
+beforeEach(() => {
+	for (const key of ENV_KEYS) {
+		savedEnv[key] = process.env[key];
+		delete process.env[key];
+	}
+});
+
+afterEach(() => {
+	for (const key of ENV_KEYS) {
+		if (savedEnv[key] === undefined) delete process.env[key];
+		else process.env[key] = savedEnv[key];
+	}
+});
+
+const PNG_URL = "https://example.invalid/cat.png";
+
+function jsonResponse(body: unknown, status = 200): Response {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" },
+	});
+}
+
+function textResponse(body: string, status = 500): Response {
+	return new Response(body, {
+		status,
+		headers: { "content-type": "text/plain" },
+	});
+}
+
+function okLocal(result: ImageDescriptionResult): LocalImageDescriptionHandler {
+	return async () => result;
+}
+
+function fallbackLocal(
+	reason: LocalVisionOutcome extends { kind: "fallback"; reason: infer R }
+		? R
+		: never,
+): LocalImageDescriptionHandler {
+	return async () =>
+		({
+			kind: "fallback",
+			reason,
+		}) satisfies LocalVisionOutcome;
+}
+
+describe("wrapImageDescriptionHandlerWithCloudFallback", () => {
+	it("returns local result without invoking cloud when local succeeds", async () => {
+		const fetchMock = vi.fn();
+		const wrapped = wrapImageDescriptionHandlerWithCloudFallback(
+			okLocal({ title: "Cat", description: "A small ginger cat." }),
+			{ token: "tk_test", baseUrl: "https://cloud.test", fetch: fetchMock },
+		);
+		const result = await wrapped({
+			imageUrl: PNG_URL,
+		} as ImageDescriptionParams);
+		expect(result).toEqual({
+			title: "Cat",
+			description: "A small ginger cat.",
+		});
+		expect(fetchMock).not.toHaveBeenCalled();
+	});
+
+	it("invokes cloud /v1/vision/describe with bearer + body when local falls back", async () => {
+		const fetchMock = vi.fn(async () =>
+			jsonResponse({
+				title: "Cloud title",
+				description: "Cloud description.",
+			}),
+		);
+		const wrapped = wrapImageDescriptionHandlerWithCloudFallback(
+			fallbackLocal("local-unavailable"),
+			{ token: "tk_test", baseUrl: "https://cloud.test", fetch: fetchMock },
+		);
+		const result = await wrapped({
+			imageUrl: PNG_URL,
+			prompt: "describe",
+		} as ImageDescriptionParams);
+		expect(result).toEqual({
+			title: "Cloud title",
+			description: "Cloud description.",
+		});
+		expect(fetchMock).toHaveBeenCalledTimes(1);
+		const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+		expect(url).toBe("https://cloud.test/v1/vision/describe");
+		expect(init.method).toBe("POST");
+		expect((init.headers as Record<string, string>).authorization).toBe(
+			"Bearer tk_test",
+		);
+		const body = JSON.parse(init.body as string) as {
+			image: { kind: string; url: string };
+			prompt: string;
+		};
+		expect(body.image).toEqual({ kind: "url", url: PNG_URL });
+		expect(body.prompt).toBe("describe");
+	});
+
+	it("forwards URL inputs as-is (no local fetch first)", async () => {
+		const fetchMock = vi.fn(async () =>
+			jsonResponse({ title: "T", description: "D" }),
+		);
+		const wrapped = wrapImageDescriptionHandlerWithCloudFallback(
+			fallbackLocal("local-unavailable"),
+			{ token: "tk_test", baseUrl: "https://cloud.test", fetch: fetchMock },
+		);
+		await wrapped({ imageUrl: PNG_URL } as ImageDescriptionParams);
+		// Only one outbound call — to the cloud describe endpoint, not to the URL.
+		expect(fetchMock).toHaveBeenCalledTimes(1);
+		const [url] = fetchMock.mock.calls[0] as [string];
+		expect(url).toBe("https://cloud.test/v1/vision/describe");
+	});
+
+	it("propagates fallback when no cloud token is configured", async () => {
+		const fetchMock = vi.fn();
+		const wrapped = wrapImageDescriptionHandlerWithCloudFallback(
+			fallbackLocal("local-unavailable"),
+			{ baseUrl: "https://cloud.test", fetch: fetchMock },
+		);
+		const out = await wrapped({ imageUrl: PNG_URL } as ImageDescriptionParams);
+		expect(fetchMock).not.toHaveBeenCalled();
+		expect(out).toMatchObject({
+			kind: "fallback",
+			reason: "local-unavailable",
+		});
+	});
+
+	it("propagates fallback when cloud responds with 5xx", async () => {
+		const fetchMock = vi.fn(async () => textResponse("upstream down", 503));
+		const wrapped = wrapImageDescriptionHandlerWithCloudFallback(
+			fallbackLocal("local-error"),
+			{ token: "tk_test", baseUrl: "https://cloud.test", fetch: fetchMock },
+		);
+		const out = await wrapped({ imageUrl: PNG_URL } as ImageDescriptionParams);
+		expect(fetchMock).toHaveBeenCalledTimes(1);
+		expect(out).toMatchObject({ kind: "fallback", reason: "local-error" });
+		expect((out as { cause?: Error }).cause?.message ?? "").toContain("503");
+	});
+});
+
+describe("wrapImageDescriptionHandlerWithVastFallback", () => {
+	it("invokes vast when inner handler returns fallback and vast is configured", async () => {
+		const innerFetch = vi.fn(async () => textResponse("cloud sad", 503));
+		const inner = wrapImageDescriptionHandlerWithCloudFallback(
+			fallbackLocal("local-unavailable"),
+			{ token: "tk_test", baseUrl: "https://cloud.test", fetch: innerFetch },
+		);
+		const vastFetch = vi.fn(async () =>
+			jsonResponse({ title: "VTitle", description: "VDescription" }),
+		);
+		const wrapped = wrapImageDescriptionHandlerWithVastFallback(inner, {
+			baseUrl: "https://vast.test",
+			apiKey: "vast_key",
+			fetch: vastFetch,
+		});
+		const result = await wrapped({
+			imageUrl: PNG_URL,
+		} as ImageDescriptionParams);
+		expect(innerFetch).toHaveBeenCalledTimes(1);
+		expect(vastFetch).toHaveBeenCalledTimes(1);
+		const [url, init] = vastFetch.mock.calls[0] as [string, RequestInit];
+		expect(url).toBe("https://vast.test/v1/vision/describe");
+		expect(init.method).toBe("POST");
+		expect((init.headers as Record<string, string>).authorization).toBe(
+			"Bearer vast_key",
+		);
+		expect(result).toEqual({ title: "VTitle", description: "VDescription" });
+	});
+
+	it("does not call vast when inner handler succeeds", async () => {
+		const inner = wrapImageDescriptionHandlerWithCloudFallback(
+			okLocal({ title: "Local", description: "Local desc." }),
+			{ token: "tk_test", baseUrl: "https://cloud.test", fetch: vi.fn() },
+		);
+		const vastFetch = vi.fn();
+		const wrapped = wrapImageDescriptionHandlerWithVastFallback(inner, {
+			baseUrl: "https://vast.test",
+			apiKey: "vast_key",
+			fetch: vastFetch,
+		});
+		const result = await wrapped({
+			imageUrl: PNG_URL,
+		} as ImageDescriptionParams);
+		expect(vastFetch).not.toHaveBeenCalled();
+		expect(result).toEqual({ title: "Local", description: "Local desc." });
+	});
+
+	it("propagates fallback when both cloud and vast are unconfigured", async () => {
+		const inner = wrapImageDescriptionHandlerWithCloudFallback(
+			fallbackLocal("local-unavailable"),
+			{ fetch: vi.fn() },
+		);
+		const vastFetch = vi.fn();
+		const wrapped = wrapImageDescriptionHandlerWithVastFallback(inner, {
+			fetch: vastFetch,
+		});
+		const out = await wrapped({ imageUrl: PNG_URL } as ImageDescriptionParams);
+		expect(vastFetch).not.toHaveBeenCalled();
+		expect(out).toMatchObject({
+			kind: "fallback",
+			reason: "local-unavailable",
+		});
+	});
+});

package/src/services/vision/cloud-fallback.ts

@@ -0,0 +1,268 @@
+/**
+ * Soft cloud fallback wrapper for local IMAGE_DESCRIPTION handlers.
+ *
+ * The local vision path can report recoverable unavailability without forcing
+ * callers to know which remote provider is paired. The wrapper keeps that
+ * state explicit: handlers return a normal image description or a typed
+ * fallback outcome that the next layer can handle.
+ */
+
+import type {
+	ImageDescriptionParams,
+	ImageDescriptionResult,
+} from "@elizaos/core";
+
+export type VisionFallbackReason =
+	| "local-unavailable"
+	| "local-overloaded"
+	| "local-error"
+	| "local-aborted-pre-completion"
+	| "local-not-registered"
+	| "cloud-unavailable"
+	| "cloud-error"
+	| "vast-unavailable"
+	| "vast-error";
+
+export type LocalVisionOutcome =
+	| ImageDescriptionResult
+	| string
+	| { kind: "ok"; result: ImageDescriptionResult | string }
+	| { kind: "fallback"; reason: VisionFallbackReason; cause?: Error };
+
+export type LocalVisionResult = Exclude<
+	LocalVisionOutcome,
+	{ kind: "fallback"; reason: VisionFallbackReason; cause?: Error }
+>;
+
+export type LocalImageDescriptionHandler = (
+	params: ImageDescriptionParams | string,
+) => Promise<LocalVisionOutcome>;
+
+export type WrappedImageDescriptionHandler = LocalImageDescriptionHandler;
+
+export interface VisionCloudFallbackOptions {
+	enabled?: boolean;
+	token?: string;
+	apiKey?: string;
+	baseUrl?: string;
+	fetch?: typeof fetch;
+	handler?: (
+		params: ImageDescriptionParams | string,
+		reason: VisionFallbackReason,
+	) => Promise<LocalVisionOutcome>;
+	log?: (message: string, detail?: Record<string, unknown>) => void;
+}
+
+export function classifyLocalVisionError(error: unknown): {
+	fallback: boolean;
+	reason: VisionFallbackReason;
+	cause?: Error;
+} {
+	const cause = error instanceof Error ? error : new Error(String(error));
+	const message = cause.message.toLowerCase();
+	if (cause.name === "AbortError") {
+		return {
+			fallback: false,
+			reason: "local-aborted-pre-completion",
+			cause,
+		};
+	}
+	if (
+		message.includes("no local") ||
+		message.includes("not registered") ||
+		message.includes("not installed") ||
+		message.includes("requires an active") ||
+		message.includes("capability_unavailable") ||
+		message.includes("backend_unavailable") ||
+		message.includes("no mtmd binding") ||
+		/not\s+implemented/u.test(message) ||
+		message.includes("not available") ||
+		message.includes("missing") ||
+		message.includes("dlopen")
+	) {
+		return { fallback: true, reason: "local-unavailable", cause };
+	}
+	if (
+		message.includes("busy") ||
+		message.includes("overloaded") ||
+		message.includes("thermal") ||
+		message.includes("low-power") ||
+		message.includes("timeout")
+	) {
+		return { fallback: true, reason: "local-overloaded", cause };
+	}
+	if (
+		message.includes("llama_decode") ||
+		message.includes("mtmd") ||
+		message.includes("projector") ||
+		message.includes("ggml_assert")
+	) {
+		return { fallback: true, reason: "local-error", cause };
+	}
+	return { fallback: true, reason: "local-error", cause };
+}
+
+export function isVisionFallbackOutcome(
+	outcome: LocalVisionOutcome,
+): outcome is {
+	kind: "fallback";
+	reason: VisionFallbackReason;
+	cause?: Error;
+} {
+	return (
+		typeof outcome === "object" &&
+		outcome !== null &&
+		"kind" in outcome &&
+		outcome.kind === "fallback"
+	);
+}
+
+export function normalizeVisionDescription(
+	result: LocalVisionResult,
+): ImageDescriptionResult {
+	if (typeof result === "object" && result !== null && "kind" in result) {
+		return normalizeVisionDescription(result.result);
+	}
+	if (typeof result === "string") {
+		const description = result.trim();
+		if (!description) {
+			throw new Error(
+				"[vision-fallback] IMAGE_DESCRIPTION backend returned an empty description",
+			);
+		}
+		return {
+			title: description.split(/[.!?]/, 1)[0]?.trim() || "Image",
+			description,
+		};
+	}
+	if (
+		result &&
+		typeof result.title === "string" &&
+		typeof result.description === "string" &&
+		result.title.trim() &&
+		result.description.trim()
+	) {
+		const title = result.title.trim();
+		const description = result.description.trim();
+		if (title === result.title && description === result.description) {
+			return result;
+		}
+		return { title, description };
+	}
+	throw new Error(
+		"[vision-fallback] IMAGE_DESCRIPTION backend returned an invalid description",
+	);
+}
+
+function resolveCloudToken(options: VisionCloudFallbackOptions): string | null {
+	return (
+		options.token?.trim() ||
+		options.apiKey?.trim() ||
+		process.env.ELIZA_CLOUD_TOKEN?.trim() ||
+		process.env.ELIZA_CLOUD_API_KEY?.trim() ||
+		null
+	);
+}
+
+function resolveCloudBaseUrl(options: VisionCloudFallbackOptions): string {
+	return (
+		options.baseUrl?.trim() ||
+		process.env.ELIZA_CLOUD_BASE_URL?.trim() ||
+		"https://api.elizacloud.ai"
+	).replace(/\/+$/, "");
+}
+
+function imageRequestBody(params: ImageDescriptionParams | string): {
+	image: { kind: "url"; url: string } | { kind: "data"; data: string };
+	prompt?: string;
+} {
+	if (typeof params === "string") {
+		return params.startsWith("data:")
+			? { image: { kind: "data", data: params } }
+			: { image: { kind: "url", url: params } };
+	}
+	const imageUrl = (params as { imageUrl?: string }).imageUrl;
+	const image = (params as { image?: string }).image;
+	const source = imageUrl ?? image;
+	const body = source?.startsWith("data:")
+		? { image: { kind: "data" as const, data: source } }
+		: { image: { kind: "url" as const, url: source ?? "" } };
+	if (params.prompt) return { ...body, prompt: params.prompt };
+	return body;
+}
+
+async function callCloudVision(
+	params: ImageDescriptionParams | string,
+	options: VisionCloudFallbackOptions,
+): Promise<ImageDescriptionResult> {
+	const token = resolveCloudToken(options);
+	if (!token) {
+		throw new Error("Eliza Cloud image fallback is not configured");
+	}
+	const fetchImpl = options.fetch ?? fetch;
+	const response = await fetchImpl(
+		`${resolveCloudBaseUrl(options)}/v1/vision/describe`,
+		{
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				authorization: `Bearer ${token}`,
+			},
+			body: JSON.stringify(imageRequestBody(params)),
+		},
+	);
+	if (!response.ok) {
+		throw new Error(
+			`Eliza Cloud image fallback failed with ${response.status}`,
+		);
+	}
+	return normalizeVisionDescription(
+		(await response.json()) as LocalVisionResult,
+	);
+}
+
+export function wrapImageDescriptionHandlerWithCloudFallback(
+	local: LocalImageDescriptionHandler,
+	options: VisionCloudFallbackOptions = {},
+): WrappedImageDescriptionHandler {
+	const enabled = options.enabled ?? true;
+	const log = options.log ?? (() => undefined);
+	return async (params) => {
+		let localOutcome: LocalVisionOutcome;
+		try {
+			localOutcome = await local(params);
+		} catch (error) {
+			const classified = classifyLocalVisionError(error);
+			if (!classified.fallback) throw error;
+			localOutcome = {
+				kind: "fallback",
+				reason: classified.reason,
+				cause: classified.cause,
+			};
+		}
+
+		if (!isVisionFallbackOutcome(localOutcome)) {
+			return normalizeVisionDescription(localOutcome);
+		}
+		if (!enabled) return localOutcome;
+
+		const token = resolveCloudToken(options);
+		if (!options.handler && !token) return localOutcome;
+
+		log("[vision/cloud-fallback] local IMAGE_DESCRIPTION fallback", {
+			reason: localOutcome.reason,
+		});
+		try {
+			const cloudOutcome = options.handler
+				? await options.handler(params, localOutcome.reason)
+				: await callCloudVision(params, options);
+			if (isVisionFallbackOutcome(cloudOutcome)) return cloudOutcome;
+			return normalizeVisionDescription(cloudOutcome);
+		} catch (error) {
+			return {
+				...localOutcome,
+				cause: error instanceof Error ? error : new Error(String(error)),
+			};
+		}
+	};
+}

package/src/services/vision/fallback-chain.test.ts

@@ -0,0 +1,86 @@
+import type { ImageDescriptionResult } from "@elizaos/core";
+import { describe, expect, it } from "vitest";
+import type { LocalImageDescriptionHandler } from "./cloud-fallback";
+import { withVisionFallbackChain } from "./index";
+
+const localResult: ImageDescriptionResult = {
+	title: "Local",
+	description: "local description",
+};
+
+const cloudResult: ImageDescriptionResult = {
+	title: "Cloud",
+	description: "cloud description",
+};
+
+const vastResult: ImageDescriptionResult = {
+	title: "Vast",
+	description: "vast description",
+};
+
+describe("vision fallback chain", () => {
+	it("returns local IMAGE_DESCRIPTION results without calling fallbacks", async () => {
+		let cloudCalls = 0;
+		const handler = withVisionFallbackChain(async () => localResult, {
+			cloud: {
+				handler: async () => {
+					cloudCalls += 1;
+					return cloudResult;
+				},
+			},
+		});
+
+		await expect(
+			handler({} as never, "data:image/png;base64,a"),
+		).resolves.toEqual(localResult);
+		expect(cloudCalls).toBe(0);
+	});
+
+	it("falls through local to cloud", async () => {
+		const local: LocalImageDescriptionHandler = async () => ({
+			kind: "fallback",
+			reason: "local-unavailable",
+		});
+		const handler = withVisionFallbackChain(local, {
+			cloud: { handler: async () => cloudResult },
+		});
+
+		await expect(
+			handler({} as never, "data:image/png;base64,a"),
+		).resolves.toEqual(cloudResult);
+	});
+
+	it("falls through cloud to vast", async () => {
+		const handler = withVisionFallbackChain(
+			async () => ({ kind: "fallback", reason: "local-error" }),
+			{
+				cloud: {
+					handler: async () => ({ kind: "fallback", reason: "cloud-error" }),
+				},
+				vast: { handler: async () => vastResult },
+			},
+		);
+
+		await expect(
+			handler({} as never, "data:image/png;base64,a"),
+		).resolves.toEqual(vastResult);
+	});
+
+	it("throws a structured error when every provider falls back", async () => {
+		const handler = withVisionFallbackChain(
+			async () => ({ kind: "fallback", reason: "local-error" }),
+			{
+				cloud: {
+					handler: async () => ({ kind: "fallback", reason: "cloud-error" }),
+				},
+				vast: {
+					handler: async () => ({ kind: "fallback", reason: "vast-error" }),
+				},
+			},
+		);
+
+		await expect(
+			handler({} as never, "data:image/png;base64,a"),
+		).rejects.toThrow("all IMAGE_DESCRIPTION providers exhausted");
+	});
+});

package/src/services/vision/hash.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Vision-embedding cache key derivation (WS2).
+ *
+ * The arbiter's vision-embedding cache (WS1, `vision-embedding-cache.ts`)
+ * is keyed by SHA-256 of a *normalized* representation of the input
+ * image. The normalization step is what makes the cache useful across
+ * platforms: two JPEG encodings of the same screenshot, or an RGBA vs
+ * RGB frame captured by different platforms, must hash to the same key
+ * or the cache hit rate collapses.
+ *
+ * Normalization is deliberately minimal:
+ *
+ *   1. Resolve the input to raw bytes (decoding base64/data-url wrappers).
+ *   2. Hash with the model-family prefix so the cache can hold tokens
+ *      for multiple VL families without collision.
+ *
+ * What we DO NOT do here:
+ *
+ *   - Resize the image. The backend's projector enforces its own input
+ *     resolution; the bytes the projector sees are what gets projected.
+ *      Re-encoding here would add work without changing the hit rate
+ *      (the platform-provided buffer is already at the camera's native
+ *      resolution).
+ *   - Strip JPEG/PNG headers. They contribute to the hash; two
+ *      reencodings of the same pixel array land in different cache
+ *      slots intentionally. Reuse only the exact same byte stream.
+ *
+ * If a downstream caller wants finer-grained cache hits (e.g. dedupe
+ * across re-encodings of the same screen frame), it should decode to
+ * RGBA pixels itself and call `hashRawPixels`. The default
+ * `hashVisionInput` path is the conservative, byte-stream-only path.
+ */
+import type { VisionImageInput } from "./types";
+/**
+ * Resolve a `VisionImageInput` to its raw bytes. Returns the decoded
+ * payload plus an optional MIME type the caller can forward to the
+ * backend. Throws on `url:` inputs — those must be fetched by the
+ * caller; the hash step does not own HTTP.
+ */
+export declare function resolveImageBytes(input: VisionImageInput): {
+    bytes: Uint8Array;
+    mimeType?: string;
+};
+/**
+ * Hash an opaque byte stream with the model-family prefix. The result
+ * is stable across processes and platforms (Node, Bun, and the
+ * Capacitor JS bridge all return the same hex string for the same
+ * input).
+ */
+export declare function hashImageBytes(bytes: Uint8Array, modelFamily?: string): string;
+/**
+ * Hash a raw pixel buffer (RGBA / RGB / BGRA / BGR). The channel order
+ * is folded into the prefix so the same image captured on two different
+ * platforms (Android = RGBA, macOS screenshot = BGRA) produces the same
+ * key when normalized. Width / height are also included so the cache
+ * doesn't conflate two scaled versions of the same source.
+ */
+export declare function hashRawPixels(args: {
+    bytes: Uint8Array;
+    width: number;
+    height: number;
+    channelOrder: "rgba" | "rgb" | "bgra" | "bgr";
+    modelFamily?: string;
+}): string;
+/**
+ * Convenience wrapper used by the provider: takes a `VisionImageInput`
+ * and a model family, returns the cache key. URL inputs throw —
+ * callers must fetch first.
+ */
+export declare function hashVisionInput(input: VisionImageInput, modelFamily?: string): string;
+//# sourceMappingURL=hash.d.ts.map

package/src/services/vision/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAIhD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,gBAAgB,GAAG;IAC3D,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB,CA4BA;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC7B,KAAK,EAAE,UAAU,EACjB,WAAW,GAAE,MAAuB,GAClC,MAAM,CAWR;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IACnC,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,CAAC;IAC9C,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,MAAM,CAeT;AAkBD;;;;GAIG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,gBAAgB,EACvB,WAAW,GAAE,MAAuB,GAClC,MAAM,CAGR"}