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

package/src/adapters/capacitor-llama/types.ts

@@ -0,0 +1,374 @@
+/**
+ * Canonical Capacitor-llama adapter contract.
+ *
+ * This is the SAME shape used by `llama-cpp-capacitor` on mobile (iOS / Android,
+ * including riscv64 once Wave 2's libllama.so is installed) and by the bun:ffi
+ * backend on desktop. Every entry point in this plugin consumes one of these
+ * interfaces — there is no `node-llama-cpp` import anywhere downstream.
+ *
+ * Shape rationale: the interface mirrors `llama-cpp-capacitor`'s
+ * `LlamaContext` class verbatim so the mobile path can implement it with a
+ * straight pass-through. The loader is mobile-only — libllama is retired, so
+ * there is no desktop façade (desktop runs the fused `libelizainference`).
+ *
+ * Why a TS interface rather than `import type { LlamaContext } from
+ * "llama-cpp-capacitor"`? The Capacitor package is mobile-only at install time
+ * (Capacitor SPI'd Java/Swift bindings). Importing its types from the desktop
+ * path would force every desktop tsc run to pull the mobile binding's d.ts. We
+ * keep the interface free-standing so any backend can implement it.
+ */
+
+export interface TokenizerConfig {
+	name: string;
+	type: string;
+}
+
+// === Context / completion params ===========================================
+
+export interface CapacitorLlamaContextParams {
+	/** GGUF model path (absolute or Capacitor-asset URI). */
+	model: string;
+	/** Optional Jinja chat template override. */
+	chat_template?: string;
+	/** When loading from a packaged Android/iOS asset. */
+	is_model_asset?: boolean;
+	use_progress_callback?: boolean;
+	n_ctx?: number;
+	n_batch?: number;
+	n_ubatch?: number;
+	n_threads?: number;
+	/**
+	 * GPU layer offload. `999` = "all layers on GPU" per llama.cpp convention.
+	 * The Capacitor binding rejects > model layer count; desktop path clamps
+	 * to the model's metadata layer count.
+	 */
+	n_gpu_layers?: number;
+	no_gpu_devices?: boolean;
+	flash_attn?: boolean;
+	cache_type_k?:
+		| "f16"
+		| "f32"
+		| "q8_0"
+		| "q4_0"
+		| "q4_1"
+		| "iq4_nl"
+		| "q5_0"
+		| "q5_1";
+	cache_type_v?:
+		| "f16"
+		| "f32"
+		| "q8_0"
+		| "q4_0"
+		| "q4_1"
+		| "iq4_nl"
+		| "q5_0"
+		| "q5_1";
+	use_mlock?: boolean;
+	use_mmap?: boolean;
+	vocab_only?: boolean;
+	lora?: string;
+	lora_scaled?: number;
+	lora_list?: Array<{ path: string; scaled?: number }>;
+	rope_freq_base?: number;
+	rope_freq_scale?: number;
+	pooling_type?: "none" | "mean" | "cls" | "last" | "rank";
+	ctx_shift?: boolean;
+	kv_unified?: boolean;
+	swa_full?: boolean;
+	n_cpu_moe?: number;
+	embedding?: boolean;
+	embd_normalize?: number;
+}
+
+export interface CapacitorLlamaMessagePart {
+	type: string;
+	text?: string;
+	image_url?: { url?: string };
+	input_audio?: { format: string; data?: string; url?: string };
+}
+
+export interface CapacitorLlamaChatMessage {
+	role: string;
+	content?: string | CapacitorLlamaMessagePart[];
+}
+
+export interface CapacitorLlamaResponseFormat {
+	type: "text" | "json_object" | "json_schema";
+	json_schema?: { strict?: boolean; schema: object };
+	schema?: object;
+}
+
+export interface CapacitorLlamaCompletionParams {
+	/** Raw prompt string. Mutually exclusive with `messages`. */
+	prompt?: string;
+	/** OpenAI-style messages; the binding renders the chat template. */
+	messages?: CapacitorLlamaChatMessage[];
+	chat_template?: string;
+	jinja?: boolean;
+	json_schema?: string;
+	/** GBNF grammar source. */
+	grammar?: string;
+	grammar_lazy?: boolean;
+	grammar_triggers?: Array<{ type: number; value: string; token: number }>;
+	enable_thinking?: boolean;
+	thinking_forced_open?: boolean;
+	preserved_tokens?: string[];
+	chat_format?: number;
+	reasoning_format?: string;
+	media_paths?: string[];
+	stop?: string[];
+	n_predict?: number;
+	n_probs?: number;
+	top_k?: number;
+	top_p?: number;
+	min_p?: number;
+	xtc_probability?: number;
+	xtc_threshold?: number;
+	typical_p?: number;
+	temperature?: number;
+	penalty_last_n?: number;
+	penalty_repeat?: number;
+	penalty_freq?: number;
+	penalty_present?: number;
+	mirostat?: number;
+	mirostat_tau?: number;
+	mirostat_eta?: number;
+	dry_multiplier?: number;
+	dry_base?: number;
+	dry_allowed_length?: number;
+	dry_penalty_last_n?: number;
+	dry_sequence_breakers?: string[];
+	top_n_sigma?: number;
+	ignore_eos?: boolean;
+	logit_bias?: Array<[number, number]>;
+	seed?: number;
+	guide_tokens?: number[];
+	tools?: object;
+	parallel_tool_calls?: object;
+	tool_choice?: string;
+	response_format?: CapacitorLlamaResponseFormat;
+	add_generation_prompt?: boolean;
+	chat_template_kwargs?: Record<string, string>;
+	prefill_text?: string;
+}
+
+export interface CapacitorLlamaToolCall {
+	type: "function";
+	id?: string;
+	function: { name: string; arguments: string };
+}
+
+export interface CapacitorLlamaTokenData {
+	token: string;
+	completion_probabilities?: Array<{
+		content: string;
+		probs: Array<{ tok_str: string; prob: number }>;
+	}>;
+	content?: string;
+	reasoning_content?: string;
+	tool_calls?: CapacitorLlamaToolCall[];
+	accumulated_text?: string;
+}
+
+export interface CapacitorLlamaCompletionResult {
+	text: string;
+	reasoning_content: string;
+	tool_calls: CapacitorLlamaToolCall[];
+	content: string;
+	chat_format: number;
+	tokens_predicted: number;
+	tokens_evaluated: number;
+	truncated: boolean;
+	stopped_eos: boolean;
+	stopped_word: string;
+	stopped_limit: number;
+	stopping_word: string;
+	context_full: boolean;
+	interrupted: boolean;
+	tokens_cached: number;
+	timings: {
+		prompt_n: number;
+		prompt_ms: number;
+		prompt_per_token_ms: number;
+		prompt_per_second: number;
+		predicted_n: number;
+		predicted_ms: number;
+		predicted_per_token_ms: number;
+		predicted_per_second: number;
+	};
+	completion_probabilities?: Array<{
+		content: string;
+		probs: Array<{ tok_str: string; prob: number }>;
+	}>;
+	audio_tokens?: number[];
+}
+
+export interface CapacitorLlamaTokenizeResult {
+	tokens: number[];
+	has_images: boolean;
+	bitmap_hashes: number[];
+	chunk_pos: number[];
+	chunk_pos_images: number[];
+}
+
+export interface CapacitorLlamaEmbeddingResult {
+	embedding: number[];
+}
+
+export interface CapacitorLlamaBenchResult {
+	modelDesc: string;
+	modelSize: number;
+	modelNParams: number;
+	ppAvg: number;
+	ppStd: number;
+	tgAvg: number;
+	tgStd: number;
+}
+
+// === Model description (mirrors NativeLlamaContext['model'])  ==============
+
+export interface CapacitorLlamaModelDescriptor {
+	desc: string;
+	size: number;
+	nEmbd: number;
+	nParams: number;
+	chatTemplates: {
+		llamaChat: boolean;
+		minja: {
+			default: boolean;
+			defaultCaps: {
+				tools: boolean;
+				toolCalls: boolean;
+				toolResponses: boolean;
+				systemRole: boolean;
+				parallelToolCalls: boolean;
+				toolCallId: boolean;
+			};
+			toolUse: boolean;
+			toolUseCaps: {
+				tools: boolean;
+				toolCalls: boolean;
+				toolResponses: boolean;
+				systemRole: boolean;
+				parallelToolCalls: boolean;
+				toolCallId: boolean;
+			};
+		};
+	};
+	metadata: object;
+	isChatTemplateSupported: boolean;
+}
+
+// === Canonical context interface ===========================================
+
+/**
+ * The canonical context handle every backend implements. Designed so a single
+ * caller can switch between `llama-cpp-capacitor`'s `LlamaContext` and the
+ * desktop bun:ffi-backed implementation with zero behavioural change at the
+ * TypeScript level.
+ *
+ * Backends that genuinely cannot implement a method (e.g. `bench()` on the
+ * desktop FFI adapter v1) MUST throw a `CapacitorLlamaUnsupportedError` so
+ * callers can route around the gap explicitly rather than silently producing
+ * wrong results.
+ */
+export interface CapacitorLlamaContext {
+	readonly id: number;
+	readonly gpu: boolean;
+	readonly reasonNoGPU: string;
+	readonly model: CapacitorLlamaModelDescriptor;
+
+	completion(
+		params: CapacitorLlamaCompletionParams,
+		callback?: (data: CapacitorLlamaTokenData) => void,
+	): Promise<CapacitorLlamaCompletionResult>;
+
+	stopCompletion(): Promise<void>;
+
+	tokenize(
+		text: string,
+		options?: { media_paths?: string[] },
+	): Promise<CapacitorLlamaTokenizeResult>;
+
+	detokenize(tokens: number[]): Promise<string>;
+
+	embedding(
+		text: string,
+		params?: { embd_normalize?: number },
+	): Promise<CapacitorLlamaEmbeddingResult>;
+
+	bench(
+		pp: number,
+		tg: number,
+		pl: number,
+		nr: number,
+	): Promise<CapacitorLlamaBenchResult>;
+
+	release(): Promise<void>;
+}
+
+/** Thrown by adapter methods that aren't implemented for a given backend. */
+export class CapacitorLlamaUnsupportedError extends Error {
+	constructor(
+		readonly method: string,
+		readonly backend: "mobile" | "desktop-ffi",
+		message?: string,
+	) {
+		super(
+			message ??
+				`[capacitor-llama] ${method} is not supported on ${backend} yet`,
+		);
+		this.name = "CapacitorLlamaUnsupportedError";
+	}
+}
+
+// === Model registry (re-exported from legacy types.ts) =====================
+
+export interface ModelSpec {
+	name: string;
+	repo: string;
+	size: string;
+	quantization: string;
+	contextSize: number;
+	tokenizer: TokenizerConfig;
+}
+
+export interface EmbeddingModelSpec extends ModelSpec {
+	dimensions: number;
+}
+
+/**
+ * Default model bundle. Vision and TTS are owned by `plugin-local-inference`'s
+ * voice and vision subsystems — they don't live on this adapter.
+ */
+export const MODEL_SPECS = {
+	small: {
+		name: "text/eliza-1-2b-128k.gguf",
+		repo: "elizaos/eliza-1",
+		size: "2B",
+		quantization: "fused GGUF",
+		contextSize: 131072,
+		tokenizer: { name: "elizaos/eliza-1", type: "eliza1" },
+	},
+	medium: {
+		name: "text/eliza-1-4b-128k.gguf",
+		repo: "elizaos/eliza-1",
+		size: "4B",
+		quantization: "fused GGUF",
+		contextSize: 131072,
+		tokenizer: { name: "elizaos/eliza-1", type: "eliza1" },
+	},
+	embedding: {
+		name: "gte-small_fp16.gguf",
+		repo: "ChristianAzinn/gte-small-gguf",
+		size: "64 MB",
+		quantization: "fp16 GGUF",
+		contextSize: 512,
+		dimensions: 384,
+		tokenizer: { name: "ChristianAzinn/gte-small-gguf", type: "bert" },
+	},
+} as const satisfies {
+	small: ModelSpec;
+	medium: ModelSpec;
+	embedding: EmbeddingModelSpec;
+};

