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

package/src/services/voice/vad.v1-v4.test.ts

@@ -0,0 +1,222 @@
+/**
+ * V1 / V4 — fast-endpoint and adaptive-hangover VAD tests.
+ *
+ * V1: when `fastEndpointEnabled` is true, the detector uses
+ * `fastPauseHangoverMs` instead of the conservative 220 ms default.
+ *
+ * V4: with `adaptiveHangoverScaleOnDrop` set, a sharp downward RMS
+ * trajectory (energy trailing off) collapses the pause hangover to the
+ * configured floor — the detector decides "you stopped talking" sooner
+ * when the audio confirms it.
+ */
+
+import { describe, expect, it } from "vitest";
+import type { PcmFrame, VadEvent } from "./types";
+import { VadDetector, type VadLike } from "./vad";
+
+const SR = 16_000;
+const FRAME = 512;
+const FRAME_MS = (FRAME / SR) * 1000; // 32 ms
+
+/**
+ * Scripted Silero whose speech probability AND the input PCM RMS are
+ * scripted in lockstep. The V4 path reads `rms(window)` from the
+ * detector — so the input pcm samples must produce the desired RMS.
+ */
+class ScriptedSileroWithEnergy implements VadLike {
+	readonly sampleRate = SR;
+	readonly windowSamples = FRAME;
+	resets = 0;
+	private idx = 0;
+	constructor(private readonly probs: readonly number[]) {}
+	async process(_window: Float32Array): Promise<number> {
+		const p = this.probs[this.idx] ?? this.probs[this.probs.length - 1] ?? 0;
+		this.idx++;
+		return p;
+	}
+	reset(): void {
+		this.resets++;
+	}
+}
+
+/**
+ * Build a frame whose RMS is approximately `targetRms`. A constant-value
+ * PCM block has RMS = |value| — easiest scriptable shape.
+ */
+function frameWithRms(targetRms: number, ts: number): PcmFrame {
+	const pcm = new Float32Array(FRAME);
+	for (let i = 0; i < FRAME; i++) pcm[i] = targetRms;
+	return { pcm, sampleRate: SR, timestampMs: ts };
+}
+
+async function runScript(
+	det: VadDetector,
+	rmsScript: readonly number[],
+): Promise<VadEvent[]> {
+	const events: VadEvent[] = [];
+	det.onVadEvent((e) => events.push(e));
+	let ts = 1000;
+	for (const r of rmsScript) {
+		await det.pushFrame(frameWithRms(r, ts));
+		ts += FRAME_MS;
+	}
+	await det.flush();
+	return events;
+}
+
+describe("V1 — fast-endpoint pause hangover", () => {
+	it("uses fastPauseHangoverMs when fastEndpointEnabled=true", async () => {
+		// 3 speech windows, then silence. With fast=100 ms and FRAME=32 ms,
+		// pause fires after ceil(100/32) ≈ 4 silence windows.
+		const probs = [
+			0.9, 0.9, 0.9, 0.9, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05,
+		];
+		const det = new VadDetector(new ScriptedSileroWithEnergy(probs), {
+			onsetThreshold: 0.5,
+			pauseHangoverMs: 220,
+			fastPauseHangoverMs: 100,
+			fastEndpointEnabled: true,
+			endHangoverMs: 700,
+			minSpeechMs: 1,
+			activeHeartbeatMs: 10_000,
+			// Disable V4 so this test isolates V1.
+			adaptiveHangoverScaleOnDrop: 1,
+		});
+		const events = await runScript(
+			det,
+			[
+				0.4, 0.4, 0.4, 0.4, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001,
+				0.001,
+			],
+		);
+		const pauseIndex = events.findIndex((e) => e.type === "speech-pause");
+		expect(pauseIndex).toBeGreaterThanOrEqual(0);
+		const pause = events[pauseIndex];
+		if (pause.type !== "speech-pause") throw new Error("type narrow failed");
+		// Pause fired after ~4 silence windows (~128 ms), well under the
+		// legacy 220 ms hangover.
+		expect(pause.pauseDurationMs).toBeLessThan(200);
+		expect(pause.pauseDurationMs).toBeGreaterThan(80);
+	});
+
+	it("uses the conservative pauseHangoverMs when fastEndpointEnabled=false", async () => {
+		const probs = [
+			0.9, 0.9, 0.9, 0.9, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05,
+			0.05,
+		];
+		const det = new VadDetector(new ScriptedSileroWithEnergy(probs), {
+			onsetThreshold: 0.5,
+			pauseHangoverMs: 220,
+			fastPauseHangoverMs: 100,
+			fastEndpointEnabled: false,
+			endHangoverMs: 700,
+			minSpeechMs: 1,
+			activeHeartbeatMs: 10_000,
+			adaptiveHangoverScaleOnDrop: 1,
+		});
+		const events = await runScript(
+			det,
+			[
+				0.4, 0.4, 0.4, 0.4, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001,
+				0.001, 0.001, 0.001,
+			],
+		);
+		const pause = events.find((e) => e.type === "speech-pause");
+		expect(pause).toBeDefined();
+		if (pause?.type !== "speech-pause") throw new Error("missing");
+		// Pause fired only after >= 220 ms (7 silence windows = ~224 ms).
+		expect(pause.pauseDurationMs).toBeGreaterThanOrEqual(220);
+	});
+});
+
+describe("V4 — adaptive hangover on sharp RMS drop", () => {
+	it("collapses the pause hangover when RMS trails off sharply", async () => {
+		// Probability tells the speech state machine "still speaking" /
+		// "below offset"; the RMS shape decides whether V4 fires. Probs:
+		// start speaking, three windows below offset threshold (so the
+		// detector enters its "trailing off" window). RMS shape: high, high,
+		// high, then a sharp drop across the last three windows.
+		const probs = [0.9, 0.9, 0.9, 0.3, 0.3, 0.3, 0.05, 0.05, 0.05, 0.05];
+		const det = new VadDetector(new ScriptedSileroWithEnergy(probs), {
+			onsetThreshold: 0.5,
+			offsetThreshold: 0.35,
+			pauseHangoverMs: 400, // conservative; V4 should shorten it
+			fastEndpointEnabled: false,
+			endHangoverMs: 1500,
+			minSpeechMs: 1,
+			activeHeartbeatMs: 10_000,
+			adaptiveHangoverScaleOnDrop: 0.25, // collapse to 25% of base
+			adaptiveHangoverFloorMs: 50,
+			adaptiveHangoverDropThreshold: -0.02,
+		});
+		// RMS script — sharp drop across last three windows so the rolling
+		// window slope is well below -0.02.
+		const rmsScript = [
+			0.3, 0.3, 0.3, 0.3, 0.2, 0.05, 0.001, 0.001, 0.001, 0.001,
+		];
+		const events = await runScript(det, rmsScript);
+		const pause = events.find((e) => e.type === "speech-pause");
+		expect(pause).toBeDefined();
+		if (pause?.type !== "speech-pause") throw new Error("missing");
+		// Without V4 the pause would not fire until 400 ms (~12.5 windows).
+		// With V4 shortening to 100 ms (25% of 400), pause fires after ~3-4
+		// silence windows.
+		expect(pause.pauseDurationMs).toBeLessThan(400);
+	});
+
+	it("disables adaptive hangover when scaleOnDrop is 1.0", async () => {
+		// 3 speech windows + many silence windows — pause must wait the full
+		// 400 ms conservative hangover (≈13 silence windows at 32 ms each).
+		const probs = [
+			0.9, 0.9, 0.9, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05,
+			0.05, 0.05, 0.05, 0.05, 0.05,
+		];
+		const det = new VadDetector(new ScriptedSileroWithEnergy(probs), {
+			onsetThreshold: 0.5,
+			offsetThreshold: 0.35,
+			pauseHangoverMs: 400,
+			fastEndpointEnabled: false,
+			endHangoverMs: 1500,
+			minSpeechMs: 1,
+			activeHeartbeatMs: 10_000,
+			// Adaptive disabled — pause must wait the full conservative 400 ms.
+			adaptiveHangoverScaleOnDrop: 1,
+		});
+		const rmsScript = [
+			0.3, 0.3, 0.3, 0.2, 0.05, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001,
+			0.001, 0.001, 0.001, 0.001, 0.001, 0.001,
+		];
+		const events = await runScript(det, rmsScript);
+		const pause = events.find((e) => e.type === "speech-pause");
+		expect(pause).toBeDefined();
+		if (pause?.type !== "speech-pause") throw new Error("missing");
+		expect(pause.pauseDurationMs).toBeGreaterThanOrEqual(400);
+	});
+
+	it("respects the adaptiveHangoverFloorMs", async () => {
+		const probs = [0.9, 0.9, 0.9, 0.3, 0.3, 0.3, 0.05, 0.05, 0.05, 0.05];
+		const det = new VadDetector(new ScriptedSileroWithEnergy(probs), {
+			onsetThreshold: 0.5,
+			offsetThreshold: 0.35,
+			pauseHangoverMs: 400,
+			fastEndpointEnabled: false,
+			endHangoverMs: 1500,
+			minSpeechMs: 1,
+			activeHeartbeatMs: 10_000,
+			// Tiny scale + a floor — the effective hangover must be at least
+			// the floor.
+			adaptiveHangoverScaleOnDrop: 0.1,
+			adaptiveHangoverFloorMs: 64,
+			adaptiveHangoverDropThreshold: -0.02,
+		});
+		const rmsScript = [
+			0.3, 0.3, 0.3, 0.3, 0.2, 0.05, 0.001, 0.001, 0.001, 0.001,
+		];
+		const events = await runScript(det, rmsScript);
+		const pause = events.find((e) => e.type === "speech-pause");
+		expect(pause).toBeDefined();
+		if (pause?.type !== "speech-pause") throw new Error("missing");
+		// Floor is 64 ms (~2 windows). Pause shouldn't fire before that.
+		expect(pause.pauseDurationMs).toBeGreaterThanOrEqual(64);
+	});
+});

