@elizaos/plugin-vision 2.0.0-alpha.9 → 2.0.3-beta.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shaw Walters and elizaOS Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# @elizaos/plugin-vision
+
+Visual perception plugin for elizaOS — gives Eliza agents real-time awareness of their camera feed and/or screen through scene analysis, object/person detection, OCR, face recognition, and entity tracking.
+
+## What it does
+
+- Captures frames from a connected camera (macOS/Linux/Windows) or the host screen.
+- Describes scenes by routing images through `runtime.useModel(IMAGE_DESCRIPTION)` — compatible with any registered VLM (local or cloud).
+- Detects and tracks people, objects, and faces across frames with persistent entity IDs.
+- Reads text on screen through the generic Apple Vision/doCTR OCR service and the coordinate-aware OCR registry used by computeruse: Windows.Media.Ocr on Windows, Tesseract on Linux when available, and the RapidOCR adapter as the portable fallback.
+- Exposes all capabilities through a single `VISION` action and a `VISION_PERCEPTION` context provider.
+
+## Installation
+
+```bash
+npm install @elizaos/plugin-vision
+```
+
+### Platform camera tools (required for camera mode)
+
+| Platform | Tool |
+|----------|------|
+| macOS | `brew install imagesnap` |
+| Linux | `sudo apt-get install fswebcam` |
+| Windows | Install ffmpeg and add to PATH |
+
+Screen capture and OCR work without these tools.
+
+## Enabling the plugin
+
+Add it to your character's plugin list:
+
+```json
+{
+  "name": "MyAgent",
+  "plugins": ["@elizaos/plugin-vision"],
+  "settings": {
+    "CAMERA_NAME": "obsbot",
+    "VISION_MODE": "CAMERA"
+  }
+}
+```
+
+The plugin auto-enables when `config.features.vision` is truthy or `config.media.vision.provider` is set.
+
+## Configuration
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `CAMERA_NAME` | auto | Partial name match for camera device selection (case-insensitive) |
+| `VISION_MODE` | `CAMERA` | `OFF` / `CAMERA` / `SCREEN` / `BOTH` |
+| `PIXEL_CHANGE_THRESHOLD` | `50` | % pixel change required before triggering a VLM scene update |
+| `VLM_UPDATE_INTERVAL` | `10000` | ms between VLM scene-describe calls |
+| `SCREEN_CAPTURE_INTERVAL` | `2000` | ms between screen captures |
+| `OCR_ENABLED` | `true` | Enable OCR on screen tiles |
+| `ENABLE_OBJECT_DETECTION` | `false` | ggml YOLOv8n object detection (`native/yolo.cpp`) |
+| `ENABLE_POSE_DETECTION` | `false` | Heuristic person detection (ggml pose pending) |
+| `ENABLE_FACE_RECOGNITION` | `false` | Native ggml face recognition (BlazeFace + 128-d embed via `native/face-cpp`) |
+| `ENTITY_TIMEOUT` | `30000` | ms before an inactive entity is evicted from tracking |
+
+All settings can also be prefixed with `VISION_` (e.g. `VISION_CAMERA_NAME`).
+
+## Actions
+
+The plugin registers a single `VISION` action that routes to one of these sub-operations based on explicit `action` parameter or natural-language inference:
+
+| Sub-operation | Trigger examples | What it does |
+|--------------|-----------------|-------------|
+| `describe` | "what do you see?", "describe the scene" | Returns the current VLM scene description |
+| `capture` | "take a photo", "screenshot" | Captures a frame and returns it as a base64 image attachment |
+| `set_mode` | "set vision mode to screen" | Switches between `OFF`, `CAMERA`, `SCREEN`, `BOTH` |
+| `enable_camera` / `disable_camera` | "turn on the camera" | Toggles camera input |
+| `enable_screen` / `disable_screen` | "enable screen capture" | Toggles screen input |
+| `name_entity` | "the person is named Alice" | Assigns a display name to the most prominent tracked entity |
+| `identify_person` | "who is that?" | Lists tracked people with names and presence duration |
+| `track_entity` | "track the person in the red shirt" | Refreshes entity tracking and reports statistics |
+
+## Vision Provider
+
+`VISION_PERCEPTION` is injected into agent context during turns in the `media` and `browser` contexts. It provides:
+
+- Current scene description text
+- Camera / screen connection status and mode
+- Detected people (count, poses, facings)
+- Detected objects (types)
+- Active tracked entities with duration
+- Recently-departed entities
+- Screen tile OCR text and UI element list (when screen mode is active)
+
+## Detection backends
+
+| Capability | Default backend | Optional / alternative |
+|-----------|-----------------|----------------------|
+| Scene description | VLM via `runtime.useModel(IMAGE_DESCRIPTION)` | Any registered IMAGE_DESCRIPTION provider |
+| Object detection | YOLOv8n ggml via `native/yolo.cpp` (`src/yolo-detector.ts`); build with `bun run build:native` + `bun run build:weights`. Service degrades to motion/heuristic + VLM when the lib/GGUF are absent. | — (TensorFlow.js path removed) |
+| Pose detection | Heuristic person detection (motion-derived) | Planned ggml MoveNet port |
+| OCR | Generic OCR uses Apple Vision (darwin, when a provider is registered) → doCTR ggml (`native/doctr.cpp`). Coordinate OCR for computeruse prefers Windows.Media.Ocr (Windows) → Tesseract CLI or vendored bundle (Linux) → RapidOCR adapter. | Native/mobile bridges can register platform OCR providers; no ONNX OCR path. |
+| Set-of-Marks grounding | `src/som.ts` fuses GGUF YOLO icon boxes + OCR text boxes into a deduplicated, 1-indexed numbered set (icon-over-text suppression + NMS) and renders a numbered-overlay PNG via `sharp`. `src/set-of-marks-provider.ts` registers it into plugin-computeruse's `detect_elements` seam at boot (best-effort; degrades to text-only marks when the GGUF detector is absent). | trycua/cua OmniParser parity (#9170 M9) |
+| Face recognition | Native ggml BlazeFace + 128-d embed (`face-detector-ggml.ts`, `face-recognition-ggml.ts`, `native/face-cpp`); disabled until the lib/GGUF artifacts land. No tfjs/face-api.js path. | MediaPipe BlazeFace migration shim is deprecated. |
+
+## Platform notes
+
+- **Node.js only.** Mobile (iOS, Android) registers a `MobileCameraSource` (`src/mobile/capacitor-camera.ts`) bridged by plugin-ios / plugin-aosp.
+- **Camera tools** (`imagesnap` / `fswebcam` / `ffmpeg`) are required for camera mode; screen capture and OCR work without them.
+- **Native detectors and OCR** (`native/yolo.cpp`, `native/doctr.cpp`, and the coordinate-OCR providers) run through the available host backend. YOLO/doCTR require compiled libraries and GGUF artifacts; Tesseract requires a binary plus traineddata resolved from the vendored bundle or PATH.
+
+## Privacy
+
+- Camera access requires OS-level permissions.
+- No frames are written to disk by default.
+- All inference runs locally unless a remote IMAGE_DESCRIPTION provider is registered.
+- Consider access implications before enabling in shared or sensitive environments.