package/src/backends/apple-foundation.ts

@@ -0,0 +1,127 @@
+/**
+ * Apple Foundation Models adapter — iOS / iPadOS / macOS 26+.
+ *
+ * The Foundation Models framework exposes a managed on-device LLM that
+ * Apple ships with the OS when Apple Intelligence is enabled. We do not
+ * own its weights and cannot ship our own; this adapter is an
+ * **opportunistic fast-path**:
+ *
+ *   - If the device is iOS 26+ and reports availability via the Capacitor
+ *     `ComputerUse` bridge probe, we register a generate function that
+ *     calls into Apple's framework for short prompts.
+ *   - Otherwise we do nothing, and the existing llama-cpp-capacitor
+ *     (Qwen3-VL-2B) path remains the active local-inference handler.
+ *
+ * Why this lives in plugin-local-inference (not plugin-capacitor-bridge):
+ *
+ *   - The plugin-capacitor-bridge package is a thin JS↔native shim. The
+ *     decision of *when* to use Apple's model vs. llama.cpp is an
+ *     inference-routing decision, which is plugin-local-inference's job.
+ *     Co-locating the adapter with the rest of the routing logic
+ *     (`backend-selector`, `runtime-dispatcher`, etc.) keeps the routing
+ *     surface inspectable in one place. The bridge only transports
+ *     bytes; it does not decide policy.
+ *
+ * Entitlement: requires `com.apple.developer.kernel.increased-memory-limit`
+ * and Apple Intelligence to be enabled by the user in Settings. See
+ * `docs/IOS_CONSTRAINTS.md`.
+ */
+
+import type {
+	FoundationModelOptions,
+	FoundationModelResult,
+	IosComputerUseBridge,
+} from "@elizaos/plugin-computeruse/mobile/ios-bridge";
+
+export interface AppleFoundationGenerateArgs {
+	readonly prompt: string;
+	readonly options?: FoundationModelOptions;
+}
+
+export interface AppleFoundationAdapter {
+	readonly name: "apple-foundation";
+	available(): boolean;
+	generate(args: AppleFoundationGenerateArgs): Promise<FoundationModelResult>;
+}
+
+/**
+ * Builds the adapter. The bridge getter is lazy so this module remains
+ * Node-importable for tests; in the Capacitor build the runtime resolves
+ * `Capacitor.Plugins.ComputerUse` and passes it in.
+ */
+export function createAppleFoundationAdapter(
+	getBridge: () => IosComputerUseBridge | null,
+): AppleFoundationAdapter {
+	let probedAvailable: boolean | null = null;
+	let probing: Promise<boolean> | null = null;
+
+	async function probe(): Promise<boolean> {
+		const bridge = getBridge();
+		if (!bridge) return false;
+		const result = await bridge.probe();
+		if (!result.ok) return false;
+		return result.data.capabilities.foundationModel === true;
+	}
+
+	return {
+		name: "apple-foundation",
+		available(): boolean {
+			if (probedAvailable !== null) return probedAvailable;
+			if (!probing) {
+				probing = probe().then((v) => {
+					probedAvailable = v;
+					return v;
+				});
+			}
+			// Synchronous semantics: return false until the probe resolves; this
+			// matches the rest of the local-inference availability pattern, which
+			// is allowed to return a slightly stale "unavailable" state until the
+			// first async probe completes.
+			return probedAvailable === true;
+		},
+		async generate(args): Promise<FoundationModelResult> {
+			const bridge = getBridge();
+			if (!bridge) {
+				throw new Error(
+					"apple-foundation adapter invoked but Capacitor ComputerUse plugin is not registered.",
+				);
+			}
+			const result = await bridge.foundationModelGenerate({
+				prompt: args.prompt,
+				...(args.options ? { options: args.options } : {}),
+			});
+			if (!result.ok) {
+				throw new Error(
+					`apple-foundation generate failed: ${result.code} — ${result.message}`,
+				);
+			}
+			return result.data;
+		},
+	};
+}
+
+// ── Registry ─────────────────────────────────────────────────────────────────
+
+let registered: AppleFoundationAdapter | null = null;
+
+/**
+ * Register the adapter so the local-inference runtime picks it up
+ * opportunistically. Idempotent — subsequent calls overwrite the previous
+ * registration so a hot reload of the bridge swaps cleanly.
+ */
+export function registerAppleFoundationAdapter(
+	adapter: AppleFoundationAdapter,
+): void {
+	registered = adapter;
+}
+
+export function getAppleFoundationAdapter(): AppleFoundationAdapter | null {
+	return registered;
+}
+
+/**
+ * Tests use this to ensure each spec starts from a known state.
+ */
+export function _resetAppleFoundationAdapterForTests(): void {
+	registered = null;
+}