package/src/services/voice/voice-budget.d.ts

@@ -0,0 +1,241 @@
+/**
+ * Voice-budget allocator — single arbiter of the co-resident memory budget
+ * for the whole voice + text bundle (text LM, drafter, ASR, TTS, embedding,
+ * VAD, wake-word, turn-detector, emotion classifier, speaker encoder).
+ *
+ * Today's `ram-budget.ts` is per-tier: it decides whether ONE text bundle
+ * fits a host. `voice-budget.ts` is the cross-model layer the brief
+ * mandated in `.swarm/VOICE_WAVE_2.md` §H4 and R9 §4 — every model loader
+ * calls `reserve()` before it loads weights, releases on unload, and
+ * `reserve()` walks the residents under contention by eviction priority
+ * (cold → warm → hot) until the requested amount fits.
+ *
+ * Priorities (from R9 §4.1, mapped to `ResidentModelRole`):
+ *
+ *   - **hot**  (priority ≥ 40): `text-target`, `tts`, `asr` — never load
+ *     on demand, never evicted before pressure-of-last-resort.
+ *   - **warm** (priority 25–35): `vad`, `embedding` — may be evicted but
+ *     reload is expensive.
+ *   - **cold** (priority ≤ 20): `speaker-id` (18), `emotion` (15),
+ *     `vision` (20), `drafter` (10) — load-on-demand; first to evict.
+ *
+ * Eviction policy: walk ascending priority (cheapest first) until enough
+ * memory has been reclaimed. The text target evicts only when it is
+ * literally the only resident role and pressure persists (matches
+ * `SharedResourceRegistry.evictLowestPriorityRole` semantics).
+ *
+ * The allocator is **memory-only** — it does not load weights. The caller
+ * (TTS engine, ASR loader, etc.) holds the typed reservation and runs
+ * `release()` on unload.
+ *
+ * Wire-up plan (handed to follow-up commits, NOT done by I9):
+ *   - `ffi-streaming-backend.ts`     → `reserve(role="text-target")` + `reserve(role="drafter")` at spawn.
+ *   - `voice/pipeline.ts`    → `reserve(role="tts", bytes=transientPeakMb*MB)` per synth.
+ *   - `voice/wake-word.ts`, `vad.ts`, `eot-classifier.ts` → reserve at session arm.
+ *   - I2/I3 add `emotion` + `speaker-id` reservations when those models register.
+ *
+ * NOTE: the wire-up is intentionally separate from the allocator
+ * implementation because the in-flight I-agents (I1/I2/I3/I5) own those
+ * loader files and we must not race their edits. The allocator + the
+ * `evictionPriority` hooks are in place; the loaders adopt it as they
+ * land.
+ */
+import { type DeviceTier, type DeviceTierAssessment } from "../device-tier";
+import type { HardwareProbe } from "../types";
+import { type ResidentModelRole } from "./shared-resources";
+/** Coarse priority class consumed by `reserve()`. Internally we map this
+ *  back to the per-role priority number in `RESIDENT_ROLE_PRIORITY`. */
+export type AllocationPriority = "hot" | "warm" | "cold";
+export declare function priorityClassForRole(role: ResidentModelRole): AllocationPriority;
+export interface BudgetReservation {
+    readonly id: string;
+    readonly role: ResidentModelRole;
+    readonly bytes: number;
+    readonly priority: AllocationPriority;
+    /** Per-role priority number (R9 §4.1 / `RESIDENT_ROLE_PRIORITY`). */
+    readonly priorityRank: number;
+    /** Idempotent. Multi-release is a no-op (release happens from teardown
+     *  paths that may race). */
+    release(): void;
+}
+/** Diagnostic snapshot row for `VoiceBudget.snapshot()`. */
+export interface ReservationSnapshot {
+    id: string;
+    role: ResidentModelRole;
+    bytes: number;
+    priority: AllocationPriority;
+    priorityRank: number;
+}
+export declare class BudgetExhaustedError extends Error {
+    readonly code = "voice-budget-exhausted";
+    readonly details: {
+        requestedBytes: number;
+        freeBytes: number;
+        totalBytes: number;
+        role: ResidentModelRole;
+        priority: AllocationPriority;
+        evictedRoles: ReadonlyArray<ResidentModelRole>;
+        evictionCandidate: ResidentModelRole | null;
+    };
+    constructor(details: BudgetExhaustedError["details"]);
+}
+export interface VoiceBudget {
+    /**
+     * Reserve `bytes` for `modelId` with `priority`. Returns a handle the
+     * caller MUST `.release()` to give the memory back. Throws
+     * `BudgetExhaustedError` when the requested amount cannot fit even after
+     * evicting every available lower-priority reservation.
+     *
+     * `evictHook` is optional: when present, the allocator will call it for
+     * each role that needs to be evicted (one at a time, ascending priority)
+     * before recording the new reservation. When omitted, the allocator just
+     * walks its own internal table — the caller is expected to drive the
+     * actual weight unload (the loader/eviction path lives in the model's
+     * own service, not here).
+     */
+    reserve(args: {
+        modelId: string;
+        role: ResidentModelRole;
+        bytes: number;
+        /** Optional; defaults to `priorityClassForRole(role)`. */
+        priority?: AllocationPriority;
+        /** Optional eviction callback. When provided, called once per evicted
+         *  role in ascending-priority order before the new reservation is
+         *  recorded. The callback should drop the weights and return the
+         *  bytes actually reclaimed (must be >= the reservation's recorded
+         *  bytes). When omitted, the allocator only drops the internal
+         *  reservation entry (eviction-by-accounting). */
+        evictHook?: (role: ResidentModelRole, id: string) => Promise<number>;
+    }): Promise<BudgetReservation>;
+    /** Best-effort current free budget, in bytes. */
+    freeBytes(): number;
+    /** Total budget on this device, in bytes. */
+    totalBytes(): number;
+    /** All current reservations, ordered by priority ascending. */
+    snapshot(): ReadonlyArray<ReservationSnapshot>;
+    /** The tier this budget was sized to. */
+    tier(): DeviceTier;
+    /** The original assessment. */
+    assessment(): DeviceTierAssessment;
+}
+/**
+ * Co-resident voice-ensemble RSS estimate in MB. Sourced from R9 §2.3,
+ * keyed off the LM-tier slot (the text model that anchors the bundle).
+ *
+ * Each row is the steady-state weights + KV at default context for the
+ * whole voice + text bundle running at once:
+ *
+ *   LM + LM KV + drafter + TTS (omnivoice base + tokenizer or kokoro-q8) +
+ *   ASR + ASR mmproj + embedding + VAD + wake-word + turn-detector +
+ *   emotion classifier + speaker encoder.
+ *
+ * The `transientTtsBufferMb` field is the OmniVoice MaskGIT decode peak
+ * (~1.17 GB measured on Metal). Backends that don't run OmniVoice locally
+ * (kokoro-only, cloud TTS) have a much smaller transient — kept at 100 MB
+ * to leave room for kokoro's ONNX compute path. Mobile defaults to no
+ * local TTS, so transient = 0.
+ *
+ * The figures are MEASURED on-disk (Q4_K_M GGUFs in
+ * `<stateDir>/local-inference/models/eliza-1-{0_8b,2b}.bundle/`) plus
+ * model-card sizes for VAD, wake-word, turn-detector, emotion, speaker-id.
+ * See R9 §2.1 + §2.2 + §2.3 for the per-component breakdown.
+ */
+export interface VoiceEnsembleBudget {
+    readonly tierSlot: VoiceTierSlot;
+    readonly lmMb: number;
+    readonly lmKvMb: number;
+    readonly drafterMb: number;
+    readonly ttsMb: number;
+    readonly asrMb: number;
+    readonly asrMmprojMb: number;
+    readonly embeddingMb: number;
+    readonly vadMb: number;
+    readonly wakeWordMb: number;
+    readonly turnDetectorMb: number;
+    readonly emotionMb: number;
+    readonly speakerEncoderMb: number;
+    readonly transientTtsBufferMb: number;
+    /** Sum of weights + KV (steady-state). Excludes transient TTS buffer. */
+    readonly steadyStateMb: number;
+    /** Sum of steady-state + transient TTS peak. */
+    readonly peakMb: number;
+}
+/**
+ * The voice ensemble's LM tier slot. We key the table off the LM size +
+ * the surrounding voice profile (mobile-cloud vs desktop-omnivoice) since
+ * the largest co-resident knob is the LM itself.
+ */
+export type VoiceTierSlot = "mobile-0_8b" | "desktop-0_8b" | "desktop-2b" | "desktop-4b" | "workstation-9b" | "workstation-27b";
+/** R9 §2.3 — measured co-resident bundle for every supported tier slot. */
+export declare const VOICE_ENSEMBLE_BUDGETS: Readonly<Record<VoiceTierSlot, VoiceEnsembleBudget>>;
+/**
+ * Estimate the full voice ensemble's peak resident MB for a tier slot.
+ * `assertVoiceBundleFitsHost` consults this against the device's host RAM.
+ */
+export declare function voiceEnsemblePeakMb(slot: VoiceTierSlot): number;
+/** Sum of weights + KV (steady-state, excludes transient TTS buffer). */
+export declare function voiceEnsembleSteadyStateMb(slot: VoiceTierSlot): number;
+/**
+ * Pick the canonical voice-tier slot for an installed text model + device
+ * tier. The LM size anchors the slot (`eliza-1-0_8b` → `0_8b`, `2b` → `2b`,
+ * …) and the device tier picks `mobile-` vs `desktop-` vs `workstation-`
+ * for the voice surrounding it. Mobile always pulls the `mobile-0_8b` slot
+ * because the brief defaults mobile to cloud TTS+ASR; only the 0.8B local
+ * LM stays available there.
+ */
+export declare function pickVoiceTierSlot(args: {
+    textModelId: string;
+    deviceTier: DeviceTier;
+    mobile?: boolean;
+}): VoiceTierSlot;
+/**
+ * Decision returned by `assertVoiceBundleFitsHost`. Mirrors the shape of
+ * `RamFitDecision` in `ram-budget.ts` but at the bundle level.
+ */
+export interface VoiceBundleFitDecision {
+    tierSlot: VoiceTierSlot;
+    deviceTier: DeviceTier;
+    /** Steady-state weights + KV, MB. */
+    steadyStateMb: number;
+    /** Steady-state + transient TTS peak, MB. */
+    peakMb: number;
+    /** RAM available to the bundle (host MB - OS reserve). */
+    usableMb: number;
+    /** True iff `peakMb <= usableMb` AND `steadyStateMb <= usableMb`. */
+    fits: boolean;
+    /** "fits" when peak fits, "tight" when only steady-state fits, "wontfit"
+     *  when not even steady-state fits. */
+    level: "fits" | "tight" | "wontfit";
+}
+/** Default OS reserve subtracted from the host before the bundle check. */
+export declare const DEFAULT_VOICE_BUNDLE_RESERVE_MB = 1536;
+/**
+ * Decide whether the whole voice ensemble fits a host. Used by the runtime
+ * at voice-session-start to refuse local-voice entry rather than start it
+ * and watch `MemoryMonitor` evict the loaders mid-session.
+ *
+ * `assertVoiceBundleFitsHost` (in `active-model.ts`) wraps this with a
+ * typed error. This function returns the raw decision so callers that want
+ * to degrade silently can do so. R9 §1.4 spec.
+ */
+export declare function assessVoiceBundleFits(args: {
+    tierSlot: VoiceTierSlot;
+    deviceTier: DeviceTier;
+    hostRamMb: number;
+    reserveMb?: number;
+}): VoiceBundleFitDecision;
+/** Public factory. */
+export declare function createVoiceBudget(args: {
+    probe: HardwareProbe;
+    /** Optional user override for the budget cap, in MB. Default: tier
+     *  natural total. Clamped to the device's effective model memory. */
+    maxRamMb?: number;
+    /** Optional pre-computed assessment (avoid double classification). */
+    assessment?: DeviceTierAssessment;
+}): VoiceBudget;
+/** Test seam — construct a budget with explicit total bytes + assessment. */
+export declare function createVoiceBudgetForTest(args: {
+    totalBytes: number;
+    assessment: DeviceTierAssessment;
+}): VoiceBudget;
+//# sourceMappingURL=voice-budget.d.ts.map

