@camstack/types 0.1.14 → 0.1.16

package/dist/capabilities/pipeline-orchestrator.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-orchestrator.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/pipeline-orchestrator.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAWlG,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAS9B,CAAA;AAEF,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO1B,CAAA;AAuCF,QAAA,MAAM,6BAA6B;;;;iBAIjC,CAAA;AAaF;;;;;;;;;GASG;AACH,QAAA,MAAM,wBAAwB;;;;;;;;;;;;iBAU5B,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,uBAAuB;;;;;;;;;;iBAQ3B,CAAA;AAEF;;;GAGG;AACH,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;iBAM1B,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;iBAUvB,CAAA;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,wBAAwB,uCAAmC,CAAA;AAuBjE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,8BAA8B;;;;;;QAOvC;;;WAGG;;;;;;;QAMH;;;;;;;;;WASG;;;;;;QAMH;;;;;WAKG;;;;QAIH,mDAAmD;;;;;;;;;;;;;;QAEnD,0DAA0D;;;;;;;;;;;;;;;;QAE1D,2EAA2E;;;;;;;;;;;;;;;;;;;QAE3E,mEAAmE;;;;;;;;;;QAEnE;;;;;;;;WAQG;;;;;;;;;;;;;;;;;;;;QAIH,yGAAyG;;;;QAEzG,+FAA+F;;;;;;;;QAQ/F,iDAAiD;;;;;QAMjD,qDAAqD;;;;QAMrD,4CAA4C;;;;;;;;;;;;QAI5C,gEAAgE;;;;;;;QAMhE,sEAAsE;;;;;;QAMtE,oFAAoF;;;;;;;;QASpF,kFAAkF;;;;;QAKlF,4DAA4D;;;;;;;QAW5D;;;;;;;;;;;WAWG;;;;;;;;;;;;;;;QAgCH,2DAA2D;;;;;;;;;;QAK3D,+DAA+D;;;;;;;;;;;QAQ/D,kMAAkM;;;;;;;;;;;QASlM;;;;;;;;;WASG;;;;;;;QAcH,2FAA2F;;;;;;;;;;;;;;;;;;;QAK3F,4HAA4H;;;;;;;;QAU5H,oFAAoF;;;;;;;;QAQpF;;;WAGG;;;;;;;;;;;;;QAWH,4GAA4G;;;;;;;;;;;;;;QAU5G,+JAA+J;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAO/J,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAElD,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAUnE,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAWpE,8EAA8E;;;;;;;CAOzC,CAAA;AAEzC,MAAM,MAAM,6BAA6B,GAAG,aAAa,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAEhG,OAAO,EACL,wBAAwB,EACxB,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,EACnB,wBAAwB,EACxB,0BAA0B,EAC1B,6BAA6B,EAC7B,sBAAsB,IAAI,kCAAkC,GAC7D,CAAA"}

package/dist/capabilities/pipeline-runner.cap.d.ts