package/src/index.d.ts

@@ -0,0 +1,7 @@
+export { buildGenerateMediaHandler, detectMediaIntent, generateMediaAction, type MediaKind, } from "./actions/generate-media.js";
+export { extractSpeakerName, identifySpeakerAction, } from "./actions/identify-speaker.js";
+export { getLocalInferenceActiveModelId, getLocalInferenceActiveSnapshot, getLocalInferenceChatStatus, handleLocalInferenceChatCommand, handleLocalInferenceRoutes, type LocalInferenceChatMetadata, type LocalInferenceChatResult, type LocalInferenceCommandIntent, } from "./local-inference-routes.js";
+export { createLocalInferenceModelHandlers, isLocalInferenceUnavailableError, LOCAL_INFERENCE_MODEL_TYPES, LOCAL_INFERENCE_PRIORITY, LOCAL_INFERENCE_PROVIDER_ID, LOCAL_INFERENCE_TEXT_MODEL_TYPES, LocalInferenceUnavailableError, type LocalInferenceUnavailableReason, localInferencePlugin, localInferencePlugin as default, } from "./provider.js";
+export { handleLocalInferenceTtsRoute, normalizeAudioBytes, sanitizeLocalInferenceSpeechText, sniffAudioContentType, } from "./routes/local-inference-tts-route.js";
+export { detectEmbeddingPreset, detectEmbeddingTier, EMBEDDING_PRESETS, type EmbeddingPreset, type EmbeddingTier, } from "./runtime/embedding-presets.js";
+//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAQA,OAAO,EACN,yBAAyB,EACzB,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,SAAS,GACd,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACN,kBAAkB,EAClB,qBAAqB,GACrB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACN,8BAA8B,EAC9B,+BAA+B,EAC/B,2BAA2B,EAC3B,+BAA+B,EAC/B,0BAA0B,EAC1B,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,2BAA2B,GAChC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACN,iCAAiC,EACjC,gCAAgC,EAChC,2BAA2B,EAC3B,wBAAwB,EACxB,2BAA2B,EAC3B,gCAAgC,EAChC,8BAA8B,EAC9B,KAAK,+BAA+B,EACpC,oBAAoB,EACpB,oBAAoB,IAAI,OAAO,GAC/B,MAAM,eAAe,CAAC;AACvB,OAAO,EACN,4BAA4B,EAC5B,mBAAmB,EACnB,gCAAgC,EAChC,qBAAqB,GACrB,MAAM,uCAAuC,CAAC;AAE/C,OAAO,EACN,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,aAAa,GAClB,MAAM,gCAAgC,CAAC"}

