@camstack/types 0.1.31 → 0.1.32

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

@@ -1,11 +1,118 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
+declare const HardwareEncoderIdSchema: z.ZodEnum<{
+    h264_videotoolbox: "h264_videotoolbox";
+    hevc_videotoolbox: "hevc_videotoolbox";
+    h264_vaapi: "h264_vaapi";
+    hevc_vaapi: "hevc_vaapi";
+    h264_nvenc: "h264_nvenc";
+    hevc_nvenc: "hevc_nvenc";
+    h264_qsv: "h264_qsv";
+    hevc_qsv: "hevc_qsv";
+    h264_amf: "h264_amf";
+    hevc_amf: "hevc_amf";
+    libx264: "libx264";
+    libx265: "libx265";
+}>;
+export type HardwareEncoderId = z.infer<typeof HardwareEncoderIdSchema>;
+declare const HardwareEncoderProbeSchema: z.ZodObject<{
+    encoder: z.ZodEnum<{
+        h264_videotoolbox: "h264_videotoolbox";
+        hevc_videotoolbox: "hevc_videotoolbox";
+        h264_vaapi: "h264_vaapi";
+        hevc_vaapi: "hevc_vaapi";
+        h264_nvenc: "h264_nvenc";
+        hevc_nvenc: "hevc_nvenc";
+        h264_qsv: "h264_qsv";
+        hevc_qsv: "hevc_qsv";
+        h264_amf: "h264_amf";
+        hevc_amf: "hevc_amf";
+        libx264: "libx264";
+        libx265: "libx265";
+    }>;
+    codec: z.ZodEnum<{
+        H264: "H264";
+        H265: "H265";
+    }>;
+    family: z.ZodEnum<{
+        videotoolbox: "videotoolbox";
+        vaapi: "vaapi";
+        qsv: "qsv";
+        amf: "amf";
+        nvenc: "nvenc";
+        software: "software";
+    }>;
+    available: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HardwareEncoderProbe = z.infer<typeof HardwareEncoderProbeSchema>;
+declare const HardwareEncodersSchema: z.ZodObject<{
+    encoders: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        encoder: z.ZodEnum<{
+            h264_videotoolbox: "h264_videotoolbox";
+            hevc_videotoolbox: "hevc_videotoolbox";
+            h264_vaapi: "h264_vaapi";
+            hevc_vaapi: "hevc_vaapi";
+            h264_nvenc: "h264_nvenc";
+            hevc_nvenc: "hevc_nvenc";
+            h264_qsv: "h264_qsv";
+            hevc_qsv: "hevc_qsv";
+            h264_amf: "h264_amf";
+            hevc_amf: "hevc_amf";
+            libx264: "libx264";
+            libx265: "libx265";
+        }>;
+        codec: z.ZodEnum<{
+            H264: "H264";
+            H265: "H265";
+        }>;
+        family: z.ZodEnum<{
+            videotoolbox: "videotoolbox";
+            vaapi: "vaapi";
+            qsv: "qsv";
+            amf: "amf";
+            nvenc: "nvenc";
+            software: "software";
+        }>;
+        available: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    defaultH264: z.ZodEnum<{
+        h264_videotoolbox: "h264_videotoolbox";
+        hevc_videotoolbox: "hevc_videotoolbox";
+        h264_vaapi: "h264_vaapi";
+        hevc_vaapi: "hevc_vaapi";
+        h264_nvenc: "h264_nvenc";
+        hevc_nvenc: "hevc_nvenc";
+        h264_qsv: "h264_qsv";
+        hevc_qsv: "hevc_qsv";
+        h264_amf: "h264_amf";
+        hevc_amf: "hevc_amf";
+        libx264: "libx264";
+        libx265: "libx265";
+    }>;
+    defaultH265: z.ZodEnum<{
+        h264_videotoolbox: "h264_videotoolbox";
+        hevc_videotoolbox: "hevc_videotoolbox";
+        h264_vaapi: "h264_vaapi";
+        hevc_vaapi: "hevc_vaapi";
+        h264_nvenc: "h264_nvenc";
+        hevc_nvenc: "hevc_nvenc";
+        h264_qsv: "h264_qsv";
+        hevc_qsv: "hevc_qsv";
+        h264_amf: "h264_amf";
+        hevc_amf: "hevc_amf";
+        libx264: "libx264";
+        libx265: "libx265";
+    }>;
+    probedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type HardwareEncoders = z.infer<typeof HardwareEncodersSchema>;
 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<{
@@ -70,7 +177,6 @@ export declare const platformProbeCapability: {
             }, 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";
@@ -102,12 +208,6 @@ export declare const platformProbeCapability: {
                 }>;
             }, 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;
@@ -132,13 +232,6 @@ export declare const platformProbeCapability: {
             }>;
             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";
@@ -162,7 +255,133 @@ export declare const platformProbeCapability: {
         }, z.core.$strip>, z.ZodObject<{
             preferred: z.ZodReadonly<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Hardware-encoder probe — see Task #185. Cached after first call.
+         */
+        readonly getHardwareEncoders: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            encoders: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                encoder: z.ZodEnum<{
+                    h264_videotoolbox: "h264_videotoolbox";
+                    hevc_videotoolbox: "hevc_videotoolbox";
+                    h264_vaapi: "h264_vaapi";
+                    hevc_vaapi: "hevc_vaapi";
+                    h264_nvenc: "h264_nvenc";
+                    hevc_nvenc: "hevc_nvenc";
+                    h264_qsv: "h264_qsv";
+                    hevc_qsv: "hevc_qsv";
+                    h264_amf: "h264_amf";
+                    hevc_amf: "hevc_amf";
+                    libx264: "libx264";
+                    libx265: "libx265";
+                }>;
+                codec: z.ZodEnum<{
+                    H264: "H264";
+                    H265: "H265";
+                }>;
+                family: z.ZodEnum<{
+                    videotoolbox: "videotoolbox";
+                    vaapi: "vaapi";
+                    qsv: "qsv";
+                    amf: "amf";
+                    nvenc: "nvenc";
+                    software: "software";
+                }>;
+                available: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            defaultH264: z.ZodEnum<{
+                h264_videotoolbox: "h264_videotoolbox";
+                hevc_videotoolbox: "hevc_videotoolbox";
+                h264_vaapi: "h264_vaapi";
+                hevc_vaapi: "hevc_vaapi";
+                h264_nvenc: "h264_nvenc";
+                hevc_nvenc: "hevc_nvenc";
+                h264_qsv: "h264_qsv";
+                hevc_qsv: "hevc_qsv";
+                h264_amf: "h264_amf";
+                hevc_amf: "hevc_amf";
+                libx264: "libx264";
+                libx265: "libx265";
+            }>;
+            defaultH265: z.ZodEnum<{
+                h264_videotoolbox: "h264_videotoolbox";
+                hevc_videotoolbox: "hevc_videotoolbox";
+                h264_vaapi: "h264_vaapi";
+                hevc_vaapi: "hevc_vaapi";
+                h264_nvenc: "h264_nvenc";
+                hevc_nvenc: "hevc_nvenc";
+                h264_qsv: "h264_qsv";
+                hevc_qsv: "hevc_qsv";
+                h264_amf: "h264_amf";
+                hevc_amf: "hevc_amf";
+                libx264: "libx264";
+                libx265: "libx265";
+            }>;
+            probedAt: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly refreshHardwareEncoders: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            encoders: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                encoder: z.ZodEnum<{
+                    h264_videotoolbox: "h264_videotoolbox";
+                    hevc_videotoolbox: "hevc_videotoolbox";
+                    h264_vaapi: "h264_vaapi";
+                    hevc_vaapi: "hevc_vaapi";
+                    h264_nvenc: "h264_nvenc";
+                    hevc_nvenc: "hevc_nvenc";
+                    h264_qsv: "h264_qsv";
+                    hevc_qsv: "hevc_qsv";
+                    h264_amf: "h264_amf";
+                    hevc_amf: "hevc_amf";
+                    libx264: "libx264";
+                    libx265: "libx265";
+                }>;
+                codec: z.ZodEnum<{
+                    H264: "H264";
+                    H265: "H265";
+                }>;
+                family: z.ZodEnum<{
+                    videotoolbox: "videotoolbox";
+                    vaapi: "vaapi";
+                    qsv: "qsv";
+                    amf: "amf";
+                    nvenc: "nvenc";
+                    software: "software";
+                }>;
+                available: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            defaultH264: z.ZodEnum<{
+                h264_videotoolbox: "h264_videotoolbox";
+                hevc_videotoolbox: "hevc_videotoolbox";
+                h264_vaapi: "h264_vaapi";
+                hevc_vaapi: "hevc_vaapi";
+                h264_nvenc: "h264_nvenc";
+                hevc_nvenc: "hevc_nvenc";
+                h264_qsv: "h264_qsv";
+                hevc_qsv: "hevc_qsv";
+                h264_amf: "h264_amf";
+                hevc_amf: "hevc_amf";
+                libx264: "libx264";
+                libx265: "libx265";
+            }>;
+            defaultH265: z.ZodEnum<{
+                h264_videotoolbox: "h264_videotoolbox";
+                hevc_videotoolbox: "hevc_videotoolbox";
+                h264_vaapi: "h264_vaapi";
+                hevc_vaapi: "hevc_vaapi";
+                h264_nvenc: "h264_nvenc";
+                hevc_nvenc: "hevc_nvenc";
+                h264_qsv: "h264_qsv";
+                hevc_qsv: "hevc_qsv";
+                h264_amf: "h264_amf";
+                hevc_amf: "hevc_amf";
+                libx264: "libx264";
+                libx265: "libx265";
+            }>;
+            probedAt: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
     };
 };
 export type IPlatformProbeProvider = InferProvider<typeof platformProbeCapability>;
+export {};
 //# sourceMappingURL=platform-probe.cap.d.ts.map

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

@@ -1 +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"}
+{"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;AAgBlG,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;EAa3B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM9B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK1B,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AA0DrE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAehC;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

package/dist/capabilities/smtp-provider.cap.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
 declare const SendEmailInputSchema: z.ZodObject<{
-    to: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-    cc: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    bcc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    to: z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodEmail>]>;
+    cc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+    bcc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
     from: z.ZodOptional<z.ZodString>;
     replyTo: z.ZodOptional<z.ZodString>;
     subject: z.ZodString;
@@ -12,8 +12,8 @@ declare const SendEmailInputSchema: z.ZodObject<{
 }, z.core.$strip>;
 declare const SendEmailResultSchema: z.ZodObject<{
     messageId: z.ZodString;
-    accepted: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    rejected: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    accepted: z.ZodDefault<z.ZodArray<z.ZodEmail>>;
+    rejected: z.ZodDefault<z.ZodArray<z.ZodEmail>>;
 }, z.core.$strip>;
 declare const SmtpStatusSchema: z.ZodObject<{
     ready: z.ZodBoolean;
@@ -26,11 +26,12 @@ export declare const smtpProviderCapability: {
     readonly scope: "system";
     readonly mode: "collection";
     readonly internal: true;
+    readonly providerKind: "email";
     readonly methods: {
         readonly sendEmail: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            to: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-            cc: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            bcc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            to: z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodEmail>]>;
+            cc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+            bcc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
             from: z.ZodOptional<z.ZodString>;
             replyTo: z.ZodOptional<z.ZodString>;
             subject: z.ZodString;
@@ -38,8 +39,8 @@ export declare const smtpProviderCapability: {
             html: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             messageId: z.ZodString;
-            accepted: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            rejected: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            accepted: z.ZodDefault<z.ZodArray<z.ZodEmail>>;
+            rejected: z.ZodDefault<z.ZodArray<z.ZodEmail>>;
         }, z.core.$strip>, "mutation">;
         /** Round-trip ping against the SMTP relay (EHLO + AUTH if configured).
          *  Used by the operator's "Test connection" button. */

package/dist/capabilities/smtp-provider.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"smtp-provider.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/smtp-provider.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAiBlG,QAAA,MAAM,oBAAoB;;;;;;;;;iBAgBxB,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AAEF,QAAA,MAAM,gBAAgB;;;;;iBASpB,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;QAW/B;+DACuD;;;;;;;;;;;;;;CAYlB,CAAA;AAEzC,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACxE,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,CAAA"}
+{"version":3,"file":"smtp-provider.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/smtp-provider.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAiBlG,QAAA,MAAM,oBAAoB;;;;;;;;;iBAgBxB,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AAEF,QAAA,MAAM,gBAAgB;;;;;iBASpB,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;QAY/B;+DACuD;;;;;;;;;;;;;;CAYlB,CAAA;AAEzC,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACxE,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,CAAA"}

package/dist/capabilities/sso-bridge.cap.d.ts

@@ -21,6 +21,7 @@ declare const SsoBridgeClaimsSchema: z.ZodObject<{
     provider: z.ZodString;
     email: z.ZodOptional<z.ZodString>;
     displayName: z.ZodOptional<z.ZodString>;
+    hubUrl: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const ssoBridgeCapability: {
     readonly name: "sso-bridge";
@@ -36,6 +37,7 @@ export declare const ssoBridgeCapability: {
                 provider: z.ZodString;
                 email: z.ZodOptional<z.ZodString>;
                 displayName: z.ZodOptional<z.ZodString>;
+                hubUrl: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>;
             ttlSec: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>, z.ZodObject<{
@@ -50,6 +52,7 @@ export declare const ssoBridgeCapability: {
             provider: z.ZodString;
             email: z.ZodOptional<z.ZodString>;
             displayName: z.ZodOptional<z.ZodString>;
+            hubUrl: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
     };
 };

package/dist/capabilities/sso-bridge.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sso-bridge.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/sso-bridge.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,qBAAqB;;;;;;;iBAOzB,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBS,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC1E,OAAO,EAAE,qBAAqB,EAAE,CAAA"}
+{"version":3,"file":"sso-bridge.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/sso-bridge.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;iBAgBzB,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBS,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC1E,OAAO,EAAE,qBAAqB,EAAE,CAAA"}

package/dist/capabilities/stream-broker.cap.d.ts

@@ -1,22 +1,12 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
 import type { IStreamBroker } from '../interfaces/stream-broker.js';
-/**
- * Per-broker RTSP restream entry. The broker exposes the public RTSP
- * restream URL for every active profile slot — consumers read the URL
- * here instead of constructing it from broker internals.
- */
 declare const RtspRestreamEntrySchema: z.ZodObject<{
     brokerId: z.ZodString;
     url: z.ZodString;
     mutedUrl: z.ZodString;
     enabled: z.ZodBoolean;
 }, z.core.$strip>;
-/**
- * Individual-client shapes for the `listClients` roster. One row per
- * consumer of the chosen broker slot (profile) — RTSP sessions,
- * decoded-frame subscribers, audio chunks.
- */
 export declare const BrokerRtspClientSchema: z.ZodObject<{
     sessionId: z.ZodString;
     remoteAddr: z.ZodString;
@@ -67,13 +57,6 @@ export type BrokerRtspClient = z.infer<typeof BrokerRtspClientSchema>;
 export type BrokerDecodedClient = z.infer<typeof BrokerDecodedClientSchema>;
 export type BrokerAudioClient = z.infer<typeof BrokerAudioClientSchema>;
 export type BrokerClients = z.infer<typeof BrokerClientsSchema>;
-/**
- * Reason rendered by the broker's placeholder image while no live RTP
- * is flowing. Each value maps 1:1 to a pre-encoded H.264 keyframe in
- * `addon-stream-broker/.../placeholder-frames.ts`. Keep aligned with
- * `PlaceholderKind` over there — the union here is the public surface
- * (cap input + provider type) and is the single source of truth.
- */
 export declare const PlaceholderReasonSchema: z.ZodEnum<{
     disabled: "disabled";
     reconnecting: "reconnecting";
@@ -82,42 +65,61 @@ export declare const PlaceholderReasonSchema: z.ZodEnum<{
     waking: "waking";
 }>;
 export type PlaceholderReason = z.infer<typeof PlaceholderReasonSchema>;
-/**
- * Stream broker — system-wide singleton cap.
- *
- * Owns two registries per device:
- *   - `cameraStreams`: the pool of physical streams published by device
- *     providers (and potentially third-party addons, e.g. an RTMP
- *     discovery addon). Ephemeral: each provider re-publishes in its
- *     own `onInitialize`.
- *   - `profileMap`: persistent operator-intent mapping
- *     `{high?, mid?, low?} -> camStreamId`. Persisted in the broker's
- *     own storage, not in `device.config`.
- *
- * Up to 3 brokers per device keyed `${deviceId}/${profile}`. Each
- * broker ingests from the URL of the cam stream currently assigned via
- * `profileMap[profile]`. Changing the assignment tears down the broker
- * and rebuilds it against the new source — stream id seen by consumers
- * never changes.
- *
- * Per-device reads (what's published, what's assigned) live on the
- * device-scoped `camera-streams` cap, surfaced via `fetchDevice()`. The
- * methods below are either mutations or system-wide dumps.
- */
+declare const VideoCodecTargetSchema: z.ZodEnum<{
+    auto: "auto";
+    H264: "H264";
+    H265: "H265";
+}>;
+export type VideoCodecTarget = z.infer<typeof VideoCodecTargetSchema>;
+declare const AudioCodecTargetSchema: z.ZodEnum<{
+    none: "none";
+    AAC: "AAC";
+    Opus: "Opus";
+    PCMU: "PCMU";
+}>;
+export type AudioCodecTarget = z.infer<typeof AudioCodecTargetSchema>;
+export declare const GetStreamWithCodecInputSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    videoCodec: z.ZodEnum<{
+        auto: "auto";
+        H264: "H264";
+        H265: "H265";
+    }>;
+    audioCodec: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        AAC: "AAC";
+        Opus: "Opus";
+        PCMU: "PCMU";
+    }>>;
+    maxResolution: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    tag: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GetStreamWithCodecInput = z.infer<typeof GetStreamWithCodecInputSchema>;
+export declare const RtpSourceSchema: z.ZodObject<{
+    url: z.ZodString;
+    videoCodec: z.ZodEnum<{
+        H264: "H264";
+        H265: "H265";
+    }>;
+    audioCodec: z.ZodString;
+    resolution: z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>;
+    transcoded: z.ZodBoolean;
+    encoder: z.ZodString;
+    pipelineKey: z.ZodString;
+}, z.core.$strip>;
+export type RtpSource = z.infer<typeof RtpSourceSchema>;
 export declare const streamBrokerCapability: {
     readonly name: "stream-broker";
     readonly scope: "system";
     readonly mode: "singleton";
     readonly exposesDeviceSettings: true;
     readonly methods: {
-        /**
-         * Register a physical camera stream as an input option. Idempotent
-         * for (deviceId, camStreamId) — re-publishing updates metadata
-         * without disturbing profile assignments. The provider calls this
-         * in `onInitialize` for each stream it offers. Third-party addons
-         * may also publish (e.g. an RTMP discovery layer) — camstack has
-         * no notion of "owner" beyond the (deviceId, camStreamId) key.
-         */
         readonly publishCameraStream: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             camStreamId: z.ZodString;
@@ -148,11 +150,6 @@ export declare const streamBrokerCapability: {
         }, z.core.$strip>, z.ZodObject<{
             success: z.ZodLiteral<true>;
         }, z.core.$strip>, "mutation">;
-        /**
-         * Assign a cam stream to a profile slot. Tears down any existing
-         * broker for that slot and rebuilds against the new source. Persists
-         * the choice — survives reboots.
-         */
         readonly assignProfile: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             profile: z.ZodEnum<{
@@ -174,11 +171,6 @@ export declare const streamBrokerCapability: {
         }, z.core.$strip>, z.ZodObject<{
             success: z.ZodLiteral<true>;
         }, z.core.$strip>, "mutation">;
-        /**
-         * Full dump of every published cam stream across every device.
-         * For dashboards and cross-device tooling; per-device reads go
-         * through the `camera-streams` cap on the device proxy.
-         */
         readonly listAllCameraStreams: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             camStreamId: z.ZodString;
             deviceId: z.ZodNumber;
@@ -296,7 +288,6 @@ export declare const streamBrokerCapability: {
         }, z.core.$strip>, z.ZodObject<{
             killed: z.ZodBoolean;
         }, z.core.$strip>, "mutation">;
-        /** Rebuild the broker for a profile slot in place (re-dial source). */
         readonly restartProfile: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             profile: z.ZodEnum<{
@@ -319,12 +310,48 @@ export declare const streamBrokerCapability: {
             url: z.ZodString;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
-         * Return the live IStreamBroker instance for a given brokerId. Same
-         * LOCAL-ONLY contract as before: callers (pipeline-runner) must be
-         * co-located. BrokerId is `${deviceId}/${camStreamId}` — profile
-         * lookup goes through `assignments` if a caller starts from a
-         * profile.
+         * Shared codec-targeted stream API — see Task #184.
+         * Resolution order: source-select → HW transcode → libx264/libx265.
          */
+        readonly getStreamWithCodec: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            videoCodec: z.ZodEnum<{
+                auto: "auto";
+                H264: "H264";
+                H265: "H265";
+            }>;
+            audioCodec: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                AAC: "AAC";
+                Opus: "Opus";
+                PCMU: "PCMU";
+            }>>;
+            maxResolution: z.ZodOptional<z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>>;
+            tag: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            url: z.ZodString;
+            videoCodec: z.ZodEnum<{
+                H264: "H264";
+                H265: "H265";
+            }>;
+            audioCodec: z.ZodString;
+            resolution: z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>;
+            transcoded: z.ZodBoolean;
+            encoder: z.ZodString;
+            pipelineKey: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        readonly releaseStreamWithCodec: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            pipelineKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            released: z.ZodBoolean;
+            refcount: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
         readonly getBroker: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             brokerId: z.ZodString;
         }, z.core.$strip>, z.ZodCustom<IStreamBroker | null, IStreamBroker | null>, import("./capability-definition.js").CapabilityMethodKind>;
@@ -369,12 +396,6 @@ export declare const streamBrokerCapability: {
         }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
     };
     readonly events: {
-        /**
-         * Emitted when a profile starts consuming a push-kind cam stream.
-         * Push-kind providers (e.g. Reolink Baichuan native streams)
-         * subscribe and begin emitting packets only on demand — battery
-         * cams stay asleep until someone actually watches.
-         */
         readonly onCamStreamDemand: import("./capability-definition.js").CapabilityEventSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             camStreamId: z.ZodString;
@@ -384,26 +405,10 @@ export declare const streamBrokerCapability: {
                 low: "low";
             }>;
         }, z.core.$strip>>;
-        /**
-         * Emitted when the last profile consuming a push-kind cam stream
-         * releases it. Providers tear down upstream connections on this
-         * signal.
-         */
         readonly onCamStreamIdle: import("./capability-definition.js").CapabilityEventSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             camStreamId: z.ZodString;
         }, z.core.$strip>>;
-        /**
-         * Emitted by a broker that failed to dial a managed-loopback
-         * source (today: `pull-rfc4571`). The publisher's transport (e.g.
-         * the Reolink lib's RFC 4571 TCP server) idle-tears-down after
-         * ~15s with no clients and may rebind to a different port on
-         * recreate, leaving the URL the broker has cached stale. The owning
-         * camera provider re-runs its publish pipeline on receipt — that
-         * call self-heals the loopback server (`ensureRfc4571Server`) and
-         * `publishCameraStream` propagates the fresh URL back into the
-         * broker's source resolver.
-         */
         readonly onRequestStreamSourceRefresh: import("./capability-definition.js").CapabilityEventSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             camStreamId: z.ZodString;

package/dist/capabilities/stream-broker.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream-broker.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/stream-broker.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA4C,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAMzG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAEnE;;;;GAIG;AACH,QAAA,MAAM,uBAAuB;;;;;iBAK3B,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;iBAQjC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;;iBAMpC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;iBAIlC,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;iBAM9B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAC3E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB;;;;;;EAMlC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,sBAAsB;;;;;;QAO/B;;;;;;;WAOG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkDH;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;QAoBH;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA4BH,uEAAuE;;;;;;;;;;;;;;;;;;;;;;QAiBvE;;;;;;WAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA2CH;;;;;WAKG;;;;;;;;;;QAMH;;;;WAIG;;;;;QAKH;;;;;;;;;;WAUG;;;;;;;CAOkC,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEhF,OAAO,EAAE,uBAAuB,EAAE,CAAA"}
+{"version":3,"file":"stream-broker.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/stream-broker.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA4C,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAMzG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAEnE,QAAA,MAAM,uBAAuB;;;;;iBAK3B,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;iBAQjC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;;iBAMpC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;iBAIlC,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;iBAM9B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAC3E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,uBAAuB;;;;;;EAMlC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAIvE,QAAA,MAAM,sBAAsB;;;;EAAmC,CAAA;AAC/D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,QAAA,MAAM,sBAAsB;;;;;EAA0C,CAAA;AACtE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAOrE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;iBAMxC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEnF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;iBAQ1B,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqF/B;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgEkC,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEhF,OAAO,EAAE,uBAAuB,EAAE,CAAA"}