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

package/src/services/voice/eliza1-eot-scorer.ts

@@ -0,0 +1,242 @@
+/**
+ * Eliza-1 EOT scorer — reuses the already-loaded text model to compute
+ * P(`<|im_end|>` next | conversation_so_far) without shipping a separate
+ * detector ONNX.
+ *
+ * The runtime keeps a `LlamaModel` resident for chat generation. Voice
+ * EOT scoring is a single forward pass over the formatted Qwen chat
+ * prompt with the trailing `<|im_end|>` removed. `capacitor-llama`'s
+ * `LlamaContextSequence.controlledEvaluate()` returns the next-token
+ * probability distribution, so we simply read the entry for the
+ * `<|im_end|>` token id — no sampling loop, no KV-cache growth on the
+ * chat session.
+ *
+ * A dedicated `LlamaContext` is held just for this scorer so we do not
+ * fight the chat session pool for sequence slots. The context is small
+ * (single sequence, ≤512 tokens) and shares the model weights with the
+ * chat path; only the per-sequence KV cache is duplicated.
+ *
+ * Optionally a LoRA adapter is attached to that context — that is how
+ * a fine-tuned EOT head (trained per
+ * `packages/training/scripts/turn_detector/`) layers onto the same base
+ * weights without a separate GGUF.
+ */
+
+import path from "node:path";
+
+// `capacitor-llama` 3.18.1 surface we depend on. We avoid importing the
+// type directly so the binding stays an optional peer dep — callers pass
+// the model through a structural type.
+export interface LlamaModelLike {
+	tokenize(text: string, specialTokens?: boolean): readonly number[];
+	createContext(options: {
+		contextSize?: number;
+		sequences?: number;
+		flashAttention?: boolean;
+		lora?: string | { adapters: Array<{ filePath: string; scale?: number }> };
+	}): Promise<LlamaContextLike>;
+}
+
+export interface LlamaContextLike {
+	getSequence(options?: object): LlamaContextSequenceLike;
+	dispose(): Promise<void>;
+}
+
+export interface LlamaContextSequenceLike {
+	clearHistory(): Promise<void>;
+	controlledEvaluate(
+		input: ControlledEvaluateInputLike[],
+		options?: { evaluationPriority?: number },
+	): Promise<Array<ControlledEvaluateOutputLike | undefined>>;
+}
+
+export type ControlledEvaluateInputLike =
+	| number
+	| [
+			token: number,
+			options: {
+				generateNext?: {
+					probabilities?: boolean;
+					confidence?: boolean;
+				};
+			},
+	  ];
+
+export interface ControlledEvaluateOutputLike {
+	next: {
+		token?: number | null;
+		confidence?: number;
+		probabilities?: Map<number, number>;
+	};
+}
+
+const IM_END_TOKEN = "<|im_end|>";
+const IM_START_USER_PREFIX = "<|im_start|>user\n";
+
+export interface Eliza1EotScorerOptions {
+	/** The already-loaded text model (eliza-1 drafter). */
+	model: LlamaModelLike;
+	/** Optional EOT LoRA adapter path (absolute). When set, applied to the dedicated EOT context. */
+	loraPath?: string;
+	/** Adapter scale (default 1.0). Only meaningful when `loraPath` is set. */
+	loraScale?: number;
+	/** Max history tokens to keep in the prompt window. LiveKit uses 128. */
+	maxHistoryTokens?: number;
+	/** Context size for the dedicated EOT context. Default 512. */
+	contextSize?: number;
+	/** Model label for telemetry. */
+	modelLabel?: string;
+}
+
+export interface Eliza1EotScoreResult {
+	/** Probability of `<|im_end|>` as the next token, ∈ [0, 1]. */
+	probability: number;
+	/** Wall-clock model latency for this scoring call. */
+	latencyMs: number;
+	/** Number of prompt tokens evaluated. */
+	promptTokens: number;
+}
+
+/**
+ * Stateful EOT scorer bound to a single loaded text model. Lazily
+ * allocates its own dedicated `LlamaContext` on first call. Safe to
+ * keep across many voice turns; call `dispose()` on shutdown.
+ */
+export class Eliza1EotScorer {
+	private readonly model: LlamaModelLike;
+	private readonly loraPath: string | undefined;
+	private readonly loraScale: number | undefined;
+	private readonly maxHistoryTokens: number;
+	private readonly contextSize: number;
+	readonly modelLabel: string;
+
+	private context: LlamaContextLike | null = null;
+	private sequence: LlamaContextSequenceLike | null = null;
+	private imEndTokenId: number | null = null;
+	private initPromise: Promise<void> | null = null;
+	/** Serializes concurrent calls — controlledEvaluate is not thread-safe per-sequence. */
+	private inflight: Promise<unknown> = Promise.resolve();
+
+	constructor(options: Eliza1EotScorerOptions) {
+		this.model = options.model;
+		this.loraPath = options.loraPath;
+		this.loraScale = options.loraScale;
+		this.maxHistoryTokens = options.maxHistoryTokens ?? 128;
+		this.contextSize = options.contextSize ?? 512;
+		this.modelLabel =
+			options.modelLabel ??
+			(this.loraPath
+				? `eliza-1-drafter+eot-lora:${path.basename(this.loraPath)}`
+				: "eliza-1-drafter");
+	}
+
+	async score(partialTranscript: string): Promise<Eliza1EotScoreResult> {
+		await this.ensureReady();
+		const sequence = this.sequence;
+		const imEndId = this.imEndTokenId;
+		if (!sequence || imEndId === null) {
+			throw new Error("[voice] Eliza1EotScorer not initialized.");
+		}
+
+		const tokens = this.tokenizePrompt(partialTranscript);
+		const start = performance.now();
+		const next = this.inflight.then(() =>
+			this.runOnce(sequence, tokens, imEndId),
+		);
+		this.inflight = next.catch(() => undefined);
+		const probability = await next;
+		return {
+			probability,
+			latencyMs: performance.now() - start,
+			promptTokens: tokens.length,
+		};
+	}
+
+	async dispose(): Promise<void> {
+		const ctx = this.context;
+		this.context = null;
+		this.sequence = null;
+		this.imEndTokenId = null;
+		this.initPromise = null;
+		if (ctx) await ctx.dispose();
+	}
+
+	private async ensureReady(): Promise<void> {
+		if (this.context && this.sequence && this.imEndTokenId !== null) return;
+		if (!this.initPromise) this.initPromise = this.initialize();
+		await this.initPromise;
+	}
+
+	private async initialize(): Promise<void> {
+		const imEndIds = this.model.tokenize(IM_END_TOKEN, true);
+		if (imEndIds.length !== 1 || !Number.isInteger(imEndIds[0])) {
+			throw new Error(
+				`[voice] Eliza1EotScorer: model tokenizer did not resolve <|im_end|> to a single special token (got ${JSON.stringify(imEndIds)}). The base model must be Qwen-template compatible.`,
+			);
+		}
+		this.imEndTokenId = imEndIds[0];
+
+		const contextOptions: Parameters<LlamaModelLike["createContext"]>[0] = {
+			contextSize: this.contextSize,
+			sequences: 1,
+			flashAttention: true,
+		};
+		if (this.loraPath) {
+			contextOptions.lora = {
+				adapters: [
+					{
+						filePath: this.loraPath,
+						...(this.loraScale !== undefined ? { scale: this.loraScale } : {}),
+					},
+				],
+			};
+		}
+
+		this.context = await this.model.createContext(contextOptions);
+		this.sequence = this.context.getSequence();
+	}
+
+	private tokenizePrompt(transcript: string): number[] {
+		const formatted = formatEotPrompt(transcript);
+		const ids = this.model.tokenize(formatted, true);
+		if (ids.length <= this.maxHistoryTokens) return [...ids];
+		return [...ids.slice(ids.length - this.maxHistoryTokens)];
+	}
+
+	private async runOnce(
+		sequence: LlamaContextSequenceLike,
+		tokens: number[],
+		imEndId: number,
+	): Promise<number> {
+		if (tokens.length === 0) return 0.5;
+		await sequence.clearHistory();
+		const input: ControlledEvaluateInputLike[] = tokens.map((tok, i) =>
+			i === tokens.length - 1
+				? [tok, { generateNext: { probabilities: true } }]
+				: tok,
+		);
+		const out = await sequence.controlledEvaluate(input);
+		const last = out[tokens.length - 1];
+		const probs = last?.next.probabilities;
+		if (!probs) return 0.5;
+		const p = probs.get(imEndId);
+		if (typeof p !== "number" || !Number.isFinite(p)) return 0.5;
+		return Math.max(0, Math.min(1, p));
+	}
+}
+
+/**
+ * Format the partial transcript using the Qwen chat template, with the
+ * trailing `<|im_end|>` removed so the next predicted token *is* the
+ * EOT signal we want to measure.
+ *
+ * Matches the formatting LiveKit's turn-detector uses (single user turn,
+ * no system prompt, no generation prefix). When upstream history is
+ * available we can stack turns here, but the LiveKit recipe truncates
+ * to the last 128 tokens regardless, so a single user turn captures the
+ * relevant context for tier-1 EOT.
+ */
+export function formatEotPrompt(transcript: string): string {
+	const cleaned = transcript.trim();
+	return `${IM_START_USER_PREFIX}${cleaned}`;
+}

