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

package/dist/lifecycle.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Minimal contract a memory arbiter must implement so vision can plug into
+ * WS1's load/unload pipeline. Mirrors the (forthcoming) interface in
+ * `@elizaos/plugin-local-inference/src/services/memory-arbiter.ts` but is
+ * declared here so plugin-vision compiles standalone.
+ */
+export interface IModelArbiter {
+    /**
+     * Reserve `bytes` of model memory for `holder`. Returning `false` means the
+     * arbiter refused — the caller must skip the load.
+     */
+    acquire(holder: string, bytes: number): Promise<boolean> | boolean;
+    /**
+     * Release the prior reservation for `holder`.
+     */
+    release(holder: string): Promise<void> | void;
+    /**
+     * Subscribe to memory-pressure events. The arbiter calls the listener with
+     * a non-empty list of holders when pressure is high enough that those
+     * holders should release.
+     */
+    onPressure(listener: (holders: string[]) => void): () => void;
+}
+export interface VisionSubServiceHandle {
+    /** Stable holder id (e.g. "vision:yolo"). */
+    id: string;
+    /** Approximate VRAM/RAM cost in bytes. Used by the arbiter; ignored if 0. */
+    memoryBytes: number;
+    /** Optional hook invoked when the sub-service has been released. */
+    unload(): Promise<void> | void;
+    /** Optional hook invoked to re-load after a prior release. */
+    acquire?(): Promise<void> | void;
+}
+export interface VisionLifecycleConfig {
+    /** Milliseconds of inactivity before a sub-service is released. */
+    idleUnloadMs?: number;
+    /** Tick interval for the idle watchdog. */
+    watchdogIntervalMs?: number;
+}
+export declare class VisionServiceLifecycleManager {
+    private readonly subs;
+    private readonly idleUnloadMs;
+    private readonly watchdogIntervalMs;
+    private arbiter;
+    private unsubscribePressure;
+    private watchdogTimer;
+    private stopped;
+    constructor(config?: VisionLifecycleConfig);
+    attachArbiter(arbiter: IModelArbiter | null): void;
+    register(handle: VisionSubServiceHandle): void;
+    unregister(id: string): void;
+    /**
+     * Mark a sub-service as in-use. If it was previously released, re-acquire
+     * via the registered `acquire` callback (if any).
+     *
+     * Returns `true` if the sub-service is loaded after the call.
+     */
+    touch(id: string): Promise<boolean>;
+    /**
+     * Force-release a single holder.
+     */
+    release(id: string): Promise<void>;
+    /**
+     * Drop every registered sub-service (used during plugin stop()).
+     */
+    stop(): Promise<void>;
+    /** Test-only: return current snapshot. */
+    snapshot(): Array<{
+        id: string;
+        loaded: boolean;
+        lastUsed: number;
+    }>;
+    private ensureWatchdog;
+    private runWatchdog;
+    private handlePressure;
+}
+/**
+ * Try to resolve a model arbiter from the runtime, dynamically. This avoids
+ * a hard dependency on `@elizaos/plugin-local-inference` (WS1) — vision still
+ * works standalone when WS1 isn't installed.
+ *
+ * Two resolution paths:
+ *   1. Direct: a service named `MEMORY_ARBITER` / `memory_arbiter` /
+ *      `memoryArbiter` that already implements the `IModelArbiter` shape.
+ *      Used by tests and standalone arbiter services.
+ *   2. WS1 bridge: a `localInferenceLoader` / `localInference` service that
+ *      exposes `getMemoryArbiter()` returning the WS1 `MemoryArbiter`. We
+ *      adapt it to `IModelArbiter` via `adaptWS1ArbiterToIModelArbiter` so
+ *      memory-pressure events cascade into vision sub-service release.
+ */
+export declare function resolveArbiterFromRuntime(runtime: {
+    getService?: (name: string) => unknown;
+}): IModelArbiter | null;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../src/lifecycle.ts"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IAEnE;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAE9C;;;;OAIG;IACH,UAAU,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CAC/D;AAED,MAAM,WAAW,sBAAsB;IACrC,6CAA6C;IAC7C,EAAE,EAAE,MAAM,CAAC;IACX,6EAA6E;IAC7E,WAAW,EAAE,MAAM,CAAC;IACpB,oEAAoE;IACpE,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC/B,8DAA8D;IAC9D,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,qBAAqB;IACpC,mEAAmE;IACnE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAYD,qBAAa,6BAA6B;IACxC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoC;IACzD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,OAAO,CAA8B;IAC7C,OAAO,CAAC,mBAAmB,CAA6B;IACxD,OAAO,CAAC,aAAa,CAA+B;IACpD,OAAO,CAAC,OAAO,CAAS;gBAEZ,MAAM,GAAE,qBAA0B;IAM9C,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,GAAG,IAAI;IAelD,QAAQ,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI;IAW9C,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAI5B;;;;;OAKG;IACG,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAgCzC;;OAEG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYxC;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B,0CAA0C;IAC1C,QAAQ,IAAI,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAQpE,OAAO,CAAC,cAAc;YAWR,WAAW;YAYX,cAAc;CAa7B;AAyDD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE;IACjD,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CACxC,GAAG,aAAa,GAAG,IAAI,CAqCvB"}