package/src/index.ts

@@ -0,0 +1,54 @@
+/// <reference path="../../../packages/agent/src/external-modules.d.ts" />
+// Plugin entry point — handler dispatch, error types, plugin definition.
+// For runtime wiring (boot-time handler registration, embedding warm-up)
+// import from `@elizaos/plugin-local-inference/runtime`.
+// For HTTP compat routes import from `@elizaos/plugin-local-inference/routes`.
+// For deep service surfaces (engine, voice, catalog, mtp) import from
+// `@elizaos/plugin-local-inference/services`.
+
+export {
+	buildGenerateMediaHandler,
+	detectMediaIntent,
+	generateMediaAction,
+	type MediaKind,
+} from "./actions/generate-media.js";
+export {
+	extractSpeakerName,
+	identifySpeakerAction,
+} from "./actions/identify-speaker.js";
+export {
+	getLocalInferenceActiveModelId,
+	getLocalInferenceActiveSnapshot,
+	getLocalInferenceChatStatus,
+	handleLocalInferenceChatCommand,
+	handleLocalInferenceRoutes,
+	type LocalInferenceChatMetadata,
+	type LocalInferenceChatResult,
+	type LocalInferenceCommandIntent,
+} from "./local-inference-routes.js";
+export {
+	createLocalInferenceModelHandlers,
+	isLocalInferenceUnavailableError,
+	LOCAL_INFERENCE_MODEL_TYPES,
+	LOCAL_INFERENCE_PRIORITY,
+	LOCAL_INFERENCE_PROVIDER_ID,
+	LOCAL_INFERENCE_TEXT_MODEL_TYPES,
+	LocalInferenceUnavailableError,
+	type LocalInferenceUnavailableReason,
+	localInferencePlugin,
+	localInferencePlugin as default,
+} from "./provider.js";
+export {
+	handleLocalInferenceTtsRoute,
+	normalizeAudioBytes,
+	sanitizeLocalInferenceSpeechText,
+	sniffAudioContentType,
+} from "./routes/local-inference-tts-route.js";
+// Embedding preset detection exported for runtime boot wiring.
+export {
+	detectEmbeddingPreset,
+	detectEmbeddingTier,
+	EMBEDDING_PRESETS,
+	type EmbeddingPreset,
+	type EmbeddingTier,
+} from "./runtime/embedding-presets.js";