@@ -0,0 +1,393 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import type { ConfigField } from '../interfaces/config-ui.js';
+/**
+ * Source enum for motion signals fed to the runner. Extensible — add
+ * new variants here when new motion-trigger paths are wired in
+ * (`wasm-cross-camera`, `event-bus-relay`, etc.). The runner uses
+ * the variant for diagnostics + to route the cap-state event payload
+ * (analyzer attaches detected `regions[]`; onboard does not — the
+ * camera typically only reports a binary signal plus an optional
+ * channel/AI class which lives in dedicated event channels).
+ */
+export declare const MotionSourceEnum: z.ZodEnum<{
+    onboard: "onboard";
+    analyzer: "analyzer";
+}>;
+export type MotionSource = z.infer<typeof MotionSourceEnum>;
+/**
+ * List of motion sources active on a camera. Empty array is valid:
+ * "no source" — happens for battery cams without firmware motion when
+ * the operator hasn't opted into the SW analyzer (would hold the
+ * substream open continuously and defeat the sleep cycle). The runner
+ * accepts the empty list as "no motion-driven phase transitions" and
+ * relies on the operator-set `detectionMode` to drive activation
+ * (`'always-on'`) — `'on-motion'` with no source effectively pins the
+ * phase to `'watching'`, which is the desired battery-cam-without-
+ * firmware behaviour.
+ *
+ * Single source of truth for the array shape — every consumer
+ * (orchestrator, runner, settings UI, dispatch) imports from here.
+ */
+export declare const MotionSourcesSchema: z.ZodArray<z.ZodEnum<{
+    onboard: "onboard";
+    analyzer: "analyzer";
+}>>;
+export type MotionSources = z.infer<typeof MotionSourcesSchema>;
+/**
+ * Input shape for `pipeline-runner.reportMotion` cap method. Exported
+ * so cap-side consumers (the orchestrator forward, the runner addon's
+ * cap implementation, tests) can reuse the type instead of redeclaring
+ * the field set.
+ */
+export declare const ReportMotionInputSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    detected: z.ZodBoolean;
+    source: z.ZodDefault<z.ZodEnum<{
+        onboard: "onboard";
+        analyzer: "analyzer";
+    }>>;
+    regions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        bbox: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            w: z.ZodNumber;
+            h: z.ZodNumber;
+        }, z.core.$strip>;
+        pixelCount: z.ZodNumber;
+        intensity: z.ZodNumber;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+export type ReportMotionInput = z.infer<typeof ReportMotionInputSchema>;
+/**
+ * Camera assignment payload sent by `addon-pipeline-orchestrator` to a
+ * specific runner instance via `attachCamera`. Carries everything the
+ * runner needs to subscribe to the local broker and execute inference.
+ *
+ * Stateless-pipeline model: the full pipeline content (`engine`, `steps`,
+ * optional `audio`) travels with the attach payload. The runner keeps it
+ * in RAM for the lifetime of the attach — on rebalance, edit, or
+ * restart the orchestrator re-sends the latest snapshot.
+ *
+ * `engine`/`steps`/`audio` are optional during the additive migration
+ * window; once orchestrator + UI are migrated they become required.
+ */
+declare const RunnerCameraConfigSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    detectionMode: z.ZodDefault<z.ZodEnum<{
+        disabled: "disabled";
+        "always-on": "always-on";
+        "on-motion": "on-motion";
+    }>>;
+    audioMode: z.ZodDefault<z.ZodEnum<{
+        disabled: "disabled";
+        "always-on": "always-on";
+        "on-motion": "on-motion";
+    }>>;
+    motionCooldownMs: z.ZodDefault<z.ZodNumber>;
+    motionFps: z.ZodDefault<z.ZodNumber>;
+    detectionFps: z.ZodDefault<z.ZodNumber>;
+    motionStreamId: z.ZodString;
+    detectionStreamId: z.ZodString;
+    motionSources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        onboard: "onboard";
+        analyzer: "analyzer";
+    }>>>;
+    pipelineEnabled: z.ZodDefault<z.ZodBoolean>;
+    engine: z.ZodOptional<z.ZodObject<{
+        runtime: z.ZodEnum<{
+            node: "node";
+            python: "python";
+        }>;
+        backend: z.ZodString;
+        format: z.ZodEnum<{
+            onnx: "onnx";
+            coreml: "coreml";
+            openvino: "openvino";
+            tflite: "tflite";
+            pt: "pt";
+        }>;
+        device: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    steps: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown>>>>>;
+    audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        engine: z.ZodObject<{
+            runtime: z.ZodEnum<{
+                node: "node";
+                python: "python";
+            }>;
+            backend: z.ZodString;
+            format: z.ZodEnum<{
+                onnx: "onnx";
+                coreml: "coreml";
+                openvino: "openvino";
+                tflite: "tflite";
+                pt: "pt";
+            }>;
+            device: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        modelId: z.ZodString;
+        enabled: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    zones: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodDefault<z.ZodEnum<{
+            polygon: "polygon";
+            tripwire: "tripwire";
+        }>>;
+        polygon: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>>;
+        color: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+/**
+ * Per-device settings UI fields the runner cap owns. Co-located with
+ * the Zod data schema so a single change to defaults / ranges /
+ * options propagates to both the wire contract AND the rendered UI.
+ *
+ * Consumers spread this into their own ConfigUISchema sections
+ * (e.g. orchestrator's deviceSettingsSchema) instead of redeclaring
+ * the fields. The ranges are read from the `*Field` constants above
+ * so values stay in sync with `RunnerCameraConfigSchema`.
+ *
+ * Fields NOT included here are intentional — they're either internal
+ * wire (motionStreamId, detectionStreamId) or live in a different
+ * config surface (priority, motionStreamProfile/detectionStreamProfile
+ * — the orchestrator transforms them into stream IDs before dispatch).
+ */
+export declare const RunnerCameraDeviceUIFields: readonly ConfigField[];
+/**
+ * Runtime load summary returned by `getLocalLoad`. Used by the orchestrator's
+ * load-balancing levels (L2 capacity-based, L3 hardware-aware) to decide
+ * which agent should receive a new camera assignment.
+ */
+declare const RunnerLocalLoadSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    attachedCameras: z.ZodNumber;
+    activeCameras: z.ZodNumber;
+    avgInferenceFps: z.ZodNumber;
+    avgInferenceTimeMs: z.ZodNumber;
+    queueDepthTotal: z.ZodNumber;
+    hardware: z.ZodObject<{
+        hasGpu: z.ZodBoolean;
+        inferenceBackend: z.ZodOptional<z.ZodString>;
+        cpuCores: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Aggregate runtime metrics for the runner's whole local pool. Mirrors the
+ * legacy `OrchestratorMetricsSchema` shape so existing dashboards keep
+ * working unchanged when they switch to reading from the runner cap.
+ */
+declare const RunnerLocalMetricsSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    activeCameras: z.ZodNumber;
+    throttledCameras: z.ZodNumber;
+    avgInferenceTimeMs: z.ZodNumber;
+    queueDepth: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Pipeline Runner capability — runtime detection workhorse.
+ *
+ * One instance per node. Receives camera assignments from
+ * `addon-pipeline-orchestrator`, subscribes to the local stream-broker for
+ * decoded frames, drains motion + detection queues, calls the local
+ * `motion-detection` and `pipeline-executor` capabilities, and emits typed
+ * `pipeline.inference-result` and `detection.motion-analysis` events on
+ * the bus.
+ *
+ * Distinct from `pipeline-orchestrator` (the hub-side load balancer) — the
+ * runner has zero knowledge of other agents, no global state, and never
+ * makes assignment decisions itself.
+ */
+export declare const pipelineRunnerCapability: {
+    readonly name: "pipeline-runner";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        /** Attach a camera to this runner. Subscribes to local broker. */
+        readonly attachCamera: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            detectionMode: z.ZodDefault<z.ZodEnum<{
+                disabled: "disabled";
+                "always-on": "always-on";
+                "on-motion": "on-motion";
+            }>>;
+            audioMode: z.ZodDefault<z.ZodEnum<{
+                disabled: "disabled";
+                "always-on": "always-on";
+                "on-motion": "on-motion";
+            }>>;
+            motionCooldownMs: z.ZodDefault<z.ZodNumber>;
+            motionFps: z.ZodDefault<z.ZodNumber>;
+            detectionFps: z.ZodDefault<z.ZodNumber>;
+            motionStreamId: z.ZodString;
+            detectionStreamId: z.ZodString;
+            motionSources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                onboard: "onboard";
+                analyzer: "analyzer";
+            }>>>;
+            pipelineEnabled: z.ZodDefault<z.ZodBoolean>;
+            engine: z.ZodOptional<z.ZodObject<{
+                runtime: z.ZodEnum<{
+                    node: "node";
+                    python: "python";
+                }>;
+                backend: z.ZodString;
+                format: z.ZodEnum<{
+                    onnx: "onnx";
+                    coreml: "coreml";
+                    openvino: "openvino";
+                    tflite: "tflite";
+                    pt: "pt";
+                }>;
+                device: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            steps: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown>>>>>;
+            audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                engine: z.ZodObject<{
+                    runtime: z.ZodEnum<{
+                        node: "node";
+                        python: "python";
+                    }>;
+                    backend: z.ZodString;
+                    format: z.ZodEnum<{
+                        onnx: "onnx";
+                        coreml: "coreml";
+                        openvino: "openvino";
+                        tflite: "tflite";
+                        pt: "pt";
+                    }>;
+                    device: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                modelId: z.ZodString;
+                enabled: z.ZodBoolean;
+            }, z.core.$strip>>>;
+            zones: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                kind: z.ZodDefault<z.ZodEnum<{
+                    polygon: "polygon";
+                    tripwire: "tripwire";
+                }>>;
+                polygon: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                }, z.core.$strip>>>;
+                color: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /** Detach a camera. Unsubscribes from local broker, clears queues. */
+        readonly detachCamera: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Report an external motion event for a camera. Drives the runner's
+         * phase machine: every `detected: true` clears + rearms the
+         * cooldown timer (`motionCooldownMs`); when the timer expires the
+         * camera returns to `watching`. `detected: false` is a no-op —
+         * onboard sources never send an explicit clear, the timer is the
+         * single closure path.
+         *
+         * `source` discriminates which motion path triggered the event so
+         * the runner can attach the right metadata to the cap-state event
+         * (analyzer carries `regions[]`, onboard does not). `regions` is
+         * populated only for `source: 'analyzer'` — the analyzer's
+         * frame-diff result. Always-on cameras silently ignore
+         * reportMotion calls.
+         */
+        readonly reportMotion: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            detected: z.ZodBoolean;
+            source: z.ZodDefault<z.ZodEnum<{
+                onboard: "onboard";
+                analyzer: "analyzer";
+            }>>;
+            regions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                bbox: z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    w: z.ZodNumber;
+                    h: z.ZodNumber;
+                }, z.core.$strip>;
+                pixelCount: z.ZodNumber;
+                intensity: z.ZodNumber;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /** Return load summary used by the orchestrator's load balancer. */
+        readonly getLocalLoad: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            nodeId: z.ZodString;
+            attachedCameras: z.ZodNumber;
+            activeCameras: z.ZodNumber;
+            avgInferenceFps: z.ZodNumber;
+            avgInferenceTimeMs: z.ZodNumber;
+            queueDepthTotal: z.ZodNumber;
+            hardware: z.ZodObject<{
+                hasGpu: z.ZodBoolean;
+                inferenceBackend: z.ZodOptional<z.ZodString>;
+                cpuCores: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Return aggregate runtime metrics for this runner instance. */
+        readonly getLocalMetrics: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            nodeId: z.ZodString;
+            activeCameras: z.ZodNumber;
+            throttledCameras: z.ZodNumber;
+            avgInferenceTimeMs: z.ZodNumber;
+            queueDepth: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Per-camera metrics for cameras attached to this runner. */
+        readonly getCameraMetrics: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            detectionMode: z.ZodEnum<{
+                disabled: "disabled";
+                "always-on": "always-on";
+                "on-motion": "on-motion";
+            }>;
+            configuredFps: z.ZodNumber;
+            actualFps: z.ZodNumber;
+            queueDepth: z.ZodNumber;
+            avgInferenceTimeMs: z.ZodNumber;
+            droppedFrames: z.ZodNumber;
+            phase: z.ZodEnum<{
+                idle: "idle";
+                watching: "watching";
+                active: "active";
+            }>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** All per-camera metrics in one round-trip. */
+        readonly getAllCameraMetrics: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            detectionMode: z.ZodEnum<{
+                disabled: "disabled";
+                "always-on": "always-on";
+                "on-motion": "on-motion";
+            }>;
+            configuredFps: z.ZodNumber;
+            actualFps: z.ZodNumber;
+            queueDepth: z.ZodNumber;
+            avgInferenceTimeMs: z.ZodNumber;
+            droppedFrames: z.ZodNumber;
+            phase: z.ZodEnum<{
+                idle: "idle";
+                watching: "watching";
+                active: "active";
+            }>;
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** List the deviceIds currently attached to this runner. */
+        readonly getLocalCameras: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodNumber>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IPipelineRunnerProvider = InferProvider<typeof pipelineRunnerCapability>;
+export { RunnerCameraConfigSchema, RunnerLocalLoadSchema, RunnerLocalMetricsSchema };
+//# sourceMappingURL=pipeline-runner.cap.d.ts.map

package/dist/capabilities/pipeline-runner.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-runner.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/pipeline-runner.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAKlG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAY7D;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;;;EAAkC,CAAA;AAC/D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE3D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB;;;GAA4B,CAAA;AAC5D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;iBAKlC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6D5B,CAAA;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,WAAW,EA2DnD,CAAA;AAEV;;;;GAIG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;iBAmBzB,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,wBAAwB;;;;;;iBAM5B,CAAA;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB;;;;;QAMjC,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAElE,sEAAsE;;;;;;QAEtE;;;;;;;;;;;;;;WAcG;;;;;;;;;;;;;;;;;;;;;QAQH,oEAAoE;;;;;;;;;;;;;;QAEpE,iEAAiE;;;;;;;;QAEjE,8DAA8D;;;;;;;;;;;;;;;;;;;;QAE9D,gDAAgD;;;;;;;;;;;;;;;;;;;QAEhD,4DAA4D;;;CASvB,CAAA;AAEzC,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEpF,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,CAAA"}

package/dist/capabilities/platform-probe.cap.d.ts

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+export declare const platformProbeCapability: {
+    readonly name: "platform-probe";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        /** Return cached hardware + scored backends for this node. */
+        readonly getCapabilities: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            hardware: z.ZodObject<{
+                platform: z.ZodEnum<{
+                    darwin: "darwin";
+                    linux: "linux";
+                    win32: "win32";
+                }>;
+                arch: z.ZodEnum<{
+                    arm64: "arm64";
+                    x64: "x64";
+                }>;
+                cpuModel: z.ZodString;
+                cpuCores: z.ZodNumber;
+                totalRAM_MB: z.ZodNumber;
+                availableRAM_MB: z.ZodNumber;
+                gpu: z.ZodNullable<z.ZodObject<{
+                    type: z.ZodEnum<{
+                        nvidia: "nvidia";
+                        amd: "amd";
+                        intel: "intel";
+                        apple: "apple";
+                    }>;
+                    name: z.ZodString;
+                    memoryMB: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                npu: z.ZodNullable<z.ZodObject<{
+                    type: z.ZodEnum<{
+                        "apple-ane": "apple-ane";
+                        "intel-npu": "intel-npu";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            scores: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                runtime: z.ZodEnum<{
+                    node: "node";
+                    python: "python";
+                }>;
+                backend: z.ZodString;
+                format: z.ZodEnum<{
+                    onnx: "onnx";
+                    coreml: "coreml";
+                    openvino: "openvino";
+                }>;
+                score: z.ZodNumber;
+                reason: z.ZodString;
+                available: z.ZodBoolean;
+            }, z.core.$strip>>>;
+            bestScore: z.ZodObject<{
+                runtime: z.ZodEnum<{
+                    node: "node";
+                    python: "python";
+                }>;
+                backend: z.ZodString;
+                format: z.ZodEnum<{
+                    onnx: "onnx";
+                    coreml: "coreml";
+                    openvino: "openvino";
+                }>;
+                score: z.ZodNumber;
+                reason: z.ZodString;
+                available: z.ZodBoolean;
+            }, z.core.$strip>;
+            pythonPath: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Convenience getter — hardware only. */
+        readonly getHardware: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            platform: z.ZodEnum<{
+                darwin: "darwin";
+                linux: "linux";
+                win32: "win32";
+            }>;
+            arch: z.ZodEnum<{
+                arm64: "arm64";
+                x64: "x64";
+            }>;
+            cpuModel: z.ZodString;
+            cpuCores: z.ZodNumber;
+            totalRAM_MB: z.ZodNumber;
+            availableRAM_MB: z.ZodNumber;
+            gpu: z.ZodNullable<z.ZodObject<{
+                type: z.ZodEnum<{
+                    nvidia: "nvidia";
+                    amd: "amd";
+                    intel: "intel";
+                    apple: "apple";
+                }>;
+                name: z.ZodString;
+                memoryMB: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            npu: z.ZodNullable<z.ZodObject<{
+                type: z.ZodEnum<{
+                    "apple-ane": "apple-ane";
+                    "intel-npu": "intel-npu";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Resolve the best (model, runtime, backend, format) for a given list
+         * of requirements, using this node's scored backends as the candidate
+         * pool. Always returns a config — falls back to CPU when no preferred
+         * backend matches.
+         */
+        readonly resolveInferenceConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            requirements: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                modelId: z.ZodString;
+                name: z.ZodString;
+                minRAM_MB: z.ZodNumber;
+                accuracyScore: z.ZodNumber;
+                formats: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            modelId: z.ZodString;
+            runtime: z.ZodEnum<{
+                node: "node";
+                python: "python";
+            }>;
+            backend: z.ZodString;
+            format: z.ZodEnum<{
+                onnx: "onnx";
+                coreml: "coreml";
+                openvino: "openvino";
+                tflite: "tflite";
+                pt: "pt";
+            }>;
+            reason: z.ZodString;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Resolve the ordered HW acceleration backend list for this node.
+         * Pass `prefer` to hint a specific backend; pass `null` or omit
+         * for auto-detection. Replaces the legacy `$hwaccel.resolve`
+         * Moleculer action — cap routing handles per-node dispatch via
+         * `nodeId`.
+         */
+        readonly resolveHwAccel: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            prefer: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                coreml: "coreml";
+                openvino: "openvino";
+                tensorrt: "tensorrt";
+                none: "none";
+                videotoolbox: "videotoolbox";
+                cuda: "cuda";
+                nvdec: "nvdec";
+                vaapi: "vaapi";
+                qsv: "qsv";
+                d3d11va: "d3d11va";
+                dxva2: "dxva2";
+                amf: "amf";
+                vdpau: "vdpau";
+                drm: "drm";
+                directml: "directml";
+                webgpu: "webgpu";
+            }>>>;
+            nodeId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            preferred: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IPlatformProbeProvider = InferProvider<typeof platformProbeCapability>;
+//# sourceMappingURL=platform-probe.cap.d.ts.map

package/dist/capabilities/platform-probe.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-probe.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/platform-probe.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAuFlG,eAAO,MAAM,uBAAuB;;;;;QAKhC,8DAA8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAK9D,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAK1C;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;QAOH;;;;;;WAMG;;;;;;;;;;;;;;;;;;;;;;;;;CASkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}