package/dist/mobile/capacitor-camera.d.ts

@@ -0,0 +1,85 @@
+import type { CameraInfo, VisionFrame } from "../types";
+interface MobileCameraOpenOptions {
+    /** Stable camera id (typically `back` / `front` / a per-device id). */
+    cameraId?: string;
+    /** Desired frame width in pixels — the native side may snap to nearest. */
+    width?: number;
+    /** Desired frame height in pixels. */
+    height?: number;
+    /** Desired frame rate. */
+    fps?: number;
+}
+/**
+ * Minimal interface every mobile camera implementation must satisfy.
+ *
+ * Implementations live in:
+ *   - plugin-aosp (Android NNAPI / CameraX) — WS8
+ *   - plugin-ios (Core ML / AVFoundation) — WS9
+ *   - plugin-capacitor-bridge (cross-platform Capacitor plugin) — planned bridge package
+ */
+export interface MobileCameraSource {
+    /** Discover cameras visible to the OS. */
+    listCameras(): Promise<CameraInfo[]>;
+    /** Open a session when the native source supports continuous capture. */
+    open(opts?: MobileCameraOpenOptions): Promise<void>;
+    /** Capture a single frame as a JPEG buffer. */
+    captureJpeg(): Promise<Buffer>;
+    /** Capture and return a fully-decoded RGBA frame. */
+    captureRgbaFrame?(): Promise<VisionFrame>;
+    /** Tear down the session. */
+    close(): Promise<void>;
+    /** Optional capability declaration — UIs use this to gate buttons. */
+    capabilities?(): {
+        supportsContinuousFrames: boolean;
+        supportsExposureLock: boolean;
+        supportsTorch: boolean;
+    };
+}
+interface CapacitorVisionPlugin {
+    listCameras?: () => Promise<CameraInfo[]>;
+    open?: (opts?: MobileCameraOpenOptions) => Promise<void>;
+    captureJpeg?: () => Promise<Buffer | Uint8Array | string | {
+        data?: string;
+    }>;
+    captureRgbaFrame?: () => Promise<VisionFrame | {
+        data: string;
+    }>;
+    close?: () => Promise<void>;
+    capabilities?: () => Promise<{
+        supportsContinuousFrames: boolean;
+        supportsExposureLock: boolean;
+        supportsTorch: boolean;
+    }>;
+}
+export declare class CapacitorCameraSource implements MobileCameraSource {
+    private readonly plugin;
+    constructor(plugin: CapacitorVisionPlugin);
+    listCameras(): Promise<CameraInfo[]>;
+    open(opts?: MobileCameraOpenOptions): Promise<void>;
+    captureJpeg(): Promise<Buffer>;
+    captureRgbaFrame(): Promise<VisionFrame>;
+    close(): Promise<void>;
+    capabilities(): {
+        supportsContinuousFrames: boolean;
+        supportsExposureLock: boolean;
+        supportsTorch: boolean;
+    };
+}
+/**
+ * Default unavailable implementation. Returns no cameras and refuses captures.
+ * This keeps the plugin-vision JS surface buildable on Node platforms where no
+ * native bridge is registered.
+ */
+export declare class UnavailableMobileCameraSource implements MobileCameraSource {
+    listCameras(): Promise<CameraInfo[]>;
+    open(): Promise<void>;
+    captureJpeg(): Promise<Buffer>;
+    close(): Promise<void>;
+}
+/** Compatibility alias for older imports. */
+export declare const CapacitorCameraStub: typeof UnavailableMobileCameraSource;
+export declare function registerMobileCameraSource(source: MobileCameraSource): void;
+export declare function getMobileCameraSource(): MobileCameraSource | null;
+export declare function clearMobileCameraSource(): void;
+export {};
+//# sourceMappingURL=capacitor-camera.d.ts.map

