@camstack/addon-provider-rtsp 0.1.13 → 0.1.14

package/dist/index.js

@@ -20,303 +20,569 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  RtspDevice: () => RtspDevice,
-  RtspProvider: () => RtspProvider,
-  RtspProviderAddon: () => RtspProviderAddon
+  RtspCamera: () => RtspCamera,
+  RtspProviderAddon: () => RtspProviderAddon,
+  rtspCameraSchema: () => rtspCameraSchema
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/rtsp-device.ts
+// src/addon.ts
+var import_types2 = require("@camstack/types");
+
+// src/rtsp-camera.ts
+var import_zod = require("zod");
 var import_types = require("@camstack/types");
-var RtspDevice = class {
-  id;
-  name;
-  providerId;
+var streamEntrySchema = import_zod.z.object({
+  id: import_zod.z.string().regex(/^stream-\d+$/).describe("Stable slot id (stream-1/2/3)"),
+  url: import_zod.z.string().describe("RTSP stream URL"),
+  profileHint: import_zod.z.enum(["high", "mid", "low"]).optional().describe("Provider-suggested profile \u2014 advisory only"),
+  resolution: import_zod.z.object({ width: import_zod.z.number().int().positive(), height: import_zod.z.number().int().positive() }).optional().describe("Probed resolution, if known")
+});
+var streamsField = import_zod.z.preprocess(
+  (raw) => {
+    if (!Array.isArray(raw)) return raw;
+    return raw.map((entry, i) => {
+      if (!entry || typeof entry !== "object") return entry;
+      const o = entry;
+      if (typeof o["id"] === "string") return entry;
+      if (typeof o["label"] === "string" && typeof o["url"] === "string") {
+        return {
+          id: `stream-${i + 1}`,
+          url: o["url"],
+          profileHint: o["label"]
+        };
+      }
+      return entry;
+    });
+  },
+  import_zod.z.array(streamEntrySchema).min(1)
+);
+var rtspCameraSchema = import_zod.z.object({
+  // `name` is now base meta (DB column on `device-meta`, not in this
+  // hardware-config schema). Read via `this.name` (resolved by
+  // `BaseDevice` from `ctx.deviceMeta.name`); mutated via
+  // `kernel.devices.setName(id, name)`.
+  streams: streamsField.describe("Published RTSP streams"),
+  snapshotUrl: import_zod.z.string().default("").describe("Snapshot URL (optional)"),
+  username: import_zod.z.string().default("").describe("Username"),
+  password: import_zod.z.string().default("").describe("Password")
+});
+var legacyStreamSchema = import_zod.z.object({
+  label: import_zod.z.enum(["high", "mid", "low"]),
+  url: import_zod.z.string()
+});
+var RtspCamera = class extends import_types.BaseDevice {
   type = import_types.DeviceType.Camera;
-  capabilities;
-  ctx;
-  stableId;
-  settings;
-  capabilityMap = /* @__PURE__ */ new Map();
-  constructor(device, settings, ctx) {
-    this.id = device.id;
-    this.stableId = device.stableId;
-    this.name = device.name;
-    this.providerId = device.integrationId;
-    this.settings = settings;
-    this.ctx = ctx;
-    this.capabilities = ["camera"];
-    this.capabilityMap.set("camera", this.createCamera());
+  features = [];
+  constructor(ctx) {
+    super(
+      ctx,
+      rtspCameraSchema,
+      { type: import_types.DeviceType.Camera }
+    );
+    this.migrateLegacyStreamsIfNeeded(ctx.persistedConfig ?? {});
+    this.registerSnapshotProvider();
   }
-  getCapability(cap) {
-    return this.capabilityMap.get(cap) ?? null;
-  }
-  hasCapability(cap) {
-    return this.capabilityMap.has(cap);
-  }
-  getState() {
-    return { online: true };
+  /**
+   * Detect legacy `{label, url}` stream shapes and reshape to
+   * `{id, url, profileHint}`. Persists via `config.setAll` once, so
+   * subsequent boots find the new shape and this branch is inert.
+   *
+   * Runs fire-and-forget — the constructor can't await. The reshape is
+   * additive (ids are newly minted) so a failed persist is recoverable
+   * on next boot.
+   */
+  migrateLegacyStreamsIfNeeded(initialData) {
+    const raw = initialData["streams"];
+    if (!Array.isArray(raw)) return;
+    if (raw.every((s) => s && typeof s === "object" && typeof s["id"] === "string")) {
+      return;
+    }
+    const migrated = [];
+    let nextIdx = 1;
+    for (const entry of raw) {
+      const parsed = legacyStreamSchema.safeParse(entry);
+      if (!parsed.success) continue;
+      migrated.push({
+        id: `stream-${nextIdx++}`,
+        url: parsed.data.url,
+        profileHint: parsed.data.label
+      });
+    }
+    if (migrated.length === 0) return;
+    const snapshotUrl = this.config.get("snapshotUrl") ?? "";
+    const username = this.config.get("username") ?? "";
+    const password = this.config.get("password") ?? "";
+    this.ctx.logger.info("Migrating legacy {label,url} streams to {id,url,profileHint}", {
+      tags: { stableId: this.stableId },
+      meta: { streamCount: migrated.length }
+    });
+    void this.config.setAll({ streams: migrated, snapshotUrl, username, password }).catch((err) => {
+      this.ctx.logger.warn("Legacy stream migration failed", {
+        tags: { stableId: this.stableId },
+        meta: { error: err instanceof Error ? err.message : String(err) }
+      });
+    });
   }
-  getMetadata() {
-    return { manufacturer: "Generic RTSP" };
+  /**
+   * Publish every configured stream to the system stream-broker as a
+   * `pull-rtsp` cam stream. Idempotent — the broker's publishCameraStream
+   * entry is keyed by `(deviceId, camStreamId)` so callers may invoke
+   * this at will (e.g. on stream-broker restart). Fire-and-forget safe.
+   */
+  /**
+   * Lifecycle hook fired by the kernel after registration. Publishes
+   * the camera's streams to the broker — the kernel doesn't know
+   * about the broker, but the camera does. Best-effort: if the
+   * broker isn't ready, the provider's `system.ready-state`
+   * subscription re-publishes on the next ready fire.
+   */
+  async onActivate() {
+    await this.publishToBroker().catch((err) => {
+      this.ctx.logger.warn("publishToBroker on activate failed \u2014 will retry on broker ready", {
+        meta: { error: err instanceof Error ? err.message : String(err) }
+      });
+    });
   }
-  createCamera() {
-    const mainUrl = String(this.settings["main_stream_url"] ?? "");
-    const subUrl = String(this.settings["sub_stream_url"] ?? "");
-    const snapshotUrl = String(this.settings["snapshot_url"] ?? "");
-    const deviceId = this.id;
-    return {
-      kind: "camera",
-      async getSnapshot() {
-        if (snapshotUrl) {
-          const res = await fetch(snapshotUrl);
-          return Buffer.from(await res.arrayBuffer());
-        }
-        return Buffer.alloc(0);
-      },
-      async getStreamOptions() {
-        const options = [
-          {
-            id: `${deviceId}_main`,
-            label: "Main",
-            protocol: "rtsp",
-            quality: "main",
-            url: mainUrl
-          }
-        ];
-        if (subUrl) {
-          options.push({
-            id: `${deviceId}_sub`,
-            label: "Sub",
-            protocol: "rtsp",
-            quality: "sub",
-            url: subUrl
-          });
-        }
-        return options;
-      },
-      async getStreamUrl(option) {
-        return option.url ?? mainUrl;
-      },
-      getConnectionMode() {
-        return "always-on";
-      },
-      async setConnectionMode() {
+  async publishToBroker() {
+    const streams = this.config.get("streams");
+    for (const [i, s] of streams.entries()) {
+      try {
+        await this.ctx.api.streamBroker.publishCameraStream.mutate({
+          deviceId: this.id,
+          camStreamId: s.id,
+          kind: "pull-rtsp",
+          url: s.url,
+          ...s.resolution ? { resolution: s.resolution } : {},
+          label: `Stream ${i + 1}`
+        });
+      } catch (err) {
+        this.ctx.logger.warn("publishCameraStream failed", {
+          tags: { deviceId: this.id, camStreamId: s.id },
+          meta: { error: err instanceof Error ? err.message : String(err) }
+        });
       }
-    };
-  }
-};
-
-// src/rtsp-provider.ts
-function sanitizeStableId(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || `rtsp-${Date.now()}`;
-}
-var RtspProvider = class {
-  id;
-  type = "rtsp";
-  name;
-  discoveryMode = "manual";
-  ctx;
-  integration;
-  registry;
-  devices = [];
-  constructor(integration, registry, ctx) {
-    this.id = integration.id;
-    this.name = integration.name;
-    this.integration = integration;
-    this.registry = registry;
-    this.ctx = ctx;
-  }
-  async start() {
-    const registeredDevices = this.registry.listDevices(this.integration.id);
-    for (const device of registeredDevices) {
-      if (!device.enabled) continue;
-      const settings = this.registry.getDeviceSettings(device.id);
-      this.devices.push(this.buildDevice(device, settings));
     }
-    this.ctx.logger.info(`RTSP provider started with ${this.devices.length} cameras`);
-  }
-  async stop() {
-    this.devices.length = 0;
-    this.ctx.logger.info("RTSP provider stopped");
-  }
-  getStatus() {
-    return { connected: true, deviceCount: this.devices.length };
   }
-  async discoverDevices() {
-    return [];
+  /**
+   * Thin compat shim: reflects the stored `{id, url, profileHint?}`
+   * streams into the legacy `StreamSourceEntry` shape so
+   * `ICameraDevice`-aware consumers (device-manager legacy paths,
+   * device-cap-proxy fallback) still find data. The broker itself does
+   * NOT read this anymore — it consumes `publishCameraStream`. This
+   * shim goes away when every consumer migrates (C5/C7).
+   */
+  async getStreamSources() {
+    const streams = this.config.get("streams");
+    return streams.map((s) => ({
+      id: s.id,
+      label: s.profileHint ?? s.id,
+      protocol: "rtsp",
+      url: s.url,
+      ...s.profileHint ? { profileHint: s.profileHint } : {},
+      ...s.resolution ? { resolution: s.resolution } : {}
+    }));
   }
-  getDevices() {
-    return [...this.devices];
+  async removeDevice() {
+    this.ctx.logger.info("Removing RTSP camera", { meta: { stableId: this.stableId } });
+    const streams = this.config.get("streams");
+    await Promise.all(
+      streams.map(
+        (s) => this.ctx.api.streamBroker.retractCameraStream.mutate({ deviceId: this.id, camStreamId: s.id }).catch((err) => {
+          this.ctx.logger.warn("retractCameraStream failed", {
+            tags: { deviceId: this.id, camStreamId: s.id },
+            meta: { error: err instanceof Error ? err.message : String(err) }
+          });
+        })
+      )
+    );
   }
-  getDeviceConfigSchema() {
-    return {
+  // ── Driver-authored settings UI ────────────────────────────────────────
+  //
+  // Streams are stored as `Array<{id, url, profileHint?, resolution?}>`
+  // but the settings UI exposes them as a `multiple` probe field of raw
+  // URLs — the form only cares about the ordered list of URLs, the ids
+  // and classification live in storage. Values are projected from
+  // storage into the flat form keys referenced by the schema.
+  getSettingsUISchema() {
+    const schema = {
       sections: [
+        // The `name` field is now base meta — rendered by the
+        // device-manager's own settings contribution (with the
+        // location field), NOT by the driver's hardware-config
+        // schema. Driver UIs only carry technical knobs.
         {
-          id: "device-info",
-          title: "Device Configuration",
-          description: "Configure the RTSP camera connection",
+          id: "streams",
+          title: "RTSP Streams",
+          description: "Provide 1\u20133 RTSP URLs for this camera. After save, each URL is probed and the stream-broker assigns the (high / mid / low) profiles by resolution (highest pixel count \u2192 high). Input slot order in this form does not affect the broker profile mapping.",
           columns: 1,
           fields: [
             {
-              type: "text",
-              key: "name",
-              label: "Device Name",
-              placeholder: "e.g. Front Door Camera",
-              required: true
-            },
-            {
-              type: "text",
-              key: "main_stream_url",
-              label: "Main Stream URL",
-              placeholder: "rtsp://192.168.1.100:554/stream1",
+              type: "probe",
+              key: "streams",
+              label: "RTSP stream URL",
+              required: true,
+              placeholder: "rtsp://user:pass@host:554/Streaming/Channels/101",
               inputType: "url",
-              required: true
-            },
-            {
-              type: "text",
-              key: "sub_stream_url",
-              label: "Sub Stream URL",
-              placeholder: "rtsp://192.168.1.100:554/stream2",
-              inputType: "url"
-            },
-            {
-              type: "text",
-              key: "snapshot_url",
-              label: "Snapshot URL",
-              placeholder: "http://192.168.1.100/snapshot.jpg",
-              inputType: "url"
+              multiple: {
+                min: 1,
+                max: 3,
+                addLabel: "Add stream",
+                itemLabel: "Stream ${n}",
+                itemDefault: ""
+              }
             }
           ]
+        },
+        {
+          id: "snapshot",
+          title: "Snapshot",
+          columns: 1,
+          fields: [
+            { type: "probe", key: "snapshotUrl", label: "Snapshot URL", description: "Optional HTTP(S) endpoint that returns a JPEG still.", placeholder: "http://host/ISAPI/Streaming/channels/101/picture", inputType: "url" }
+          ]
+        },
+        {
+          id: "credentials",
+          title: "Credentials",
+          description: "Optional. If the RTSP URL already contains user:pass@ you can leave these empty.",
+          columns: 2,
+          fields: [
+            { type: "text", key: "username", label: "Username" },
+            { type: "password", key: "password", label: "Password", showToggle: true }
+          ]
         }
       ]
     };
+    return (0, import_types.hydrateSchema)(schema, this.collectFormValues());
   }
-  async createDevice(config) {
-    const name = String(config["name"] ?? "").trim();
-    if (!name) throw new Error("Device name is required");
-    const mainStreamUrl = String(config["main_stream_url"] ?? "").trim();
-    if (!mainStreamUrl) throw new Error("Main stream URL is required");
-    const stableId = sanitizeStableId(name);
-    const existing = this.registry.getDeviceByStableId(stableId);
-    if (existing) throw new Error(`A device with name "${name}" already exists (stableId: ${stableId})`);
-    const device = this.registry.createDevice({
-      integrationId: this.integration.id,
-      stableId,
-      type: "camera",
-      name,
-      enabled: true,
-      info: {},
-      settings: {
-        main_stream_url: mainStreamUrl,
-        sub_stream_url: config["sub_stream_url"] ? String(config["sub_stream_url"]) : "",
-        snapshot_url: config["snapshot_url"] ? String(config["snapshot_url"]) : ""
-      }
+  /**
+   * Project stored config into the flat UI keys referenced by the schema.
+   * Form only sees URLs — the internal id/profileHint/resolution stay
+   * invisible to the operator (the broker decides profiles from probed
+   * metadata at save time).
+   */
+  collectFormValues() {
+    const stored = this.config.get("streams");
+    const sorted = [...stored].sort((a, b) => a.id.localeCompare(b.id, "en", { numeric: true }));
+    const urls = sorted.map((s) => s.url).filter((u) => u.length > 0);
+    return {
+      streams: urls,
+      snapshotUrl: this.config.get("snapshotUrl"),
+      username: this.config.get("username"),
+      password: this.config.get("password")
+    };
+  }
+  async applySettingsPatch(patch) {
+    const current = this.collectFormValues();
+    const merged = { ...current, ...patch };
+    const pickStr = (k) => typeof merged[k] === "string" ? merged[k].trim() : "";
+    const next = {};
+    const rawStreams = merged["streams"];
+    const incomingUrls = Array.isArray(rawStreams) ? rawStreams.filter((s) => typeof s === "string").map((s) => s.trim()).filter((s) => s.length > 0) : [];
+    if (incomingUrls.length === 0) {
+      next.streams = this.config.get("streams");
+    } else {
+      const probed = await this.probeAndClassify(incomingUrls.slice(0, 3));
+      next.streams = probed;
+    }
+    next.snapshotUrl = pickStr("snapshotUrl");
+    next.username = pickStr("username");
+    next.password = typeof merged["password"] === "string" ? merged["password"] : this.config.get("password");
+    await this.config.setAll(next);
+    await this.publishToBroker();
+  }
+  /**
+   * Probe a list of RTSP URLs through the kernel stream-probe and return
+   * the new `{id, url, profileHint?, resolution?}` entries. Ids are
+   * assigned `stream-1/2/3` in input order so the UI's slot ordering is
+   * preserved across edits. The broker is in charge of the actual
+   * (high/mid/low) profile assignment via `computeInitialAssignment`.
+   */
+  async probeAndClassify(urls) {
+    const streamProbe = this.ctx.streamProbe;
+    if (!streamProbe) {
+      this.ctx.logger.warn(
+        "[rtsp-edit] ctx.streamProbe unavailable \u2014 falling back to input-order profile assignment",
+        { meta: { streamCount: urls.length } }
+      );
+      const sequence = urls.length === 1 ? ["high"] : urls.length === 2 ? ["high", "low"] : ["high", "mid", "low"];
+      return urls.map((url, i) => ({
+        id: `stream-${i + 1}`,
+        url,
+        profileHint: sequence[i]
+      }));
+    }
+    const probed = await Promise.all(
+      urls.map(async (url) => {
+        try {
+          const metadata = await streamProbe.probe(url, { force: false });
+          return { url, metadata };
+        } catch (err) {
+          this.ctx.logger.warn(
+            "[rtsp-edit] probe failed \u2014 landing in the lowest tier via classifyStreams",
+            { meta: { url: (0, import_types.maskUrlCredentials)(url), error: err instanceof Error ? err.message : String(err) } }
+          );
+          const emptyMetadata = {};
+          return { url, metadata: emptyMetadata };
+        }
+      })
+    );
+    const classified = (0, import_types.classifyStreams)(probed);
+    const metadataByUrl = new Map(probed.map((p) => [p.url, p.metadata]));
+    const classifiedByUrl = new Map(classified.map((c) => [c.url, c]));
+    return urls.map((url, i) => {
+      const tag = classifiedByUrl.get(url);
+      const meta = metadataByUrl.get(url);
+      const entry = { id: `stream-${i + 1}`, url };
+      if (tag) entry.profileHint = tag.quality;
+      if (meta?.width && meta?.height) entry.resolution = { width: meta.width, height: meta.height };
+      return entry;
     });
-    const settings = this.registry.getDeviceSettings(device.id);
-    const rtspDevice = this.buildDevice(device, settings);
-    this.devices.push(rtspDevice);
-    this.ctx.logger.info(`Created RTSP device: ${device.id} / ${stableId} (${name})`);
-    return rtspDevice;
   }
-  subscribeLiveEvents(_callback) {
-    return () => {
+  // ── Native capabilities ────────────────────────────────────────────────
+  registerSnapshotProvider() {
+    const snapshotUrl = (this.config.get("snapshotUrl") ?? "").trim();
+    if (!snapshotUrl) return;
+    const provider = {
+      getSnapshot: async ({ deviceId }) => {
+        if (deviceId !== this.id) {
+          throw new Error(`RtspCamera: deviceId mismatch, expected ${this.id}, got ${deviceId}`);
+        }
+        const buf = await this.fetchHttpSnapshot(snapshotUrl);
+        if (buf.length === 0) return null;
+        return { base64: buf.toString("base64"), contentType: "image/jpeg" };
+      },
+      invalidateCache: async () => {
+      }
     };
+    this.ctx.registerNativeCap(import_types.snapshotCapability, provider);
   }
-  buildDevice(device, settings) {
-    const deviceCtx = {
-      id: `device:${device.id}`,
-      logger: this.ctx.logger.child(device.name),
-      eventBus: this.ctx.eventBus,
-      storage: this.ctx.storage,
-      config: this.ctx.config
-    };
-    return new RtspDevice(device, settings, deviceCtx);
+  async fetchHttpSnapshot(url) {
+    const username = (this.config.get("username") ?? "").trim();
+    const password = (this.config.get("password") ?? "").trim();
+    const headers = {};
+    if (username || password) {
+      const creds = Buffer.from(`${username}:${password}`).toString("base64");
+      headers["authorization"] = `Basic ${creds}`;
+    }
+    const res = await fetch(url, { headers });
+    if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`);
+    const ab = await res.arrayBuffer();
+    return Buffer.from(ab);
   }
 };
 
 // src/addon.ts
-var RtspProviderAddon = class {
-  manifest = {
-    id: "provider-rtsp",
-    name: "RTSP Camera Provider",
-    version: "0.1.0",
-    description: "Direct connection to cameras via RTSP URL",
-    capabilities: ["device-provider"]
+function getString(obj, key) {
+  const v = obj[key];
+  return typeof v === "string" ? v : "";
+}
+function getStringArray(obj, key) {
+  const v = obj[key];
+  if (!Array.isArray(v)) return [];
+  return v.filter((s) => typeof s === "string").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function buildCreationFormSchema() {
+  return {
+    sections: [
+      {
+        id: "identity",
+        title: "Camera",
+        columns: 1,
+        fields: [
+          { type: "text", key: "name", label: "Name", required: true, placeholder: "Living room" }
+        ]
+      },
+      {
+        id: "streams",
+        title: "RTSP Streams",
+        description: "Provide 1\u20133 RTSP URLs for this camera. Each URL is probed and published to the stream-broker; the broker assigns the (high / mid / low) profiles by resolution \u2014 you do not need to label the streams manually.",
+        columns: 1,
+        fields: [
+          {
+            type: "probe",
+            key: "streams",
+            label: "RTSP stream URL",
+            required: true,
+            placeholder: "rtsp://user:pass@host:554/Streaming/Channels/101",
+            inputType: "url",
+            multiple: {
+              min: 1,
+              max: 3,
+              addLabel: "Add stream",
+              itemLabel: "Stream ${n}",
+              itemDefault: ""
+            }
+          }
+        ]
+      },
+      {
+        id: "snapshot",
+        title: "Snapshot",
+        columns: 1,
+        fields: [
+          { type: "probe", key: "snapshotUrl", label: "Snapshot URL", description: "Optional HTTP(S) endpoint that returns a JPEG still.", placeholder: "http://host/ISAPI/Streaming/channels/101/picture", inputType: "url" }
+        ]
+      },
+      {
+        id: "credentials",
+        title: "Credentials",
+        description: "Optional. If the RTSP URL already contains user:pass@ you can leave these empty.",
+        columns: 2,
+        fields: [
+          { type: "text", key: "username", label: "Username" },
+          { type: "password", key: "password", label: "Password", showToggle: true }
+        ]
+      }
+    ]
   };
-  provider = null;
-  async initialize(context) {
-    const registry = context.integrationRegistry;
-    if (!registry) {
-      context.logger.warn("IntegrationRegistry not available \u2014 RTSP provider cannot start");
-      return;
-    }
-    let integration = registry.getIntegrationByAddonId("provider-rtsp");
-    if (!integration) {
-      integration = registry.createIntegration({
-        addonId: "provider-rtsp",
-        name: "RTSP Cameras",
-        enabled: true,
-        info: { discoveryMode: "manual", icon: "assets/icon.svg", color: "#78716c" }
-      });
-      context.logger.info(`Created RTSP integration: ${integration.id}`);
-    }
-    if (!integration.enabled) {
-      context.logger.info("RTSP integration is disabled \u2014 skipping start");
-      return;
-    }
-    this.provider = new RtspProvider(integration, registry, {
-      id: context.id,
-      logger: context.logger,
-      eventBus: context.eventBus,
-      storage: context.storage,
-      config: context.config
-    });
-    await this.provider.start();
-    context.logger.info(`RTSP provider started (integration=${integration.id}, devices=${this.provider.getDevices().length})`);
+}
+function isStreamBrokerReady(event) {
+  if (event.category !== "system.ready-state") return false;
+  const data = event.data;
+  return data["capName"] === "stream-broker" && data["state"] === "ready";
+}
+var RtspProviderAddon = class extends import_types2.BaseDeviceProvider {
+  addonId = "provider-rtsp";
+  providerName = "RTSP";
+  deviceClasses = {
+    [import_types2.DeviceType.Camera]: RtspCamera
+  };
+  constructor() {
+    super({});
   }
-  async shutdown() {
-    await this.provider?.stop();
-    this.provider = null;
+  async onInitialize() {
+    const regs = await super.onInitialize();
+    this.subscribe(
+      { category: import_types2.EventCategory.DeviceStateChanged },
+      (event) => {
+        const data = event.data;
+        if (data.capName !== "camera-streams") return;
+        const deviceId = data.deviceId;
+        if (typeof deviceId !== "number") return;
+        const registry = this.ctx.kernel.deviceRegistry;
+        if (!registry) return;
+        if (registry.getAddonId(deviceId) !== this.addonId) return;
+        const device = registry.getById(deviceId);
+        if (!device) return;
+        const online = data.slice?.online === true;
+        if (device.online !== online) device.online = online;
+      }
+    );
+    this.subscribe(
+      { category: import_types2.EventCategory.SystemReadyState },
+      (event) => {
+        if (!isStreamBrokerReady(event)) return;
+        void this.republishAll().catch((err) => {
+          this.ctx.logger.warn("Failed to re-publish RTSP streams after broker ready", {
+            meta: { error: err instanceof Error ? err.message : String(err) }
+          });
+        });
+      }
+    );
+    return regs;
   }
-  getCapabilityProvider(name) {
-    if (name === "device-provider" && this.provider) {
-      return this.provider;
-    }
-    return null;
+  // ── Creation ─────────────────────────────────────────────────────────
+  async onGetCreationSchema(type) {
+    if (type !== import_types2.DeviceType.Camera) return null;
+    return buildCreationFormSchema();
   }
-  getConfigSchema() {
-    return {
-      sections: [
-        {
-          id: "general",
-          title: "RTSP Provider",
-          description: "Configure generic RTSP camera connections",
-          columns: 1,
-          fields: [
-            { type: "text", key: "name", label: "Provider Name", placeholder: "RTSP Cameras" },
-            {
-              type: "info",
-              key: "info",
-              label: "Camera Configuration",
-              content: "Individual cameras are configured via the device management interface after adding this provider.",
-              variant: "info"
-            }
-          ]
+  async onCreateDevice(type, config) {
+    if (type !== import_types2.DeviceType.Camera) {
+      throw new Error(`RTSP provider does not support device type: ${type}`);
+    }
+    const name = getString(config, "name").trim();
+    if (!name) throw new Error("Camera name is required");
+    const rawStreams = getStringArray(config, "streams");
+    if (rawStreams.length === 0) throw new Error("At least one RTSP stream URL is required");
+    if (rawStreams.length > 3) throw new Error("At most 3 RTSP stream URLs are supported");
+    const streamProbe = this.ctx.kernel.streamProbe;
+    if (!streamProbe) throw new Error("ctx.kernel.streamProbe unavailable \u2014 cannot probe streams");
+    const probed = await Promise.all(
+      rawStreams.map(async (url) => {
+        try {
+          const metadata = await streamProbe.probe(url, { force: false });
+          return { url, metadata, ok: true };
+        } catch (err) {
+          this.ctx.logger.warn(
+            "[rtsp-create] probe failed \u2014 publishing without probed metadata",
+            { meta: { url: (0, import_types2.maskUrlCredentials)(url), error: err instanceof Error ? err.message : String(err) } }
+          );
+          return { url, metadata: void 0, ok: false };
         }
-      ]
+      })
+    );
+    const classified = (0, import_types2.classifyStreams)(
+      probed.map((p) => ({ url: p.url, metadata: p.metadata ?? {} }))
+    );
+    const hintByUrl = new Map(classified.map((c) => [c.url, c.quality]));
+    const streams = probed.map((p, i) => {
+      const entry = { id: `stream-${i + 1}`, url: p.url };
+      const hint = hintByUrl.get(p.url);
+      if (hint) entry.profileHint = hint;
+      if (p.metadata?.width && p.metadata?.height) {
+        entry.resolution = { width: p.metadata.width, height: p.metadata.height };
+      }
+      return entry;
+    });
+    const parsed = rtspCameraSchema.parse({
+      streams,
+      snapshotUrl: getString(config, "snapshotUrl"),
+      username: getString(config, "username"),
+      password: getString(config, "password")
+    });
+    return {
+      meta: { type: import_types2.DeviceType.Camera, name },
+      config: parsed
     };
   }
-  getConfig() {
-    return {};
+  // ── Field probing ────────────────────────────────────────────────────
+  async testCreationField(input) {
+    if (input.type !== import_types2.DeviceType.Camera) {
+      return { status: "error", error: `Unsupported device type: ${input.type}` };
+    }
+    const streamProbe = this.ctx.kernel.streamProbe;
+    if (!streamProbe) {
+      return { status: "error", error: "ctx.kernel.streamProbe unavailable \u2014 cannot reach kernel probe" };
+    }
+    return streamProbe.probeField(input.key, input.value);
   }
-  async onConfigChange(_config) {
+  // ── Restore ──────────────────────────────────────────────────────────
+  //
+  // `BaseDeviceProvider.onRestoreDevices` default impl iterates
+  // `savedDevices`, looks up the right class via `deviceClasses`,
+  // and calls `kernel.devices.create()`. Each created device fires
+  // its `onCreated` lifecycle hook (see `RtspCamera.onCreated()`)
+  // which publishes streams to the broker — no per-provider override
+  // needed here.
+  // ── Internal — re-publish every RtspCamera to the broker ────────────
+  async republishAll() {
+    const all = await this.ctx.kernel.devices?.getAll() ?? [];
+    let published = 0;
+    for (const dev of all) {
+      if (!(dev instanceof RtspCamera)) continue;
+      try {
+        await dev.publishToBroker();
+        published++;
+      } catch (err) {
+        this.ctx.logger.debug("publishToBroker threw during republish", {
+          tags: { deviceId: dev.id },
+          meta: { error: err instanceof Error ? err.message : String(err) }
+        });
+      }
+    }
+    if (published > 0) {
+      this.ctx.logger.info("Re-published RTSP streams to stream-broker", {
+        meta: { published, total: all.length }
+      });
+    }
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RtspDevice,
-  RtspProvider,
-  RtspProviderAddon
+  RtspCamera,
+  RtspProviderAddon,
+  rtspCameraSchema
 });
 //# sourceMappingURL=index.js.map