package/auto-enable.ts

@@ -0,0 +1,29 @@
+// Auto-enable check for @elizaos/plugin-vision.
+//
+// Plugin manifest entry-point — referenced by package.json's
+// `elizaos.plugin.autoEnableModule`. Keep this module light: env reads only,
+// no service init, no transitive imports of the full plugin runtime. The
+// auto-enable engine loads dozens of these per boot.
+import type { PluginAutoEnableContext } from "@elizaos/core";
+
+function isFeatureEnabled(
+  config: PluginAutoEnableContext["config"],
+  key: string,
+): boolean {
+  const f = (config?.features as Record<string, unknown> | undefined)?.[key];
+  if (f === true) return true;
+  if (f && typeof f === "object" && f !== null) {
+    return (f as Record<string, unknown>).enabled !== false;
+  }
+  return false;
+}
+
+/**
+ * Enable when `config.features.vision` is truthy, or when the user has
+ * explicitly chosen a vision provider via `config.media.vision.provider`.
+ */
+export function shouldEnable(ctx: PluginAutoEnableContext): boolean {
+  if (isFeatureEnabled(ctx.config, "vision")) return true;
+  const visionProvider = ctx.config?.media?.vision?.provider;
+  return typeof visionProvider === "string" && visionProvider.length > 0;
+}

package/dist/action.d.ts

@@ -0,0 +1,3 @@
+import { type Action } from "@elizaos/core";
+export declare const visionAction: Action;
+//# sourceMappingURL=action.d.ts.map

package/dist/action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../src/action.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EAYZ,MAAM,eAAe,CAAC;AA29CvB,eAAO,MAAM,YAAY,EAAE,MAmP1B,CAAC"}