package/dist/mobile/capacitor-camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capacitor-camera.d.ts","sourceRoot":"","sources":["../../src/mobile/capacitor-camera.ts"],"names":[],"mappings":"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"}

package/dist/native/doctr-ffi.d.ts

@@ -0,0 +1,40 @@
+/** Where the runtime expects GGUF weights. */
+export declare function defaultDetWeightsPath(): string;
+export declare function defaultRecWeightsPath(): string;
+interface DocTRBindings {
+    /** Detection forward pass. Output: prob map at H/4 × W/4. */
+    detect(detGGUFPath: string, rgbCHW: Float32Array, h: number, w: number): Promise<{
+        probMap: Float32Array;
+        h: number;
+        w: number;
+    }>;
+    /** Recognition forward pass on a cropped line image. */
+    recognize(recGGUFPath: string, rgbCHW: Float32Array, h: number, w: number): Promise<{
+        logits: Float32Array;
+        T: number;
+        C: number;
+    }>;
+    /** Returns the recognition charset (utf-8, newline separated). */
+    charset(recGGUFPath: string): Promise<string>;
+    dispose(): Promise<void>;
+}
+/**
+ * Load the doctr.cpp shared library via `bun:ffi`. Returns null when either
+ * the library or the GGUF weights are missing — the caller is expected to
+ * throw a clear error in that case rather than silently fall back.
+ */
+export declare function loadDoctrBindings(): Promise<DocTRBindings | null>;
+/**
+ * `true` when both the native library and the GGUF weights exist on disk. Does
+ * not actually initialize anything — callers should still expect the C++ side
+ * to return DOCTR_ERR_BACKEND until the ggml graph is wired.
+ */
+export declare function isDoctrReady(opts?: {
+    detPath?: string;
+    recPath?: string;
+}): Promise<{
+    ready: boolean;
+    reason?: string;
+}>;
+export {};
+//# sourceMappingURL=doctr-ffi.d.ts.map

package/dist/native/doctr-ffi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctr-ffi.d.ts","sourceRoot":"","sources":["../../src/native/doctr-ffi.ts"],"names":[],"mappings":"AA0CA,8CAA8C;AAC9C,wBAAgB,qBAAqB,IAAI,MAAM,CAO9C;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAO9C;AAsBD,UAAU,aAAa;IACrB,6DAA6D;IAC7D,MAAM,CACJ,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,YAAY,EACpB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,OAAO,CAAC;QAAE,OAAO,EAAE,YAAY,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAE5D,wDAAwD;IACxD,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,YAAY,EACpB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,OAAO,CAAC;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAE3D,kEAAkE;IAClE,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE9C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAID;;;;GAIG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAsLvE;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,IAAI,CAAC,EAAE;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAqB/C"}

package/dist/native/yolo-ffi.d.ts

@@ -0,0 +1,21 @@
+export declare function defaultYoloWeightsPath(): string;
+interface YoloBindings {
+    /** Run forward pass. Returns the raw (channels, anchors) logits tensor. */
+    run(ggufPath: string, rgbCHW: Float32Array, h: number, w: number): Promise<{
+        logits: Float32Array;
+        channels: number;
+        anchors: number;
+    }>;
+    /** Returns the embedded class names (newline-separated). */
+    classes(ggufPath: string): Promise<string>;
+    dispose(): Promise<void>;
+}
+export declare function loadYoloBindings(): Promise<YoloBindings | null>;
+export declare function isYoloReady(opts?: {
+    weightsPath?: string;
+}): Promise<{
+    ready: boolean;
+    reason?: string;
+}>;
+export {};
+//# sourceMappingURL=yolo-ffi.d.ts.map

package/dist/native/yolo-ffi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yolo-ffi.d.ts","sourceRoot":"","sources":["../../src/native/yolo-ffi.ts"],"names":[],"mappings":"AAuCA,wBAAgB,sBAAsB,IAAI,MAAM,CAO/C;AAED,UAAU,YAAY;IACpB,2EAA2E;IAC3E,GAAG,CACD,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,YAAY,EACpB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,OAAO,CAAC;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAExE,4DAA4D;IAC5D,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE3C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAmBD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CA0HrE;AAED,wBAAsB,WAAW,CAAC,IAAI,CAAC,EAAE;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,OAAO,CAAC;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAe/C"}