package/src/services/voice/voice-budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voice-budget.d.ts","sourceRoot":"","sources":["voice-budget.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,EAEN,KAAK,UAAU,EACf,KAAK,oBAAoB,EAEzB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAEN,KAAK,iBAAiB,EACtB,MAAM,oBAAoB,CAAC;AAK5B;wEACwE;AACxE,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAEzD,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,iBAAiB,GACrB,kBAAkB,CAKpB;AAED,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,qEAAqE;IACrE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;gCAC4B;IAC5B,OAAO,IAAI,IAAI,CAAC;CAChB;AAED,4DAA4D;AAC5D,MAAM,WAAW,mBAAmB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,iBAAiB,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,4BAA4B;IACzC,QAAQ,CAAC,OAAO,EAAE;QACjB,cAAc,EAAE,MAAM,CAAC;QACvB,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,iBAAiB,CAAC;QACxB,QAAQ,EAAE,kBAAkB,CAAC;QAC7B,YAAY,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;QAC/C,iBAAiB,EAAE,iBAAiB,GAAG,IAAI,CAAC;KAC5C,CAAC;gBACU,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC;CAYpD;AAED,MAAM,WAAW,WAAW;IAC3B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,IAAI,EAAE;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,iBAAiB,CAAC;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,0DAA0D;QAC1D,QAAQ,CAAC,EAAE,kBAAkB,CAAC;QAC9B;;;;;0DAKkD;QAClD,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;KACrE,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAE/B,iDAAiD;IACjD,SAAS,IAAI,MAAM,CAAC;IACpB,6CAA6C;IAC7C,UAAU,IAAI,MAAM,CAAC;IACrB,+DAA+D;IAC/D,QAAQ,IAAI,aAAa,CAAC,mBAAmB,CAAC,CAAC;IAC/C,yCAAyC;IACzC,IAAI,IAAI,UAAU,CAAC;IACnB,+BAA+B;IAC/B,UAAU,IAAI,oBAAoB,CAAC;CACnC;AAkCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,yEAAyE;IACzE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,GACtB,aAAa,GACb,cAAc,GACd,YAAY,GACZ,YAAY,GACZ,gBAAgB,GAChB,iBAAiB,CAAC;AAKrB,2EAA2E;AAC3E,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC5C,MAAM,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAkG1C,CAAC;AAyBF;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAE/D;AAED,yEAAyE;AACzE,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAEtE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,aAAa,CAYhB;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACtC,QAAQ,EAAE,aAAa,CAAC;IACxB,UAAU,EAAE,UAAU,CAAC;IACvB,qCAAqC;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,IAAI,EAAE,OAAO,CAAC;IACd;2CACuC;IACvC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;CACpC;AAED,2EAA2E;AAC3E,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAEpD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC3C,QAAQ,EAAE,aAAa,CAAC;IACxB,UAAU,EAAE,UAAU,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,sBAAsB,CAmBzB;AA8JD,sBAAsB;AACtB,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACvC,KAAK,EAAE,aAAa,CAAC;IACrB;yEACqE;IACrE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sEAAsE;IACtE,UAAU,CAAC,EAAE,oBAAoB,CAAC;CAClC,GAAG,WAAW,CASd;AAED,6EAA6E;AAC7E,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,oBAAoB,CAAC;CACjC,GAAG,WAAW,CAKd"}