package/dist/audio-capture-stream.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from "node:events";
+import { type IAgentRuntime } from "@elizaos/core";
+export interface StreamingAudioConfig {
+    enabled: boolean;
+    device?: string;
+    sampleRate?: number;
+    channels?: number;
+    vadThreshold?: number;
+    silenceTimeout?: number;
+    responseDelay?: number;
+    chunkSize?: number;
+}
+export declare class StreamingAudioCaptureService extends EventEmitter {
+    private runtime;
+    private config;
+    private captureProcess;
+    private isCapturing;
+    private audioBuffer;
+    private isSpeaking;
+    private silenceTimer;
+    private transcriptionInProgress;
+    private currentTranscription;
+    private responseTimer;
+    constructor(runtime: IAgentRuntime, config: StreamingAudioConfig);
+    initialize(): Promise<void>;
+    private startContinuousCapture;
+    private processAudioChunk;
+    private calculateEnergy;
+    private startStreamingTranscription;
+    private endSpeech;
+    private processFinalTranscription;
+    private getRecentAudioData;
+    private transcribeAudio;
+    private rawToWav;
+    private generateResponse;
+    private createAudioMemory;
+    stop(): Promise<void>;
+    isActive(): boolean;
+    getCurrentTranscription(): string;
+    isSpeechActive(): boolean;
+}
+//# sourceMappingURL=audio-capture-stream.d.ts.map

package/dist/audio-capture-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-capture-stream.d.ts","sourceRoot":"","sources":["../src/audio-capture-stream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EACL,KAAK,aAAa,EAInB,MAAM,eAAe,CAAC;AAEvB,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAQD,qBAAa,4BAA6B,SAAQ,YAAY;IAC5D,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,YAAY,CAA+B;IACnD,OAAO,CAAC,uBAAuB,CAAS;IACxC,OAAO,CAAC,oBAAoB,CAAM;IAClC,OAAO,CAAC,aAAa,CAA+B;gBAExC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,oBAAoB;IAc1D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAmBnB,sBAAsB;IA2FpC,OAAO,CAAC,iBAAiB;IAuDzB,OAAO,CAAC,eAAe;YAcT,2BAA2B;IAqCzC,OAAO,CAAC,SAAS;YAcH,yBAAyB;IA8BvC,OAAO,CAAC,kBAAkB;YA2BZ,eAAe;IAyB7B,OAAO,CAAC,QAAQ;YAkCF,gBAAgB;YAchB,iBAAiB;IAwBzB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAyB3B,QAAQ,IAAI,OAAO;IAInB,uBAAuB,IAAI,MAAM;IAIjC,cAAc,IAAI,OAAO;CAG1B"}

package/dist/audio-capture.d.ts