package/src/local-inference-routes.d.ts

@@ -0,0 +1,38 @@
+import * as http from "node:http";
+import { type ContentValue } from "@elizaos/core";
+export type LocalInferenceCommandIntent = "retry" | "resume" | "redownload" | "download" | "cancel" | "switch_smaller" | "status" | "use_cloud" | "use_local";
+export interface LocalInferenceChatMetadata {
+    [key: string]: ContentValue;
+    intent?: LocalInferenceCommandIntent;
+    status: "missing" | "downloading" | "loading" | "failed" | "no_space" | "idle" | "ready" | "cancelled" | "routing";
+    modelId?: string | null;
+    activeModelId?: string | null;
+    provider?: string;
+    error?: string;
+    progress?: {
+        percent?: number;
+        receivedBytes: number;
+        totalBytes: number;
+        bytesPerSec?: number;
+        etaMs?: number | null;
+    };
+}
+export interface LocalInferenceChatResult {
+    text: string;
+    localInference: LocalInferenceChatMetadata;
+}
+export declare function getLocalInferenceActiveModelId(): string | undefined;
+export declare function getLocalInferenceActiveSnapshot(): Promise<{
+    modelId: string | null;
+    loadedAt: string | null;
+    status: "idle" | "loading" | "ready" | "error";
+    error?: string;
+    loadedContextSize?: number | null;
+    loadedCacheTypeK?: string | null;
+    loadedCacheTypeV?: string | null;
+    loadedGpuLayers?: number | null;
+}>;
+export declare function getLocalInferenceChatStatus(intent?: LocalInferenceCommandIntent, error?: unknown): Promise<LocalInferenceChatResult>;
+export declare function handleLocalInferenceChatCommand(intent: LocalInferenceCommandIntent, prompt: string): Promise<LocalInferenceChatResult>;
+export declare function handleLocalInferenceRoutes(req: http.IncomingMessage, res: http.ServerResponse): Promise<boolean>;
+//# sourceMappingURL=local-inference-routes.d.ts.map