package/dist/ocr-host-windows.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Persistent WinRT OCR host (Windows-only) — kills the per-OCR cold-spawn tax.
+ *
+ * `WindowsMediaOcrService.describe()` previously ran `powershell -File
+ * windows-ocr.ps1` for EVERY recognized region. On Defender-heavy hosts a cold
+ * `powershell.exe` spawn is ~10-16s (#9581), and OCR fires on every dirty region
+ * every turn — and the scene pipeline OCRs regions in parallel, so a turn would
+ * spawn N cold processes at once and thrash the AV scanner.
+ *
+ * This keeps ONE long-lived `powershell.exe` that loads the (expensive) WinRT
+ * projection + `OcrEngine` ONCE in its parent scope, then loops: read an image
+ * path on stdin, recognize, emit one compact JSON line on stdout. So each call
+ * pays neither the process spawn NOR the WinRT type-load — only the recognize
+ * (~0.3-1s). Requests are serialized over the one pipe (fine — each is fast).
+ *
+ * It is a pure latency optimization: `describe()` falls back to the original
+ * one-shot `-File` spawn whenever the host is unavailable / disabled / errors,
+ * so output is unchanged. No-op off Windows. Disable with `ELIZA_VISION_OCR_HOST=0`.
+ *
+ * Protocol: JS writes `<absolute-image-path>\n`; the host writes exactly one
+ * line of compact JSON (`{width,height,lines}` — same shape as the one-shot
+ * script). base64 isn't needed: temp image paths never contain newlines, and
+ * `ConvertTo-Json -Compress` output is always a single physical line.
+ */
+export declare function ocrHostAvailable(): boolean;
+export declare function shutdownOcrHost(): void;
+/**
+ * Recognize the image at `imagePath` via the warm host, returning the raw JSON
+ * line (same shape the one-shot script emits). Serialized against other calls.
+ * Rejects (so the caller can fall back to a one-shot spawn) on host-start
+ * failure, timeout, or unexpected exit.
+ */
+export declare function runOcrHost(imagePath: string): Promise<string>;
+//# sourceMappingURL=ocr-host-windows.d.ts.map

package/dist/ocr-host-windows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocr-host-windows.d.ts","sourceRoot":"","sources":["../src/ocr-host-windows.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAqFH,wBAAgB,gBAAgB,IAAI,OAAO,CAK1C;AA2BD,wBAAgB,eAAe,IAAI,IAAI,CAsBtC;AAuFD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ7D"}

package/dist/ocr-service-apple-vision-macos.d.ts

@@ -0,0 +1,51 @@
+/**
+ * macOS Apple Vision OCR provider (issue #9105 — per-OS native OCR fallback).
+ *
+ * Implements the structural `AppleVisionOcrProvider` seam from `ocr-service.ts`
+ * by shelling out to a bundled Swift helper (`native/macos-vision-ocr.swift`)
+ * that runs `VNRecognizeTextRequest` (accurate level, language correction on).
+ * The helper reads PNG/JPEG bytes from stdin and prints a single JSON object;
+ * this module pipes the bytes in and maps the result onto the provider shape.
+ *
+ * Zero LLM tokens, no model download — Apple Vision ships with macOS. This is
+ * the darwin sibling of `WindowsMediaOcrService` (Windows.Media.Ocr) and the
+ * iOS `createIosVisionOcrProvider` (Capacitor bridge): same VNRecognizeText
+ * engine, reached without Capacitor on a desktop host.
+ *
+ * Coordinate convention: Vision returns normalized BOTTOM-LEFT bboxes; the
+ * Swift helper converts them to TOP-LEFT PIXEL coordinates so the result
+ * matches the display-absolute convention used by every other provider.
+ *
+ * Fails soft: `available()` is false off darwin or when `swift` is missing, and
+ * `recognize()` returns an empty result rather than throwing on a helper
+ * failure, so the `OCRService` chain falls through to the doCTR backend.
+ */
+import type { AppleVisionOcrProvider } from "./ocr-service";
+interface MacosVisionAvailabilityOptions {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    pathExists?: (candidate: string) => boolean;
+    executableExists?: (name: string, env: NodeJS.ProcessEnv) => boolean;
+}
+/**
+ * Resolve the bundled Swift helper. Works from both the dev tree (`src/`) and
+ * the published build (`dist/`) — the `native/` directory sits alongside both,
+ * at the package root. `ELIZA_MACOS_VISION_OCR_SCRIPT` overrides for tests.
+ */
+declare function resolveScriptPath(env?: NodeJS.ProcessEnv, pathExists?: (candidate: string) => boolean): string | null;
+/** True when running on macOS with the `swift` toolchain and the helper present. */
+declare function macosVisionAvailable(options?: MacosVisionAvailabilityOptions): boolean;
+/**
+ * Build an `AppleVisionOcrProvider` backed by macOS Apple Vision. Register it
+ * via `registerAppleVisionOcrProvider(createMacosVisionOcrProvider())` on
+ * darwin so the `OCRService` Apple-Vision backend resolves a real engine.
+ */
+export declare function createMacosVisionOcrProvider(): AppleVisionOcrProvider;
+/** Exposed for the runtime wire-up + tests; mirrors `macosVisionAvailable`. */
+export declare function isMacosVisionOcrAvailable(): boolean;
+export declare const __test__: {
+    macosVisionAvailable: typeof macosVisionAvailable;
+    resolveScriptPath: typeof resolveScriptPath;
+};
+export {};
+//# sourceMappingURL=ocr-service-apple-vision-macos.d.ts.map

package/dist/ocr-service-apple-vision-macos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocr-service-apple-vision-macos.d.ts","sourceRoot":"","sources":["../src/ocr-service-apple-vision-macos.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAOH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAe5D,UAAU,8BAA8B;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IAC5C,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,UAAU,KAAK,OAAO,CAAC;CACtE;AAED;;;;GAIG;AACH,iBAAS,iBAAiB,CACxB,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,UAAU,GAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAoB,GACtD,MAAM,GAAG,IAAI,CAQf;AAsBD,oFAAoF;AACpF,iBAAS,oBAAoB,CAC3B,OAAO,GAAE,8BAAmC,GAC3C,OAAO,CAQT;AA8BD;;;;GAIG;AACH,wBAAgB,4BAA4B,IAAI,sBAAsB,CAoCrE;AAED,+EAA+E;AAC/E,wBAAgB,yBAAyB,IAAI,OAAO,CAEnD;AAED,eAAO,MAAM,QAAQ;;;CAGpB,CAAC"}

package/dist/ocr-service-doctr.d.ts

@@ -0,0 +1,61 @@
+import type { OCRResult } from "./types";
+export interface DoctrOCRConfig {
+    /** GGUF detection weights path. */
+    detPath?: string;
+    /** GGUF recognition weights path. */
+    recPath?: string;
+    /** Detection input resolution (square). Default 1024. */
+    inputSize?: number;
+    /** Probability threshold for the DBNet output. */
+    probThreshold?: number;
+    /** Minimum connected-component pixel count for a detection. */
+    minComponentSize?: number;
+}
+/**
+ * Detect platforms where Apple Vision is the better OCR choice.
+ *
+ * macOS Sonoma+ and iOS expose VNRecognizeTextRequest which is faster and
+ * higher-quality than any community OCR for Latin scripts. The integration
+ * lives in `plugin-computeruse/mobile`; we just refuse to claim availability
+ * so the higher-priority Apple Vision backend wins on darwin.
+ */
+export declare function shouldPreferAppleVision(): boolean;
+export declare class DoctrOCRService {
+    private readonly cfg;
+    private initPromise;
+    private initialized;
+    private charset;
+    constructor(config?: DoctrOCRConfig);
+    /**
+     * Best-effort availability check. Confirms the native lib loads and the
+     * GGUF files are on disk. Does NOT prove the ggml forward pass works —
+     * that's discovered on the first `extractText` call.
+     */
+    static isAvailable(opts?: {
+        detPath?: string;
+        recPath?: string;
+    }): Promise<boolean>;
+    isInitialized(): boolean;
+    initialize(): Promise<void>;
+    private _initialize;
+    extractText(imageBuffer: Buffer): Promise<OCRResult>;
+    private toCHWFloat32;
+    /**
+     * DBNet contouring: scan the probability map, group above-threshold pixels
+     * into connected components, return axis-aligned bboxes in original image
+     * coordinates.
+     *
+     * This is the same algorithm as the previous PP-OCRv5 path — it's a
+     * standard DBNet post-process and works for both detection backbones.
+     */
+    private probMapToBoxes;
+    /**
+     * Recognition step: crop the bbox, resize to 32xN, run through the CRNN
+     * recognizer, CTC-decode the output.
+     */
+    private recognizeCrop;
+    /** CTC greedy decoding. Blank index = 0. */
+    private ctcDecode;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=ocr-service-doctr.d.ts.map

package/dist/ocr-service-doctr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocr-service-doctr.d.ts","sourceRoot":"","sources":["../src/ocr-service-doctr.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAe,SAAS,EAAE,MAAM,SAAS,CAAC;AAEtD,MAAM,WAAW,cAAc;IAC7B,mCAAmC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,+DAA+D;IAC/D,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,IAAI,OAAO,CAKjD;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAGH;IACjB,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,OAAO,CAAgB;gBAEnB,MAAM,GAAE,cAAmB;IAUvC;;;;OAIG;WACU,WAAW,CAAC,IAAI,CAAC,EAAE;QAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,OAAO,CAAC;IAKpB,aAAa,IAAI,OAAO;IAIlB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAOnB,WAAW;IA0BnB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAmD1D,OAAO,CAAC,YAAY;IAWpB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAoEtB;;;OAGG;YACW,aAAa;IAwC3B,4CAA4C;IAC5C,OAAO,CAAC,SAAS;IAwBX,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAO/B"}

package/dist/ocr-service-linux-tesseract.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Native Linux OCR-with-coords via the classic `tesseract` CLI (issue #9105 /
+ * M4).
+ *
+ * Zero LLM tokens, no in-repo model download, no ONNX — `tesseract` is a
+ * standalone C++ engine packaged by every Linux distro (`apt install
+ * tesseract-ocr`). We shell to it with `tsv` output, which emits one row per
+ * recognized element with a `level` column (1=page, 2=block, 3=para, 4=line,
+ * 5=word) plus per-element `left/top/width/height` boxes and a per-word `conf`.
+ * Output maps onto `OcrWithCoordsResult`, so this plugs straight into the
+ * `OcrWithCoordsService` registry seam and (via the M1 bridge) into
+ * plugin-computeruse's `CoordOcrProvider`.
+ *
+ * We read the word rows (`level == 5`), group them by their parent
+ * `(block, paragraph, line)` triple into one `OcrWithCoordsBlock` per text
+ * line (block bbox = union of its word rects), compute the semantic position
+ * against the source-tile thirds, and shift every bbox into display-absolute
+ * coordinates via `sourceX/sourceY` — the same shape as the Windows provider.
+ *
+ * Availability is feature-detected on the `tesseract` binary and cached for the
+ * process lifetime. When the binary is absent the provider reports unavailable
+ * and `describe()` returns empty blocks; it never throws so the boot chain
+ * falls through to the docTR ggml backend cleanly.
+ */
+import { type OcrWithCoordsInput, type OcrWithCoordsResult, type OcrWithCoordsService } from "./ocr-with-coords.js";
+/** A single `level == 5` (word) row parsed from the tesseract TSV. */
+interface TesseractWordRow {
+    readonly blockNum: number;
+    readonly parNum: number;
+    readonly lineNum: number;
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+    /** Tesseract confidence in [0, 100]; `-1` for non-word rows (filtered out). */
+    readonly conf: number;
+    readonly text: string;
+}
+/**
+ * Parse the raw tesseract TSV into word rows. Pure — exported for tests so the
+ * column mapping has a single source of truth and CI never needs a real
+ * tesseract binary. Skips the header row, non-word levels, blank text, and any
+ * row with too few columns.
+ */
+export declare function parseTesseractTsv(tsv: string): TesseractWordRow[];
+/**
+ * Pure mapper: raw tesseract TSV → `OcrWithCoordsResult`. Exported for
+ * cross-platform unit tests that inject a fixed TSV string (no real binary).
+ * Word rows are grouped by their `(block, paragraph, line)` triple — one
+ * `OcrWithCoordsBlock` per recognized text line — in first-seen order.
+ */
+export declare function mapTesseractTsvToResult(tsv: string, tileWidth: number, tileHeight: number, sourceX: number, sourceY: number): OcrWithCoordsResult;
+/** Resolved tesseract invocation: the binary path + the env it must run under. */
+export interface TesseractResolution {
+    bin: string;
+    /** Extra env merged onto `process.env` for child runs (LD_LIBRARY_PATH,
+     * TESSDATA_PREFIX) — non-empty only when a bundled tesseract is used. */
+    env: Record<string, string>;
+}
+/**
+ * Resolve a tesseract to run, so the OCR path "just ships and works" without a
+ * system `apt install tesseract-ocr` (#9105). Order:
+ *
+ *   1. `ELIZA_TESSERACT_BIN` — an explicit binary path (CI / power users).
+ *   2. A vendored bundle the app ships, found at
+ *      `${ELIZA_VISION_VENDOR_DIR}/tesseract/{bin/tesseract, lib/*.so*,
+ *      tessdata/<lang>.traineddata}`. The desktop build stages a portable
+ *      tesseract there (binary + libtesseract/libleptonica + eng.traineddata);
+ *      we then run it with that `lib/` on `LD_LIBRARY_PATH` and that `tessdata/`
+ *      as `TESSDATA_PREFIX`, so no host install is needed.
+ *   3. `tesseract` on `PATH` (a system install, the legacy path).
+ *
+ * Pure-ish + exported for tests (it only reads env + the filesystem); cached for
+ * the process lifetime.
+ */
+export declare function resolveTesseract(): TesseractResolution;
+/** Test-only: reset the cached availability + resolution probes between cases. */
+export declare function _resetTesseractAvailabilityForTests(): void;
+export declare class LinuxTesseractOcrService implements OcrWithCoordsService {
+    readonly name = "linux-tesseract";
+    static isAvailable(): boolean;
+    describe(input: OcrWithCoordsInput): Promise<OcrWithCoordsResult>;
+}
+export {};
+//# sourceMappingURL=ocr-service-linux-tesseract.d.ts.map

package/dist/ocr-service-linux-tesseract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocr-service-linux-tesseract.d.ts","sourceRoot":"","sources":["../src/ocr-service-linux-tesseract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAOH,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EAE1B,MAAM,sBAAsB,CAAC;AAG9B,sEAAsE;AACtE,UAAU,gBAAgB;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAkBD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,EAAE,CA2BjE;AA4ED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,mBAAmB,CA4BrB;AAED,kFAAkF;AAClF,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ;6EACyE;IACzE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,IAAI,mBAAmB,CA2BtD;AA2CD,kFAAkF;AAClF,wBAAgB,mCAAmC,IAAI,IAAI,CAG1D;AA8CD,qBAAa,wBAAyB,YAAW,oBAAoB;IACnE,QAAQ,CAAC,IAAI,qBAAqB;IAElC,MAAM,CAAC,WAAW,IAAI,OAAO;IAIvB,QAAQ,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAwBxE"}

package/dist/ocr-service-paddleocr.d.ts

@@ -0,0 +1,59 @@
+/**
+ * PaddleOCR / Paddle-Lite OCR-with-coords backend (issue #9581).
+ *
+ * The alternate coord-OCR provider beyond the shipped Tesseract + RapidOCR
+ * adapters. PaddleOCR is a standalone, cross-platform OCR engine (pip install
+ * paddleocr) with strong multilingual detection. We drive it through a small
+ * self-contained Python wrapper so the JS side parses a stable JSON shape we
+ * control — not PaddleOCR's version-sensitive raw `ocr.ocr()` return — and so
+ * the wrapper absorbs the numpy/tuple conversion and the 2.x detection layout
+ * (`[page][det] = [box4pts, (text, conf)]`).
+ *
+ * The wrapper emits one object per recognized text line:
+ *   `[{ "box": [[x,y],[x,y],[x,y],[x,y]], "text": "...", "conf": 0.0..1.0 }, …]`
+ * PaddleOCR returns line-level (not word-level) detections, so each entry maps
+ * to one `OcrWithCoordsBlock` whose single word is the line; the block bbox is
+ * the axis-aligned hull of the (possibly rotated) detection quad, shifted into
+ * display-absolute coordinates via `sourceX/sourceY` — the same output shape as
+ * the Tesseract and Windows providers, so it plugs straight into the
+ * `OcrWithCoordsService` registry seam (and via the bridge into
+ * plugin-computeruse's `CoordOcrProvider`).
+ *
+ * Opt-in: this provider is only selected when `ELIZA_VISION_OCR_BACKEND` is
+ * `paddleocr`, so it never displaces a verified default provider. When PaddleOCR
+ * (or python3) is absent it reports unavailable and `describe()` returns empty
+ * blocks; it never throws, so the boot chain falls through cleanly.
+ *
+ * NOTE (#9581): the JSON parser below is unit-tested without the engine (CI
+ * needs no PaddleOCR install). End-to-end behaviour against a real PaddleOCR
+ * install still needs on-target verification before this becomes a default.
+ */
+import { type OcrWithCoordsInput, type OcrWithCoordsResult, type OcrWithCoordsService } from "./ocr-with-coords.js";
+/** One detection from the wrapper's stable JSON: a quad + line text + score. */
+interface PaddleOcrDetection {
+    readonly box: ReadonlyArray<readonly [number, number]>;
+    readonly text: string;
+    readonly conf: number;
+}
+/**
+ * Parse the wrapper's stable JSON into typed detections. Pure — exported for
+ * tests so the contract with `PADDLE_PY` has a single source of truth and CI
+ * never needs a real PaddleOCR install. Drops entries without a 4-point box,
+ * blank text, or a non-finite score.
+ */
+export declare function parsePaddleOcrJson(raw: string): PaddleOcrDetection[];
+/**
+ * Pure mapper: wrapper JSON → `OcrWithCoordsResult`. Exported for unit tests
+ * that inject a fixed JSON string (no real engine). One block per detected line
+ * (PaddleOCR is line-level), in first-seen order; the single word is the line.
+ */
+export declare function mapPaddleOcrJsonToResult(raw: string, tileWidth: number, tileHeight: number, sourceX: number, sourceY: number): OcrWithCoordsResult;
+/** Test-only: reset the cached availability probe between cases. */
+export declare function _resetPaddleOcrAvailabilityForTests(): void;
+export declare class PaddleOcrService implements OcrWithCoordsService {
+    readonly name = "paddleocr";
+    static isAvailable(): boolean;
+    describe(input: OcrWithCoordsInput): Promise<OcrWithCoordsResult>;
+}
+export {};
+//# sourceMappingURL=ocr-service-paddleocr.d.ts.map

package/dist/ocr-service-paddleocr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocr-service-paddleocr.d.ts","sourceRoot":"","sources":["../src/ocr-service-paddleocr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAOH,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EAC1B,MAAM,sBAAsB,CAAC;AAG9B,gFAAgF;AAChF,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAwDD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAuCpE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,mBAAmB,CA0BrB;AAgDD,oEAAoE;AACpE,wBAAgB,mCAAmC,IAAI,IAAI,CAE1D;AAmBD,qBAAa,gBAAiB,YAAW,oBAAoB;IAC3D,QAAQ,CAAC,IAAI,eAAe;IAE5B,MAAM,CAAC,WAAW,IAAI,OAAO;IAIvB,QAAQ,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAwBxE"}

package/dist/ocr-service-windows.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Native Windows OCR-with-coords via the built-in WinRT `Windows.Media.Ocr`
+ * engine (issue #9105 / M4a).
+ *
+ * Zero LLM tokens, no model download, NPU-accelerated where available. The
+ * WinRT projection is only reachable from Windows PowerShell 5.1 (`powershell`),
+ * not PowerShell 7 (`pwsh`), so we shell to `powershell` with an embedded
+ * script. Output is `OcrWithCoordsResult`, so this plugs straight into the
+ * `OcrWithCoordsService` registry seam and (via the M1 bridge) into
+ * plugin-computeruse's `CoordOcrProvider`.
+ *
+ * The engine returns text LINES, each with WORDS that carry bounding rects.
+ * We map each line to one `OcrWithCoordsBlock` (block bbox = union of its word
+ * rects), compute the semantic position against the source tile thirds, and
+ * shift every bbox into display-absolute coordinates via `sourceX/sourceY`.
+ */
+import { type OcrWithCoordsInput, type OcrWithCoordsResult, type OcrWithCoordsService } from "./ocr-with-coords.js";
+/** Shape emitted by the embedded PowerShell script (parsed from stdout JSON). */
+interface WinOcrRaw {
+    width: number;
+    height: number;
+    lines: Array<{
+        text: string;
+        words: Array<{
+            text: string;
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }>;
+    }>;
+}
+/** Pure mapper (exported for cross-platform unit tests). */
+export declare function mapWinOcrToResult(raw: WinOcrRaw, sourceX: number, sourceY: number): OcrWithCoordsResult;
+export declare class WindowsMediaOcrService implements OcrWithCoordsService {
+    readonly name = "windows-media-ocr";
+    static isAvailable(): boolean;
+    describe(input: OcrWithCoordsInput): Promise<OcrWithCoordsResult>;
+}
+export {};
+//# sourceMappingURL=ocr-service-windows.d.ts.map

package/dist/ocr-service-windows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocr-service-windows.d.ts","sourceRoot":"","sources":["../src/ocr-service-windows.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAQH,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EAE1B,MAAM,sBAAsB,CAAC;AAG9B,iFAAiF;AACjF,UAAU,SAAS;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,KAAK,CAAC;YACX,IAAI,EAAE,MAAM,CAAC;YACb,CAAC,EAAE,MAAM,CAAC;YACV,CAAC,EAAE,MAAM,CAAC;YACV,KAAK,EAAE,MAAM,CAAC;YACd,MAAM,EAAE,MAAM,CAAC;SAChB,CAAC,CAAC;KACJ,CAAC,CAAC;CACJ;AA+JD,4DAA4D;AAC5D,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,SAAS,EACd,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,mBAAmB,CAOrB;AAED,qBAAa,sBAAuB,YAAW,oBAAoB;IACjE,QAAQ,CAAC,IAAI,uBAAuB;IAEpC,MAAM,CAAC,WAAW,IAAI,OAAO;IAIvB,QAAQ,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAyCxE"}