package/src/services/voice/embedding-server.ts

@@ -0,0 +1,200 @@
+/**
+ * Lazy embedding `llama-server` sidecar for Eliza-1 bundles.
+ *
+ * The route resolver decides which GGUF backs embeddings. This class owns the
+ * process boundary: validate the GGUF at construction, start the sidecar only
+ * on first non-empty `embed()`, and return Matryoshka-truncated vectors.
+ */
+
+import { type ChildProcess, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import net from "node:net";
+import os from "node:os";
+import {
+	isValidEmbeddingDim,
+	type LocalEmbeddingRoute,
+	truncateMatryoshka,
+} from "./embedding";
+import { VoiceStartupError } from "./errors";
+
+interface EmbeddingServerConfig {
+	/** GGUF the sidecar mmaps. For the dedicated-region mode this is the `embedding/` file. */
+	modelPath: string;
+	/** Extra `llama-server` flags — the route's `embeddingServerFlags` (`--embeddings --pooling last`). */
+	serverFlags: ReadonlyArray<string>;
+	/** GPU offload: `"auto"` (= all layers) for CPU/Vulkan/CUDA hosts, `0` to force CPU. */
+	gpuLayers?: number | "auto";
+	/** Thread count for the embedding forward pass. Defaults to the host's logical core count. */
+	threads?: number;
+}
+
+export class EmbeddingServer {
+	private readonly config: EmbeddingServerConfig;
+	private child: ChildProcess | null = null;
+	private baseUrl: string | null = null;
+	private starting: Promise<void> | null = null;
+
+	constructor(config: EmbeddingServerConfig) {
+		if (!existsSync(config.modelPath)) {
+			throw new VoiceStartupError(
+				"missing-bundle-root",
+				`[embedding-server] model GGUF not found at ${config.modelPath}`,
+			);
+		}
+		this.config = config;
+	}
+
+	isRunning(): boolean {
+		return this.child !== null && this.child.exitCode === null;
+	}
+
+	async embed(texts: string[], dim = 1024): Promise<number[][]> {
+		if (texts.length === 0) return [];
+		if (!isValidEmbeddingDim(dim)) {
+			throw new Error(`[embedding] dim ${dim} is not a valid Matryoshka width`);
+		}
+		await this.ensureStarted();
+		const response = await fetch(`${this.baseUrl}/v1/embeddings`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({ input: texts }),
+		});
+		if (!response.ok) {
+			const body = await response.text().catch(() => "");
+			throw new Error(
+				`[embedding-server] /v1/embeddings returned ${response.status}: ${body.slice(0, 200)}`,
+			);
+		}
+		const payload = (await response.json()) as {
+			data?: Array<{ embedding?: number[] }>;
+		};
+		const rows = payload.data ?? [];
+		if (rows.length !== texts.length) {
+			throw new Error(
+				`[embedding-server] expected ${texts.length} embedding rows, got ${rows.length}`,
+			);
+		}
+		return rows.map((row, index) => {
+			if (!Array.isArray(row.embedding)) {
+				throw new Error(
+					`[embedding-server] response row ${index} missing embedding vector`,
+				);
+			}
+			return truncateMatryoshka(row.embedding, dim);
+		});
+	}
+
+	private async ensureStarted(): Promise<void> {
+		if (this.isRunning()) return;
+		this.starting ??= this.start().finally(() => {
+			this.starting = null;
+		});
+		await this.starting;
+	}
+
+	private async start(): Promise<void> {
+		const port = await reserveTcpPort();
+		const binary =
+			process.env.ELIZA_LLAMA_SERVER_PATH?.trim() || "llama-server";
+		const args = [
+			"-m",
+			this.config.modelPath,
+			...this.config.serverFlags,
+			"--host",
+			"127.0.0.1",
+			"--port",
+			String(port),
+			"--threads",
+			String(this.config.threads ?? Math.max(1, os.cpus().length)),
+		];
+		if (typeof this.config.gpuLayers === "number") {
+			args.push("--n-gpu-layers", String(this.config.gpuLayers));
+		}
+
+		const child = spawn(binary, args, {
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		this.child = child;
+		this.baseUrl = `http://127.0.0.1:${port}`;
+
+		child.once("exit", (code, signal) => {
+			if (this.child === child) this.child = null;
+			if (code !== 0 && code !== null) {
+				console.warn(
+					`[embedding-server] llama-server exited with code ${code}`,
+				);
+			} else if (signal) {
+				console.warn(`[embedding-server] llama-server exited on ${signal}`);
+			}
+		});
+
+		await this.waitUntilReady();
+	}
+
+	private async waitUntilReady(): Promise<void> {
+		const deadline = Date.now() + 20_000;
+		while (Date.now() < deadline) {
+			if (!this.isRunning()) {
+				throw new VoiceStartupError(
+					"missing-fused-build",
+					"[embedding-server] llama-server exited before /health became ready",
+				);
+			}
+			try {
+				const response = await fetch(`${this.baseUrl}/health`);
+				if (response.ok) return;
+			} catch {
+				// Server socket is not open yet.
+			}
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+		throw new VoiceStartupError(
+			"missing-fused-build",
+			"[embedding-server] timed out waiting for llama-server /health",
+		);
+	}
+
+	async stop(): Promise<void> {
+		const child = this.child;
+		if (!child) return;
+		this.child = null;
+		await new Promise<void>((resolve) => {
+			child.once("exit", () => resolve());
+			child.kill("SIGTERM");
+			setTimeout(() => {
+				if (child.exitCode === null) child.kill("SIGKILL");
+				resolve();
+			}, 2_000).unref();
+		});
+	}
+}
+
+export function embeddingServerForRoute(
+	route: LocalEmbeddingRoute,
+	opts: { gpuLayers?: number | "auto"; threads?: number } = {},
+): EmbeddingServer {
+	const modelPath =
+		route.source.kind === "pooled-text"
+			? route.source.textModelPath
+			: route.source.embeddingModelPath;
+	return new EmbeddingServer({
+		modelPath,
+		serverFlags: route.serverFlags,
+		gpuLayers: opts.gpuLayers,
+		threads: opts.threads,
+	});
+}
+
+async function reserveTcpPort(): Promise<number> {
+	return new Promise((resolve, reject) => {
+		const server = net.createServer();
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address();
+			server.close(() => {
+				if (address && typeof address === "object") resolve(address.port);
+				else reject(new Error("[embedding-server] failed to reserve TCP port"));
+			});
+		});
+	});
+}

package/src/services/voice/embedding.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Local embedding wiring for Eliza-1 bundles.
+ *
+ * Per `packages/inference/AGENTS.md` §1:
+ *   - On the `0_8b` and `2b` tiers the **embedding model IS the text backbone**,
+ *     served with `--pooling last` — there is no separate `embedding/`
+ *     GGUF and no duplicate parameters in the mobile/default tiers.
+ *   - On `4b` and larger tiers, a dedicated
+ *     `embedding/` GGUF region (Apache-2.0,
+ *     1024-dim Matryoshka, 32k ctx) is acquired lazily through the same
+ *     engine / `SharedResourceRegistry`. **Do not collapse it to pooled
+ *     text on the larger tiers** — that breaks the 1024-dim Matryoshka
+ *     contract (B1's verdict).
+ *
+ * This module is a pure resolver: given a bundle root + tier id it
+ * describes *where* embeddings come from (the text GGUF with a pooling
+ * flag, or a separate region file) without doing any I/O beyond an
+ * `existsSync`. The engine consumes the descriptor to mount the region
+ * and the local-embedding route. It also owns the Matryoshka-truncation
+ * helper that callers / the vector store use to trade dimensionality for
+ * storage (see `EMBEDDING_MATRYOSHKA_DIMS` + `truncateMatryoshka`).
+ */
+import type { Eliza1TierId } from "../catalog";
+/** Bundle-relative directory holding a dedicated embedding GGUF (larger tiers). */
+export declare const EMBEDDING_DIR_REL_PATH = "embedding";
+/** Full output dimensionality of the Eliza-1 embedding model. */
+export declare const EMBEDDING_FULL_DIM: 1024;
+/**
+ * Valid Matryoshka truncation points for the Eliza-1 embedding region. The model
+ * is trained so that the leading N components of the 1024-dim vector are
+ * themselves a usable embedding at these widths; quality degrades
+ * gracefully as N shrinks (see the tradeoff table in
+ * `reports/porting/2026-05-11/embedding-model-review.md`).
+ *
+ * 1024 (full) → 768 → 512 → 256 → 128 → 64. Smaller widths than 64 are
+ * not part of the published contract.
+ */
+export declare const EMBEDDING_MATRYOSHKA_DIMS: readonly number[];
+/** Type-narrow guard for `EMBEDDING_MATRYOSHKA_DIMS`. */
+export declare function isValidEmbeddingDim(dim: number): boolean;
+/**
+ * Truncate a full 1024-dim embedding to one of the Matryoshka widths and
+ * L2-renormalize. Renormalization matters: the dedicated embedding outputs are
+ * unit-norm at 1024 dims, but the leading slice is *not* unit-norm, and
+ * downstream cosine-similarity / dot-product retrieval assumes unit
+ * vectors.
+ *
+ * Throws on an invalid `dim` (must be one of `EMBEDDING_MATRYOSHKA_DIMS`)
+ * or when `vec` is shorter than `dim` — no silent truncation-to-whatever
+ * or zero-padding (Commandment 8: don't hide a broken pipeline).
+ */
+export declare function truncateMatryoshka(vec: readonly number[], dim: number): number[];
+export type LocalEmbeddingSource = {
+    /** `0_8b` / `2b`: reuse the text backbone GGUF; serve with `--pooling last`. */
+    readonly kind: "pooled-text";
+    readonly textModelPath: string;
+    readonly poolingType: "last";
+} | {
+    /** Larger tiers: a dedicated `embedding/<name>.gguf` region. */
+    readonly kind: "dedicated-region";
+    readonly embeddingModelPath: string;
+    /** 1024-dim Matryoshka (the published Eliza-1 embedding contract). */
+    readonly dimensions: typeof EMBEDDING_FULL_DIM;
+    /**
+     * The dedicated model already ships a contrastive `last`-token
+     * pooling head — `--pooling last` is still passed so llama-server
+     * doesn't fall back to the GGUF's metadata default (which for a raw
+     * Qwen3 base is `mean`). The model's own pooling layer dominates;
+     * this just pins the read.
+     */
+    readonly poolingType: "last";
+};
+/**
+ * Tiers whose embedding model is the text backbone with `--pooling last`
+ * (no separate GGUF). The default mobile tiers deliberately avoid duplicate
+ * parameters; larger tiers may use a dedicated embedding region.
+ */
+export declare const POOLED_TEXT_EMBEDDING_TIERS: ReadonlySet<Eliza1TierId>;
+/**
+ * Resolve the embedding source for an activated Eliza-1 bundle.
+ *
+ * @param bundleRoot   Bundle directory on disk.
+ * @param tierId       The Eliza-1 tier id (`eliza-1-0_8b`, ...).
+ * @param textModelPath Absolute path of the activated text GGUF (needed for
+ *                      the `pooled-text` case).
+ *
+ * Hard-fails (AGENTS.md §3) when a larger tier is missing its
+ * `embedding/` region — no silent fallback to pooled text, which would
+ * regress dimensions from 1024 to whatever the text model emits.
+ */
+export declare function resolveLocalEmbeddingSource(args: {
+    bundleRoot: string;
+    tierId: Eliza1TierId;
+    textModelPath: string;
+}): LocalEmbeddingSource;
+/**
+ * Descriptor for the local-embedding route the engine exposes. The
+ * route's job is `text[] → number[dim][]`; the runtime mounts the source
+ * (pooled text or dedicated region) and forwards. Kept as a plain data
+ * shape so both the API layer and tests can assert it without standing up
+ * a server.
+ */
+export interface LocalEmbeddingRoute {
+    readonly tierId: Eliza1TierId;
+    readonly source: LocalEmbeddingSource;
+    /** Full output dimensionality the route produces before truncation. 1024 on every tier. */
+    readonly dimensions: typeof EMBEDDING_FULL_DIM;
+    /**
+     * Default Matryoshka width the route returns when a caller does not ask
+     * for a smaller `dim`. Always 1024 (= `dimensions`) — callers/the vector
+     * store opt into a smaller width for storage savings.
+     */
+    readonly defaultDim: number;
+    /** The Matryoshka widths a caller may request. */
+    readonly matryoshkaDims: readonly number[];
+    /**
+     * `llama-server` flags for the embedding server process — always
+     * `--embeddings --pooling last`. The embedding server is a lazily-started
+     * sidecar over the route's GGUF (the text backbone on `0_8b` / `2b`, the
+     * `embedding/` GGUF on larger tiers); see `embedding-server.ts`. The
+     * chat `llama-server` is left untouched (completions-only) — these flags
+     * do NOT go on it.
+     */
+    readonly serverFlags: ReadonlyArray<string>;
+}
+export declare function buildLocalEmbeddingRoute(args: {
+    bundleRoot: string;
+    tierId: Eliza1TierId;
+    textModelPath: string;
+    /** Default output width; must be one of `EMBEDDING_MATRYOSHKA_DIMS`. Defaults to 1024. */
+    defaultDim?: number;
+}): LocalEmbeddingRoute;
+//# sourceMappingURL=embedding.d.ts.map

package/src/services/voice/embedding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding.d.ts","sourceRoot":"","sources":["embedding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,cAAc,CAAC;AAElD,iEAAiE;AACjE,eAAO,MAAM,kBAAkB,EAAG,IAAa,CAAC;AAEhD;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,EAAE,SAAS,MAAM,EAEtD,CAAC;AAEF,yDAAyD;AACzD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CACjC,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,GAAG,EAAE,MAAM,GACT,MAAM,EAAE,CAiBV;AAYD,MAAM,MAAM,oBAAoB,GAC7B;IACA,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC5B,GACD;IACA,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,sEAAsE;IACtE,QAAQ,CAAC,UAAU,EAAE,OAAO,kBAAkB,CAAC;IAC/C;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC5B,CAAC;AAaL;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,EAAE,WAAW,CAAC,YAAY,CAGhE,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,YAAY,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACtB,GAAG,oBAAoB,CA4BvB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IACtC,2FAA2F;IAC3F,QAAQ,CAAC,UAAU,EAAE,OAAO,kBAAkB,CAAC;IAC/C;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,kDAAkD;IAClD,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC5C;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,YAAY,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,0FAA0F;IAC1F,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,mBAAmB,CAoBtB"}