@@ -0,0 +1,25 @@
+import { type IAgentRuntime } from "@elizaos/core";
+export interface AudioConfig {
+    enabled: boolean;
+    transcriptionInterval: number;
+    device?: string;
+    sampleRate?: number;
+    channels?: number;
+}
+export declare class AudioCaptureService {
+    private runtime;
+    private config;
+    private isRecording;
+    private recordingInterval;
+    constructor(runtime: IAgentRuntime, config: AudioConfig);
+    initialize(): Promise<void>;
+    private checkAudioTools;
+    private startTranscriptionLoop;
+    recordAndTranscribe(): Promise<string | null>;
+    private recordAudio;
+    private createAudioMemory;
+    listAudioDevices(): Promise<string[]>;
+    isActive(): boolean;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=audio-capture.d.ts.map

package/dist/audio-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-capture.d.ts","sourceRoot":"","sources":["../src/audio-capture.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,aAAa,EAInB,MAAM,eAAe,CAAC;AAIvB,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,iBAAiB,CAA+B;gBAE5C,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW;IASjD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAgCnB,eAAe;IAgD7B,OAAO,CAAC,sBAAsB;IAexB,mBAAmB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;YA4DrC,WAAW;YAqCX,iBAAiB;IAuBzB,gBAAgB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IA+D3C,QAAQ,IAAI,OAAO;IAIb,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAe5B"}

package/dist/computeruse-ocr-bridge.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Bridge plugin-vision's hierarchical OCR into plugin-computeruse's
+ * `CoordOcrProvider` registry seam.
+ *
+ * plugin-vision owns the OCR implementations; plugin-computeruse's
+ * scene-builder + GET_SCREEN want coordinate-aware OCR but must NOT take a
+ * hard dependency on plugin-vision (that would create a cycle and force the
+ * vision OCR stack onto every computeruse consumer). So plugin-vision
+ * registers a bridge into computeruse's seam at boot via a best-effort dynamic
+ * import (see `index.ts`).
+ *
+ * The two interfaces are structurally identical — vision's
+ * `OcrWithCoordsService.describe(OcrWithCoordsInput) -> OcrWithCoordsResult`
+ * and computeruse's `CoordOcrProvider.describe(CoordOcrInput) -> CoordOcrResult`
+ * share field shapes (displayId/sourceX/sourceY/pngBytes in; blocks with
+ * bbox+words+semantic_position out) — so the bridge is a thin pass-through.
+ * The types live in different packages, so we describe computeruse's side
+ * structurally here rather than importing it (keeps the no-hard-dep rule).
+ *
+ * Pure + injectable so the wiring is unit-testable without a real
+ * plugin-computeruse present.
+ */
+import { type OcrWithCoordsResult, type OcrWithCoordsService } from "./ocr-with-coords.js";
+/** Structural shape of `@elizaos/plugin-computeruse`'s `CoordOcrInput`. */
+export interface CoordOcrInputLike {
+    readonly displayId: string;
+    readonly sourceX: number;
+    readonly sourceY: number;
+    readonly pngBytes: Uint8Array;
+}
+/** Structural shape of `@elizaos/plugin-computeruse`'s `CoordOcrProvider`. */
+export interface CoordOcrProviderLike {
+    readonly name: string;
+    describe(input: CoordOcrInputLike): Promise<OcrWithCoordsResult>;
+}
+export type RegisterCoordOcrProvider = (provider: CoordOcrProviderLike | null) => void;
+export declare const VISION_COORD_OCR_BRIDGE_NAME = "vision-coord-ocr-bridge";
+/**
+ * Build a `CoordOcrProvider`-shaped bridge that delegates to whatever vision
+ * `OcrWithCoordsService` is currently registered. Resolving the service lazily
+ * (per call) means a later `registerOcrWithCoordsService()` (e.g. swapping in a
+ * native Windows.Media.Ocr / Apple Vision provider) is picked up automatically.
+ */
+export declare function buildVisionCoordOcrBridge(resolve?: () => OcrWithCoordsService | null): CoordOcrProviderLike;
+/**
+ * Register the vision OCR bridge into computeruse's CoordOcrProvider seam.
+ * Idempotent (the seam is last-call-wins). Returns true once registered.
+ */
+export declare function wireComputerUseOcrBridge(register: RegisterCoordOcrProvider, resolve?: () => OcrWithCoordsService | null): boolean;
+//# sourceMappingURL=computeruse-ocr-bridge.d.ts.map

package/dist/computeruse-ocr-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeruse-ocr-bridge.d.ts","sourceRoot":"","sources":["../src/computeruse-ocr-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EAC1B,MAAM,sBAAsB,CAAC;AAE9B,2EAA2E;AAC3E,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;CAC/B;AAED,8EAA8E;AAC9E,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;CAClE;AAED,MAAM,MAAM,wBAAwB,GAAG,CACrC,QAAQ,EAAE,oBAAoB,GAAG,IAAI,KAClC,IAAI,CAAC;AAEV,eAAO,MAAM,4BAA4B,4BAA4B,CAAC;AAEtE;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,MAAM,oBAAoB,GAAG,IAA8B,GACnE,oBAAoB,CAetB;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,wBAAwB,EAClC,OAAO,CAAC,EAAE,MAAM,oBAAoB,GAAG,IAAI,GAC1C,OAAO,CAGT"}

package/dist/config.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import type { VisionConfig } from "./types";
+export declare const defaultVisionConfig: VisionConfig;
+export declare const VisionConfigSchema: z.ZodObject<{
+    cameraName: z.ZodOptional<z.ZodString>;
+    enableCamera: z.ZodDefault<z.ZodBoolean>;
+    pixelChangeThreshold: z.ZodDefault<z.ZodNumber>;
+    updateInterval: z.ZodDefault<z.ZodNumber>;
+    enableObjectDetection: z.ZodDefault<z.ZodBoolean>;
+    objectConfidenceThreshold: z.ZodDefault<z.ZodNumber>;
+    enablePoseDetection: z.ZodDefault<z.ZodBoolean>;
+    poseConfidenceThreshold: z.ZodDefault<z.ZodNumber>;
+    tfUpdateInterval: z.ZodDefault<z.ZodNumber>;
+    vlmUpdateInterval: z.ZodDefault<z.ZodNumber>;
+    tfChangeThreshold: z.ZodDefault<z.ZodNumber>;
+    vlmChangeThreshold: z.ZodDefault<z.ZodNumber>;
+    visionMode: z.ZodDefault<z.ZodEnum<{
+        OFF: "OFF";
+        CAMERA: "CAMERA";
+        SCREEN: "SCREEN";
+        BOTH: "BOTH";
+    }>>;
+    screenCaptureInterval: z.ZodDefault<z.ZodNumber>;
+    tileSize: z.ZodDefault<z.ZodNumber>;
+    tileProcessingOrder: z.ZodDefault<z.ZodEnum<{
+        sequential: "sequential";
+        priority: "priority";
+        random: "random";
+    }>>;
+    maxConcurrentTiles: z.ZodDefault<z.ZodNumber>;
+    ocrEnabled: z.ZodDefault<z.ZodBoolean>;
+    ocrLanguage: z.ZodDefault<z.ZodString>;
+    ocrConfidenceThreshold: z.ZodDefault<z.ZodNumber>;
+    enableFaceRecognition: z.ZodDefault<z.ZodBoolean>;
+    faceMatchThreshold: z.ZodDefault<z.ZodNumber>;
+    maxFaceProfiles: z.ZodDefault<z.ZodNumber>;
+    entityTimeout: z.ZodDefault<z.ZodNumber>;
+    maxTrackedEntities: z.ZodDefault<z.ZodNumber>;
+    enableGPUAcceleration: z.ZodDefault<z.ZodBoolean>;
+    maxMemoryUsageMB: z.ZodDefault<z.ZodNumber>;
+    debugMode: z.ZodDefault<z.ZodBoolean>;
+    logLevel: z.ZodDefault<z.ZodEnum<{
+        info: "info";
+        error: "error";
+        warn: "warn";
+        debug: "debug";
+    }>>;
+}, z.core.$strip>;
+export type VisionConfigInput = z.input<typeof VisionConfigSchema>;
+export type VisionConfigOutput = z.output<typeof VisionConfigSchema>;
+interface RuntimeWithSettings {
+    getSetting(key: string): string | undefined;
+}
+export declare class ConfigurationManager {
+    private config;
+    private runtime;
+    constructor(runtime: RuntimeWithSettings);
+    private loadConfiguration;
+    private getSetting;
+    private getBooleanSetting;
+    private getNumberSetting;
+    private getEnumSetting;
+    get(): VisionConfigOutput;
+    update(updates: Partial<VisionConfigInput>): void;
+    static getPreset(name: string): Partial<VisionConfigInput>;
+}
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,SAAS,CAAC;AAExD,eAAO,MAAM,mBAAmB,EAAE,YAcjC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgC7B,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACnE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAErE,UAAU,mBAAmB;IAC3B,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CAC7C;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,OAAO,CAAsB;gBAEzB,OAAO,EAAE,mBAAmB;IAKxC,OAAO,CAAC,iBAAiB;IAiGzB,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,cAAc;IAetB,GAAG,IAAI,kBAAkB;IAIzB,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,IAAI;IAejD,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAmC3D"}

package/dist/describe-backpressure.d.ts

@@ -0,0 +1,90 @@
+export type MemoryPressureLevel = "nominal" | "low" | "critical";
+export type DescribePauseReason = "arbiter-pressure" | "memory-cap" | null;
+export interface DescribeBackpressureStats {
+    /** True while the describe step is currently being skipped. */
+    paused: boolean;
+    /** Last arbiter pressure level applied via `setPressure`. */
+    pressureLevel: MemoryPressureLevel;
+    /** Describe ticks skipped because of backpressure since construction. */
+    describesSkipped: number;
+    /** Count of paused<->active edges (telemetry / test signal). */
+    pauseTransitions: number;
+    /** RSS captured on the first describe tick, used as the local cap baseline. */
+    memoryBaselineBytes: number | null;
+    /** Latest sampled RSS growth over the captured baseline. */
+    memoryGrowthBytes: number | null;
+}
+export interface DescribeBackpressureDecision {
+    /** Run the expensive describe this tick? */
+    describe: boolean;
+    /** `"paused"`/`"active"` when this call flipped the state, else `null`. */
+    transitionedTo: "paused" | "active" | null;
+    /** Why we are paused (only meaningful when `describe === false`). */
+    reason: DescribePauseReason;
+    /** How long the current continuous pause has lasted, in ms. */
+    pausedForMs: number;
+    /** True when the caller should emit a throttled long-pause warning. */
+    warnPaused: boolean;
+}
+export interface DescribeBackpressureConfig {
+    /**
+     * RSS growth cap in bytes. The first describe tick captures the process RSS
+     * baseline; while sampled RSS exceeds `baseline + memoryCapBytes`, the
+     * describe step pauses. `0` or negative disables the local check — only the
+     * arbiter signal can pause describing.
+     */
+    memoryCapBytes?: number;
+    /**
+     * RSS sampler; defaults to `process.memoryUsage().rss`. Injected by tests so
+     * the cap can be exercised deterministically without allocating memory.
+     */
+    sampleRssBytes?: () => number;
+    /**
+     * How long a single arbiter pressure signal keeps the loop paused, in ms.
+     * Because the WS1 bridge delivers pressure but not recovery, the pause
+     * auto-clears after this window of silence. Default 15_000.
+     */
+    arbiterPauseCooldownMs?: number;
+    /** Continuous pause duration before a warning is requested. Default 60s. */
+    pauseWarningThresholdMs?: number;
+    /** Minimum interval between repeated long-pause warnings. Default 60s. */
+    pauseWarningIntervalMs?: number;
+    /** Clock, injectable for tests. Defaults to `Date.now`. */
+    now?: () => number;
+}
+export declare class DescribeBackpressureController {
+    private readonly memoryCapBytes;
+    private readonly sampleRssBytes;
+    private readonly arbiterPauseCooldownMs;
+    private readonly pauseWarningThresholdMs;
+    private readonly pauseWarningIntervalMs;
+    private readonly now;
+    private pressureLevel;
+    private pauseUntilMs;
+    private paused;
+    private describesSkipped;
+    private pauseTransitions;
+    private memoryBaselineBytes;
+    private latestMemoryGrowthBytes;
+    private pauseStartedAtMs;
+    private lastPauseWarningAtMs;
+    constructor(config?: DescribeBackpressureConfig);
+    /**
+     * Apply an arbiter memory-pressure level. A non-nominal level opens (or
+     * extends) the cooldown pause window; `nominal` clears it immediately (only
+     * arbiters that actually report recovery do this — the WS1 bridge relies on
+     * the cooldown instead).
+     */
+    setPressure(level: MemoryPressureLevel): void;
+    /**
+     * Decide whether the expensive describe step may run this tick. Call ONLY
+     * when a describe would otherwise happen (the change/time gate already
+     * passed), so the skip counter reflects real avoided work. Has side effects:
+     * updates the skip counter and the pause/resume transition state. The
+     * arbiter signal takes precedence over the local cap when both are active so
+     * the reported `reason` is the more authoritative one.
+     */
+    evaluate(): DescribeBackpressureDecision;
+    stats(): DescribeBackpressureStats;
+}
+//# sourceMappingURL=describe-backpressure.d.ts.map

package/dist/describe-backpressure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describe-backpressure.d.ts","sourceRoot":"","sources":["../src/describe-backpressure.ts"],"names":[],"mappings":"AAmCA,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,KAAK,GAAG,UAAU,CAAC;AAEjE,MAAM,MAAM,mBAAmB,GAAG,kBAAkB,GAAG,YAAY,GAAG,IAAI,CAAC;AAE3E,MAAM,WAAW,yBAAyB;IACxC,+DAA+D;IAC/D,MAAM,EAAE,OAAO,CAAC;IAChB,6DAA6D;IAC7D,aAAa,EAAE,mBAAmB,CAAC;IACnC,yEAAyE;IACzE,gBAAgB,EAAE,MAAM,CAAC;IACzB,gEAAgE;IAChE,gBAAgB,EAAE,MAAM,CAAC;IACzB,+EAA+E;IAC/E,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,4DAA4D;IAC5D,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,4BAA4B;IAC3C,4CAA4C;IAC5C,QAAQ,EAAE,OAAO,CAAC;IAClB,2EAA2E;IAC3E,cAAc,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAAC;IAC3C,qEAAqE;IACrE,MAAM,EAAE,mBAAmB,CAAC;IAC5B,+DAA+D;IAC/D,WAAW,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,MAAM,CAAC;IAC9B;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,4EAA4E;IAC5E,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,0EAA0E;IAC1E,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,2DAA2D;IAC3D,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAMD,qBAAa,8BAA8B;IACzC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAe;IAC9C,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAChD,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAS;IACjD,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAChD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,aAAa,CAAkC;IACvD,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,uBAAuB,CAAuB;IACtD,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,oBAAoB,CAAK;gBAErB,MAAM,GAAE,0BAA+B;IAyBnD;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI;IAS7C;;;;;;;OAOG;IACH,QAAQ,IAAI,4BAA4B;IA2DxC,KAAK,IAAI,yBAAyB;CAUnC"}

package/dist/dirty-tile-describer.d.ts

@@ -0,0 +1,102 @@
+/**
+ * DirtyTileDescriber — change-gated, per-tile screen description (#9105 M3).
+ *
+ * The dominant token cost in a CUA loop is re-describing a whole screen to a
+ * VLM every step even when almost nothing moved. The Brain already skips the
+ * describe entirely when the *whole frame* dHash is unchanged
+ * (`plugin-computeruse` `Brain` frame-dHash cache). This describer is the
+ * finer-grained tier: it splits a frame into tiles (via `screen-tiler.ts`),
+ * computes a per-tile perceptual hash, and only (re)describes tiles whose hash
+ * changed since the last frame — every unchanged tile reuses its cached
+ * description. So a single text field flipping characters re-describes one tile,
+ * not the entire screen.
+ *
+ * The describer is pure + injectable: the tile hash (`hashTile`) and the
+ * per-tile describe call (`describeTile`) are supplied by the caller. The real
+ * boot wiring injects `plugin-computeruse`'s `frameDhash` (the existing
+ * `scene/dhash.ts`) and a `runtime.useModel(IMAGE_DESCRIPTION)`-backed describe;
+ * tests inject deterministic fakes with no model and no native dHash. The
+ * counters (`describeCallsSaved`, `approxTokensSaved`) make the saving
+ * measurable so a test can assert it.
+ */
+import type { ScreenTile } from "./screen-tiler.js";
+/** Approx image tokens charged for one tile describe — used only for the saved-tokens estimate. */
+export declare const APPROX_TOKENS_PER_TILE = 256;
+/** A described tile: its source rectangle plus the VLM/OCR text for it. */
+export interface DescribedTile {
+    /** Tiler id, e.g. `tile-1-0`. */
+    id: string;
+    displayId: string;
+    /** Top-left of the tile in source display pixel space. */
+    sourceX: number;
+    sourceY: number;
+    sourceW: number;
+    sourceH: number;
+    /** The description text for this tile. */
+    description: string;
+    /** True when this tile's description was reused from cache (no describe call). */
+    cached: boolean;
+}
+export interface DirtyTileDescription {
+    /** One entry per tile, in tiler order. */
+    tiles: DescribedTile[];
+    /** Composed full-frame description (non-empty tile texts, source-order). */
+    vlmScene: string;
+    /** Per-tile elements suitable for `Scene.vlm_elements`. */
+    elements: DirtyTileElement[];
+}
+/** A described tile projected into the `Scene.vlm_elements` shape. */
+export interface DirtyTileElement {
+    id: string;
+    kind: string;
+    desc: string;
+    /** Display-local `[x, y, w, h]` of the tile. */
+    bbox: [number, number, number, number];
+    displayId: number;
+}
+/** Token-accounting snapshot for a describer. */
+export interface DirtyTileStats {
+    /** Tiles actually sent to the describe call. */
+    tilesDescribed: number;
+    /** Tiles served from the per-tile cache (no describe call). */
+    tilesSkipped: number;
+    /** Describe calls avoided by the cache (== tilesSkipped). */
+    describeCallsSaved: number;
+    /** Approx image tokens avoided (tilesSkipped × APPROX_TOKENS_PER_TILE). */
+    approxTokensSaved: number;
+}
+export interface DirtyTileDescriberDeps {
+    /**
+     * Perceptual hash of a tile PNG. Identical pixels MUST hash equal. The boot
+     * wiring passes `plugin-computeruse`'s `frameDhash`; `null` means "could not
+     * hash" and forces a (re)describe for that tile.
+     */
+    hashTile: (png: Buffer) => bigint | null;
+    /** Describe one tile's pixels. Only called for changed/new tiles. */
+    describeTile: (tile: ScreenTile) => Promise<string>;
+    /** Tiling options forwarded to `tileScreenshot`. */
+    maxEdge?: number;
+    overlapFraction?: number;
+    /** Tokens charged per describe, for the saved-tokens estimate. */
+    approxTokensPerTile?: number;
+}
+export declare class DirtyTileDescriber {
+    private readonly deps;
+    /** tileId → { hash, description } from the previous frame. */
+    private readonly cache;
+    private stats;
+    constructor(deps: DirtyTileDescriberDeps);
+    getStats(): DirtyTileStats;
+    /**
+     * Describe a frame, re-describing only tiles whose hash changed since the
+     * previous call. Unchanged tiles reuse their cached description.
+     */
+    describe(input: {
+        displayId: number;
+        width: number;
+        height: number;
+        pngBytes: Buffer;
+    }): Promise<DirtyTileDescription>;
+    private toDescribed;
+}
+//# sourceMappingURL=dirty-tile-describer.d.ts.map

package/dist/dirty-tile-describer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dirty-tile-describer.d.ts","sourceRoot":"","sources":["../src/dirty-tile-describer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,mGAAmG;AACnG,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,2EAA2E;AAC3E,MAAM,WAAW,aAAa;IAC5B,iCAAiC;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,kFAAkF;IAClF,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,0CAA0C;IAC1C,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,4EAA4E;IAC5E,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B;AAED,sEAAsE;AACtE,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,iDAAiD;AACjD,MAAM,WAAW,cAAc;IAC7B,gDAAgD;IAChD,cAAc,EAAE,MAAM,CAAC;IACvB,+DAA+D;IAC/D,YAAY,EAAE,MAAM,CAAC;IACrB,6DAA6D;IAC7D,kBAAkB,EAAE,MAAM,CAAC;IAC3B,2EAA2E;IAC3E,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IACzC,qEAAqE;IACrE,YAAY,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACpD,oDAAoD;IACpD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kEAAkE;IAClE,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,qBAAa,kBAAkB;IAajB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAZjC,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAGlB;IACJ,OAAO,CAAC,KAAK,CAKX;gBAE2B,IAAI,EAAE,sBAAsB;IAEzD,QAAQ,IAAI,cAAc;IAI1B;;;OAGG;IACG,QAAQ,CAAC,KAAK,EAAE;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAqEjC,OAAO,CAAC,WAAW;CAgBpB"}

package/dist/dirty-tile-scene.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Wiring seam for the change-gated per-tile scene describe (#9105 efficiency).
+ *
+ * `DirtyTileDescriber` (dirty-tile-describer.ts) is pure + injectable: it owns
+ * the per-tile hash cache and the "only re-describe changed tiles" loop, but it
+ * does not know how to hash a tile or how to ask the VLM to describe one. This
+ * module supplies those two collaborators from the live runtime so
+ * `VisionService` can build a describer that re-describes only the screen
+ * regions that actually changed since the previous frame instead of paying for
+ * a whole-frame VLM pass every scene tick.
+ *
+ * Two collaborators:
+ *   - `hashTile`: a perceptual hash. We reuse plugin-computeruse's `frameDhash`
+ *     (the same dHash the Brain frame-cache uses), resolved via a best-effort
+ *     dynamic import so plugin-vision never eagerly pulls computeruse's module
+ *     graph at boot — exactly the idiom the OCR bridge already uses. When
+ *     computeruse is absent the resolve returns `null` and the caller degrades
+ *     to the existing full-frame describe.
+ *   - `describeTile`: one `runtime.useModel(IMAGE_DESCRIPTION, …)` call per
+ *     changed tile, built from a caller-supplied prompt + result normalizer so
+ *     the per-tile path reuses the same prompt plumbing as the full-frame path.
+ */
+import type { ScreenTile } from "./screen-tiler.js";
+/** PNG perceptual hash. Identical pixels MUST hash equal; `null` = undecodable. */
+export type FrameHash = (png: Buffer) => bigint | null;
+/** Per-tile describe call. Returns the model's description text for one tile. */
+export type TileDescribeFn = (tile: ScreenTile) => Promise<string>;
+export interface TileDescribeDeps {
+    /**
+     * Build the per-tile image URL the VLM is asked to describe. The tile carries
+     * PNG bytes (`tile.pngBytes`), so this is a `data:image/png;base64,…` URL.
+     */
+    buildTileImageUrl: (tile: ScreenTile) => string;
+    /**
+     * Build the per-tile prompt. Receives the tile so callers can include bounds.
+     * Async because the scene context is pulled from a peer provider per call.
+     */
+    buildTilePrompt: (tile: ScreenTile) => Promise<string>;
+    /** Invoke the IMAGE_DESCRIPTION model and return its raw result. */
+    invokeModel: (imageUrl: string, prompt: string) => Promise<unknown>;
+    /**
+     * Normalize a model result into a description string, or `null` when the
+     * result is unusable (sentinel / empty). A `null` result yields an empty tile
+     * description, which the describer treats as "nothing to compose for this
+     * tile" while still caching the (empty) result against the tile hash.
+     */
+    extractDescription: (result: unknown) => string | null;
+}
+/**
+ * Build a `describeTile` function bound to the runtime's IMAGE_DESCRIPTION
+ * model. The describer calls this only for tiles whose hash changed.
+ */
+export declare function createTileDescribeFn(deps: TileDescribeDeps): TileDescribeFn;
+/** Encode a tile's PNG bytes into a base64 data URL for the VLM. */
+export declare function tilePngToImageUrl(tile: ScreenTile): string;
+//# sourceMappingURL=dirty-tile-scene.d.ts.map

package/dist/dirty-tile-scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dirty-tile-scene.d.ts","sourceRoot":"","sources":["../src/dirty-tile-scene.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,mFAAmF;AACnF,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;AAEvD,iFAAiF;AACjF,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAEnE,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,iBAAiB,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,MAAM,CAAC;IAChD;;;OAGG;IACH,eAAe,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACvD,oEAAoE;IACpE,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACpE;;;;;OAKG;IACH,kBAAkB,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI,CAAC;CACxD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,GAAG,cAAc,CAO3E;AAED,oEAAoE;AACpE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAE1D"}