@camstack/types 0.1.40 → 0.1.42

package/dist/capabilities/binary.cap.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Generic boolean sensor — last-resort fallback when no domain-
+ * specific binary cap fits (Home Assistant `binary_sensor` without a
+ * known `device_class`, or a domain we haven't typed yet). Pure
+ * pass-through: just the bool + timestamp. Push-driven.
+ *
+ * Prefer the typed alternatives (`contact`, `flood`, `smoke`,
+ * `carbon-monoxide`, `gas`, `tamper`, `vibration`, `connectivity`,
+ * `motion`) when the semantics match — export adapters render those
+ * with the right HomeKit / Alexa display category.
+ */
+export declare const BinaryStatusSchema: z.ZodObject<{
+    on: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type BinaryStatus = z.infer<typeof BinaryStatusSchema>;
+export declare const binaryCapability: {
+    readonly name: "binary";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Sensor];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            on: z.ZodBoolean;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        on: z.ZodBoolean;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IBinaryProvider = InferProvider<typeof binaryCapability>;
+//# sourceMappingURL=binary.cap.d.ts.map

package/dist/capabilities/binary.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/binary.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB;;;iBAI7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;CAYY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/capabilities/brightness.cap.d.ts

@@ -4,8 +4,8 @@ import { DeviceType } from '../device/device-type.js';
 /**
  * Dimmable-light brightness control. Co-exists with `switch` on the
  * same device — the switch toggles on/off, this cap sets the level
- * applied when the light is on. Modeled after Scrypted's `Brightness`
- * interface so drivers can map their per-vendor dim controls cleanly.
+ * applied when the light is on. Drivers map their per-vendor dim
+ * controls to this single-method surface.
  *
  * The cap is intentionally minimal: a single `setBrightness({deviceId,
  * percentage})` mutation plus the auto-injected `getStatus`. Drivers
@@ -21,6 +21,7 @@ export type BrightnessStatus = z.infer<typeof BrightnessStatusSchema>;
 export declare const brightnessCapability: {
     readonly name: "brightness";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Light];
     readonly methods: {

package/dist/capabilities/brightness.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brightness.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/brightness.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB;;;iBAKjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;QAgB7B;;;;WAIG;;;;;;;;;;;;;;;;IAWL;;;;OAIG;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA"}
+{"version":3,"file":"brightness.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/brightness.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB;;;iBAKjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;QAiB7B;;;;WAIG;;;;;;;;;;;;;;;;IAWL;;;;OAIG;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

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

@@ -0,0 +1,291 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * `broker` — unified pub/sub broker registry, system-scoped collection.
+ *
+ * The cap models any kind-tagged message broker the user wants to
+ * register and that other addons might consume. The first two kinds
+ * are MQTT (mosquitto / aedes embedded / cloud bridge) and
+ * Home Assistant (HA WebSocket — subscribe_entities + call_service).
+ * Future kinds (Zigbee2MQTT bridge, ZHA, KNX, Telegram, …) plug in
+ * the same surface.
+ *
+ * Why one cap, not one cap per kind:
+ *   - The integrations page wants a single table of "every broker"
+ *     across kinds; a unified cap drives it without join logic.
+ *   - Generic admin operations (add / remove / test / status) are
+ *     identical across kinds — duplicating them per cap was busywork.
+ *   - The `network-access` cap precedent: same interface, many
+ *     `providerKind: 'ingress'` implementations (Tailscale, ngrok, …).
+ *
+ * What stays kind-specific:
+ *   - `getBrokerConfig` payload (kind decides whether it returns
+ *     mqtt URL+creds, HA baseUrl+token, …) — typed as
+ *     `Record<string, unknown>` at the wire; consumers narrow.
+ *   - `publish` / `subscribe` / `getState` arguments (target / filter /
+ *     key) — also typed as `Record<string, unknown>` so each kind can
+ *     evolve its surface (MQTT topic+qos vs HA entity_id+domain)
+ *     without rebreaking the cap signature.
+ *   - `add` `settings` payload (different fields per kind, validated by
+ *     the kind-specific provider).
+ *
+ * Bidirectionality:
+ *   - `publish` is RPC — synchronous result (provider-defined).
+ *   - `subscribe` returns a subscription handle; the actual message
+ *     stream flows over the typed event-bus as `broker.message` events
+ *     keyed by `(brokerId, subscriptionId)`. Consumers filter in their
+ *     event handler. Subscriptions persist across reconnects — the
+ *     provider re-subscribes upstream after a transport drop.
+ *
+ * Why event-bus push (not a subscription RPC stream):
+ *   - Matches the rest of CamStack's D8 contract — events for telemetry,
+ *     RPC for loss-is-a-bug. Broker messages are telemetry (a single
+ *     drop is recoverable via `getState({key})`).
+ *   - Frees `broker.subscribe` from holding a long-lived RPC channel.
+ *   - Cross-process: events already route through `$event-bus`; no
+ *     per-broker wire-shaping needed.
+ */
+export declare const BrokerStatusEnum: z.ZodEnum<{
+    error: "error";
+    unreachable: "unreachable";
+    connecting: "connecting";
+    connected: "connected";
+    disconnected: "disconnected";
+    "auth-failed": "auth-failed";
+}>;
+export type BrokerStatus = z.infer<typeof BrokerStatusEnum>;
+declare const BrokerInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    addonId: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodString;
+    status: z.ZodEnum<{
+        error: "error";
+        unreachable: "unreachable";
+        connecting: "connecting";
+        connected: "connected";
+        disconnected: "disconnected";
+        "auth-failed": "auth-failed";
+    }>;
+    info: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    lastCheckedAt: z.ZodNullable<z.ZodNumber>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type BrokerInfo = z.infer<typeof BrokerInfoSchema>;
+declare const RegistryStatusSchema: z.ZodObject<{
+    brokerCount: z.ZodNumber;
+    connectedCount: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * One entry per `broker` provider — which addon provides which broker
+ * kind(s). The unified create picker reads this to know, for each
+ * (addonId, kind) pair the operator can pick, where to route the
+ * follow-up `getSettingsSchema` / `testSettings` / `add` calls (via the
+ * `{ addonId }` selector). A provider only advertises a kind here when
+ * it implements `getSettingsSchema` for that kind (so the picker never
+ * offers a kind whose creation form can't be rendered).
+ */
+declare const BrokerProviderInfoSchema: z.ZodObject<{
+    addonId: z.ZodString;
+    kinds: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BrokerProviderInfo = z.infer<typeof BrokerProviderInfoSchema>;
+declare const AddInputSchema: z.ZodObject<{
+    kind: z.ZodString;
+    name: z.ZodString;
+    settings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+declare const TestConnectionResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    latencyMs: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    error: z.ZodString;
+}, z.core.$strip>], "ok">;
+declare const SettingsSchemaInputSchema: z.ZodObject<{
+    kind: z.ZodString;
+}, z.core.$strip>;
+declare const TestSettingsInputSchema: z.ZodObject<{
+    kind: z.ZodString;
+    settings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+declare const TestSettingsResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    latencyMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    error: z.ZodString;
+}, z.core.$strip>], "ok">;
+declare const PublishInputSchema: z.ZodObject<{
+    brokerId: z.ZodString;
+    target: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    payload: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const SubscribeInputSchema: z.ZodObject<{
+    brokerId: z.ZodString;
+    filter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+declare const SubscribeResultSchema: z.ZodObject<{
+    subscriptionId: z.ZodString;
+}, z.core.$strip>;
+declare const UnsubscribeInputSchema: z.ZodObject<{
+    brokerId: z.ZodString;
+    subscriptionId: z.ZodString;
+}, z.core.$strip>;
+declare const GetStateInputSchema: z.ZodObject<{
+    brokerId: z.ZodString;
+    key: z.ZodString;
+}, z.core.$strip>;
+export declare const brokerCapability: {
+    readonly name: "broker";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly providerKind: "broker";
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            brokerCount: z.ZodNumber;
+            connectedCount: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "poll";
+    };
+    readonly methods: {
+        readonly list: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            addonId: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodString;
+            status: z.ZodEnum<{
+                error: "error";
+                unreachable: "unreachable";
+                connecting: "connecting";
+                connected: "connected";
+                disconnected: "disconnected";
+                "auth-failed": "auth-failed";
+            }>;
+            info: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            lastCheckedAt: z.ZodNullable<z.ZodNumber>;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly get: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            addonId: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodString;
+            status: z.ZodEnum<{
+                error: "error";
+                unreachable: "unreachable";
+                connecting: "connecting";
+                connected: "connected";
+                disconnected: "disconnected";
+                "auth-failed": "auth-failed";
+            }>;
+            info: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            lastCheckedAt: z.ZodNullable<z.ZodNumber>;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Enumerate which addon provides which broker kind(s) for the
+         *  unified create picker. The auto-mount fans this array across
+         *  every registered `broker` provider (array-output method), so the
+         *  picker sees every kind from every provider in one call. */
+        readonly listProviders: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodArray<z.ZodObject<{
+            addonId: z.ZodString;
+            kinds: z.ZodArray<z.ZodObject<{
+                kind: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly add: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            kind: z.ZodString;
+            name: z.ZodString;
+            settings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        readonly remove: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly testConnection: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            latencyMs: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            ok: z.ZodLiteral<false>;
+            error: z.ZodString;
+        }, z.core.$strip>], "ok">, "mutation">;
+        /** Read the persisted settings record for a broker (kind-specific
+         *  shape). Admin-only — settings may contain secrets. Returns `null`
+         *  when the broker id is unknown to the provider (the collection
+         *  fallback may route a foreign id to the first provider). */
+        readonly getSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Overwrite the persisted settings record. The kind-specific
+         *  provider validates the shape and applies the change (reconnects
+         *  if credentials changed). */
+        readonly setSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+            settings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Returns the kind-specific connection config the consumer needs
+         *  to open its own client (MQTT pattern: `{url, username, password,
+         *  clientIdPrefix}`). HA providers MAY return the auth envelope
+         *  but typical HA consumers use `publish` / `subscribe` instead.
+         *  Returns `null` when the broker id is unknown to the provider. */
+        readonly getBrokerConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getSettingsSchema: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            kind: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodUnknown>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly testSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            kind: z.ZodString;
+            settings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            latencyMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            ok: z.ZodLiteral<false>;
+            error: z.ZodString;
+        }, z.core.$strip>], "ok">, "mutation">;
+        readonly publish: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            brokerId: z.ZodString;
+            target: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            payload: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        readonly subscribe: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            brokerId: z.ZodString;
+            filter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            subscriptionId: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        readonly unsubscribe: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            brokerId: z.ZodString;
+            subscriptionId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Read the broker's cached state for a key. Returns `null` when
+         *  unknown to the broker (never published / unknown entity). */
+        readonly getState: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            brokerId: z.ZodString;
+            key: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodUnknown>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Status method — explicit registration with a `z.void()` input so
+         *  the codegen-generated tRPC router types its input as
+         *  `{addonId?: string, nodeId?: string}` (system-scoped collection
+         *  shape) instead of the device-scoped `{deviceId}` fallback. */
+        readonly getStatus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            brokerCount: z.ZodNumber;
+            connectedCount: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IBrokerProvider = InferProvider<typeof brokerCapability>;
+export { BrokerInfoSchema, BrokerProviderInfoSchema, RegistryStatusSchema as BrokerRegistryStatusSchema, TestConnectionResultSchema as BrokerTestConnectionResultSchema, PublishInputSchema as BrokerPublishInputSchema, SubscribeInputSchema as BrokerSubscribeInputSchema, SubscribeResultSchema as BrokerSubscribeResultSchema, UnsubscribeInputSchema as BrokerUnsubscribeInputSchema, GetStateInputSchema as BrokerGetStateInputSchema, AddInputSchema as BrokerAddInputSchema, SettingsSchemaInputSchema as BrokerSettingsSchemaInputSchema, TestSettingsInputSchema as BrokerTestSettingsInputSchema, TestSettingsResultSchema as BrokerTestSettingsResultSchema, };
+//# sourceMappingURL=broker.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"broker.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/broker.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,eAAO,MAAM,gBAAgB;;;;;;;EAO3B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE3D,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;iBA2BpB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,QAAA,MAAM,oBAAoB;;;iBAGxB,CAAA;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,wBAAwB;;;;;;iBAK5B,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAUzE,QAAA,MAAM,cAAc;;;;iBAOlB,CAAA;AAMF,QAAA,MAAM,0BAA0B;;;;;;yBAG9B,CAAA;AAIF,QAAA,MAAM,yBAAyB;;iBAAiC,CAAA;AAChE,QAAA,MAAM,uBAAuB;;;iBAG3B,CAAA;AACF,QAAA,MAAM,wBAAwB;;;;;;yBAK5B,CAAA;AAIF,QAAA,MAAM,kBAAkB;;;;iBAUtB,CAAA;AAEF,QAAA,MAAM,oBAAoB;;;iBAMxB,CAAA;AAEF,QAAA,MAAM,qBAAqB;;iBAIzB,CAAA;AAEF,QAAA,MAAM,sBAAsB;;;iBAG1B,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;iBAMvB,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAUzB;;;sEAG8D;;;;;;;;;;;;;;;;;;;;;;;;;;;QAO9D;;;sEAG8D;;;;QAE9D;;uCAE+B;;;;;QAQ/B;;;;4EAIoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAYpE;wEACgE;;;;;QAGhE;;;yEAGiE;;;;;;CAG5B,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEpE,OAAO,EACL,gBAAgB,EAChB,wBAAwB,EACxB,oBAAoB,IAAI,0BAA0B,EAClD,0BAA0B,IAAI,gCAAgC,EAC9D,kBAAkB,IAAI,wBAAwB,EAC9C,oBAAoB,IAAI,0BAA0B,EAClD,qBAAqB,IAAI,2BAA2B,EACpD,sBAAsB,IAAI,4BAA4B,EACtD,mBAAmB,IAAI,yBAAyB,EAChD,cAAc,IAAI,oBAAoB,EACtC,yBAAyB,IAAI,+BAA+B,EAC5D,uBAAuB,IAAI,6BAA6B,EACxD,wBAAwB,IAAI,8BAA8B,GAC3D,CAAA"}

package/dist/capabilities/button.cap.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * button — device-scoped capability for HA `button.*` / `input_button.*`
+ * fire-only actuators. A button entity has no readable state — pressing it
+ * triggers an action on the HA side. There is no `status` / `runtimeState`:
+ * nothing to poll, nothing to subscribe to.
+ *
+ * Usage: the admin UI renders a single "Press" affordance. The provider calls
+ * the HA `button.press` (or `input_button.press`) service. The domain is
+ * derived from the entity_id prefix at runtime.
+ */
+export declare const buttonCapability: {
+    readonly name: "button";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Button];
+    readonly methods: {
+        readonly press: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+};
+export type IButtonProvider = InferProvider<typeof buttonCapability>;
+//# sourceMappingURL=button.cap.d.ts.map

package/dist/capabilities/button.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"button.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/button.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAaY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/capabilities/camera-credentials.cap.d.ts

@@ -62,6 +62,7 @@ export type CameraCredentialsStatus = z.infer<typeof CameraCredentialsStatusSche
 export declare const cameraCredentialsCapability: {
     readonly name: "camera-credentials";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly methods: {

package/dist/capabilities/camera-credentials.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"camera-credentials.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/camera-credentials.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;iBAiBlC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;iBASxC,CAAA;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEnF,eAAO,MAAM,2BAA2B;;;;;;QAMpC;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWkC,CAAA;AAEzC,MAAM,MAAM,0BAA0B,GAAG,aAAa,CAAC,OAAO,2BAA2B,CAAC,CAAA"}
+{"version":3,"file":"camera-credentials.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/camera-credentials.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;iBAiBlC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;iBASxC,CAAA;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEnF,eAAO,MAAM,2BAA2B;;;;;;;QAOpC;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWkC,CAAA;AAEzC,MAAM,MAAM,0BAA0B,GAAG,aAAa,CAAC,OAAO,2BAA2B,CAAC,CAAA"}

package/dist/capabilities/camera-streams.cap.d.ts

@@ -1,6 +1,56 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
 import { DeviceType } from '../device/device-type.js';
+export declare const StreamCodecSchema: z.ZodEnum<{
+    h264: "h264";
+    h265: "h265";
+    hevc: "hevc";
+    mjpeg: "mjpeg";
+    av1: "av1";
+    vp8: "vp8";
+    vp9: "vp9";
+}>;
+export type StreamCodec = z.infer<typeof StreamCodecSchema>;
+export declare const PickStreamRequirementsSchema: z.ZodReadonly<z.ZodObject<{
+    acceptCodecs: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        h264: "h264";
+        h265: "h265";
+        hevc: "hevc";
+        mjpeg: "mjpeg";
+        av1: "av1";
+        vp8: "vp8";
+        vp9: "vp9";
+    }>>>>;
+    minHeight: z.ZodOptional<z.ZodNumber>;
+    minWidth: z.ZodOptional<z.ZodNumber>;
+    excludeDerived: z.ZodOptional<z.ZodBoolean>;
+    requireSiblingCodec: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        h264: "h264";
+        h265: "h265";
+        hevc: "hevc";
+        mjpeg: "mjpeg";
+        av1: "av1";
+        vp8: "vp8";
+        vp9: "vp9";
+    }>>>>;
+}, z.core.$strip>>;
+export declare const PickStreamPreferencesSchema: z.ZodReadonly<z.ZodObject<{
+    preferredProviders: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    resolutionPreference: z.ZodOptional<z.ZodEnum<{
+        highest: "highest";
+        lowest: "lowest";
+    }>>;
+}, z.core.$strip>>;
+export declare const PickedCamStreamSchema: z.ZodObject<{
+    camStreamId: z.ZodString;
+    codec: z.ZodOptional<z.ZodString>;
+    resolution: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type PickedCamStream = z.infer<typeof PickedCamStreamSchema>;
 /**
  * Camera streams — device-scoped facade over the system `stream-broker`.
  *
@@ -38,6 +88,7 @@ export declare const cameraStreamsCapability: {
                 "pull-http": "pull-http";
                 "pull-rfc4571": "pull-rfc4571";
                 "push-annexb": "push-annexb";
+                derived: "derived";
             }>;
             url: z.ZodOptional<z.ZodString>;
             codec: z.ZodOptional<z.ZodString>;
@@ -78,17 +129,16 @@ export declare const cameraStreamsCapability: {
             errorMessage: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
-         * Per-device RTSP restream entries. Returns the broker's published
-         * RTSP URLs (one per `${deviceId}/${profile}`) for THIS device only,
-         * including the rendered `url` field with the RTSP token applied.
-         * Consumers (snapshot wrapper, recording, external probes) use this
-         * to pick a stream URL without scanning the whole cluster.
+         * Per-device RAW RTSP restream entries — one per published camStream
+         * that has RTSP restream enabled (`native:main`, `rtsp:sub`, …).
          *
-         * The system `stream-broker.getAllRtspEntries({hostname?})` still
-         * exists for whole-cluster use cases (admin dashboard, settings
-         * exports). This device-scoped accessor is the supported handle for
-         * code that already has a `deviceId` in hand — keeps device-keyed
-         * filtering server-side and rides the DeviceProxy auto-injection.
+         * LIVE-VIEW ONLY. This is the surface the device-details stream
+         * picker uses so an operator can hit each physical stream directly.
+         * Programmatic / external consumers (HAP, Alexa, ha-mqtt, recording)
+         * MUST use `getProfileRtspEntries` instead — picking from raw
+         * variants makes two consumers of the same camera land on two
+         * different physical pulls (e.g. Reolink `native:main` vs
+         * `rtsp:main`) and trips the camera's concurrent-session limit.
          */
         readonly getRtspEntries: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
@@ -98,7 +148,93 @@ export declare const cameraStreamsCapability: {
             url: z.ZodString;
             mutedUrl: z.ZodString;
             enabled: z.ZodBoolean;
+            codec: z.ZodOptional<z.ZodString>;
+            resolution: z.ZodOptional<z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Per-device PROFILE RTSP restream entries — one per ASSIGNED
+         * profile slot (high/mid/low). Each entry's `url` is a profile-keyed
+         * broker restream that aliases the profile's assigned source broker,
+         * so HAP / Alexa / recording / WebRTC all converge on the broker's
+         * single on-demand pull for that profile. This is the supported
+         * exporter-facing surface; the raw `getRtspEntries` is live-view
+         * only. Returns `[]` for a device with no assigned profiles
+         * (cold-start before first publish).
+         */
+        readonly getProfileRtspEntries: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            hostname: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            profile: z.ZodEnum<{
+                high: "high";
+                mid: "mid";
+                low: "low";
+            }>;
+            brokerId: z.ZodString;
+            url: z.ZodString;
+            mutedUrl: z.ZodString;
+            enabled: z.ZodBoolean;
+            codec: z.ZodOptional<z.ZodString>;
+            resolution: z.ZodOptional<z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * "Best source stream for these decode constraints". Returns the
+         * camStreamId the caller should dial (or null when no stream
+         * matches). See `PickStreamRequirementsSchema` for the filter shape
+         * and `PickStreamPreferencesSchema` for the ranking inputs.
+         *
+         * Returning null instructs the caller to fall back to its existing
+         * path (derived-broker transcode, profile-slot pick, etc.) — the
+         * picker NEVER ranks `derived:*` candidates as a "match" because
+         * its whole job is to avoid the transcode.
+         */
+        readonly pickStream: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            requirements: z.ZodReadonly<z.ZodObject<{
+                acceptCodecs: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    h264: "h264";
+                    h265: "h265";
+                    hevc: "hevc";
+                    mjpeg: "mjpeg";
+                    av1: "av1";
+                    vp8: "vp8";
+                    vp9: "vp9";
+                }>>>>;
+                minHeight: z.ZodOptional<z.ZodNumber>;
+                minWidth: z.ZodOptional<z.ZodNumber>;
+                excludeDerived: z.ZodOptional<z.ZodBoolean>;
+                requireSiblingCodec: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    h264: "h264";
+                    h265: "h265";
+                    hevc: "hevc";
+                    mjpeg: "mjpeg";
+                    av1: "av1";
+                    vp8: "vp8";
+                    vp9: "vp9";
+                }>>>>;
+            }, z.core.$strip>>;
+            preferences: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                preferredProviders: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                resolutionPreference: z.ZodOptional<z.ZodEnum<{
+                    highest: "highest";
+                    lowest: "lowest";
+                }>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            camStreamId: z.ZodString;
+            codec: z.ZodOptional<z.ZodString>;
+            resolution: z.ZodOptional<z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>>;
+            reason: z.ZodString;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
     };
     readonly events: {
         /** Fires on publishCameraStream / retractCameraStream. */
@@ -113,6 +249,7 @@ export declare const cameraStreamsCapability: {
                     "pull-http": "pull-http";
                     "pull-rfc4571": "pull-rfc4571";
                     "push-annexb": "push-annexb";
+                    derived: "derived";
                 }>;
                 url: z.ZodOptional<z.ZodString>;
                 codec: z.ZodOptional<z.ZodString>;

package/dist/capabilities/camera-streams.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"camera-streams.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/camera-streams.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA4C,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AACzG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAKrD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAgBhC;;;;;;;;;;;;WAYG;;;;;;;;;;;;QAWH,0DAA0D;;;;;;;;;;;;;;;;;;;;;;;;;;QAK1D,wEAAwE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAM1E;;;;;;;;;;;;;;;;;;;;;;OAsBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAeoC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}
+{"version":3,"file":"camera-streams.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/camera-streams.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA4C,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AACzG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAuBrD,eAAO,MAAM,iBAAiB;;;;;;;;EAA8B,CAAA;AAC5D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;kBA2B5B,CAAA;AAEb,eAAO,MAAM,2BAA2B;;;;;;kBAa3B,CAAA;AAEb,eAAO,MAAM,qBAAqB;;;;;;;;iBAMhC,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAGnE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAgBhC;;;;;;;;;;;WAWG;;;;;;;;;;;;;;;QASH;;;;;;;;;WASG;;;;;;;;;;;;;;;;;;;;QASH;;;;;;;;;;WAUG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAWH,0DAA0D;;;;;;;;;;;;;;;;;;;;;;;;;;;QAK1D,wEAAwE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAM1E;;;;;;;;;;;;;;;;;;;;;;OAsBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAeoC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

package/dist/capabilities/capability-definition.d.ts

@@ -253,6 +253,12 @@ export interface CapabilityDefinition<TName extends string = string, TMethods ex
      * Ignored unless `kind === 'wrapper'`. Default: `false`.
      */
     readonly defaultActive?: boolean;
+    /** True when this cap is registered PER-DEVICE via `ctx.registerNativeCap`
+     *  (the provider IS the device), so the tRPC layer must resolve it with
+     *  `requireDeviceScoped` → `getNativeProvider(capName, deviceId)`. Distinct
+     *  from `scope:'device'` SYSTEM caps (zones/recording/motion/events) whose
+     *  single provider dispatches on deviceId internally. Default: undefined/false. */
+    readonly deviceNative?: boolean;
     /** Method definitions: name → { input, output } Zod schemas */
     readonly methods: TMethods;
     /** Event definitions: name → { data } Zod schema (optional) */
@@ -378,6 +384,15 @@ export interface CapabilityDefinition<TName extends string = string, TMethods ex
      *     cluster roster.
      */
     readonly nodeIdMode?: 'routing' | 'data';
+    /**
+     * For `mode: 'singleton'` caps with multiple possible provider addons —
+     * the addon id that should be the DEFAULT active provider when no operator
+     * preference (`setActiveSingleton`) is set. Makes active-provider selection
+     * deterministic instead of registration-order-dependent. Ignored when an
+     * operator preference exists (operator choice always wins) and for
+     * non-singleton caps.
+     */
+    readonly preferredProvider?: string;
 }
 /** Contract for the three methods added by `exposesDeviceSettings: true`. */
 export interface DeviceSettingsContribution {