package/src/local-inference-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-inference-routes.d.ts","sourceRoot":"","sources":["local-inference-routes.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAIlC,OAAO,EACN,KAAK,YAAY,EAMjB,MAAM,eAAe,CAAC;AAsFvB,MAAM,MAAM,2BAA2B,GACpC,OAAO,GACP,QAAQ,GACR,YAAY,GACZ,UAAU,GACV,QAAQ,GACR,gBAAgB,GAChB,QAAQ,GACR,WAAW,GACX,WAAW,CAAC;AAgCf,MAAM,WAAW,0BAA0B;IAC1C,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAC;IAC5B,MAAM,CAAC,EAAE,2BAA2B,CAAC;IACrC,MAAM,EACH,SAAS,GACT,aAAa,GACb,SAAS,GACT,QAAQ,GACR,UAAU,GACV,MAAM,GACN,OAAO,GACP,WAAW,GACX,SAAS,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE;QACV,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,aAAa,EAAE,MAAM,CAAC;QACtB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACtB,CAAC;CACF;AAED,MAAM,WAAW,wBAAwB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,0BAA0B,CAAC;CAC3C;AAuBD,wBAAgB,8BAA8B,IAAI,MAAM,GAAG,SAAS,CAQnE;AA0bD,wBAAsB,+BAA+B,IAAI,OAAO,CAAC;IAChE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC,CAAC,CAuDD;AA6PD,wBAAsB,2BAA2B,CAChD,MAAM,GAAE,2BAAsC,EAC9C,KAAK,CAAC,EAAE,OAAO,GACb,OAAO,CAAC,wBAAwB,CAAC,CAyEnC;AAED,wBAAsB,+BAA+B,CACpD,MAAM,EAAE,2BAA2B,EACnC,MAAM,EAAE,MAAM,GACZ,OAAO,CAAC,wBAAwB,CAAC,CAoHnC;AAMD,wBAAsB,0BAA0B,CAC/C,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,GACtB,OAAO,CAAC,OAAO,CAAC,CAuXlB"}