@camstack/sdk 0.1.23

package/dist/index.cjs

@@ -0,0 +1,1169 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BackendClient: () => BackendClient,
+  DEFAULT_ENABLED_CLASSES: () => DEFAULT_ENABLED_CLASSES,
+  DetectionClass: () => DetectionClass,
+  ELIGIBLE_HA_DOMAINS: () => ELIGIBLE_HA_DOMAINS,
+  ELIGIBLE_HA_DOMAINS_SET: () => ELIGIBLE_HA_DOMAINS_SET,
+  ELIGIBLE_SCRYPTED_DEVICE_TYPES: () => ELIGIBLE_SCRYPTED_DEVICE_TYPES,
+  ELIGIBLE_SCRYPTED_DEVICE_TYPES_SET: () => ELIGIBLE_SCRYPTED_DEVICE_TYPES_SET,
+  FEATURE_MATRIX: () => FEATURE_MATRIX,
+  HA_DOMAIN_TYPE_MAP: () => HA_DOMAIN_TYPE_MAP,
+  RAW_TO_CANONICAL: () => RAW_TO_CANONICAL,
+  SCRYPTED_TYPE_TO_CANONICAL: () => SCRYPTED_TYPE_TO_CANONICAL,
+  TIMELINE_PRESET_ALL: () => TIMELINE_PRESET_ALL,
+  TIMELINE_PRESET_CRITICAL: () => TIMELINE_PRESET_CRITICAL,
+  TIMELINE_PRESET_IMPORTANT: () => TIMELINE_PRESET_IMPORTANT,
+  animalClasses: () => animalClasses,
+  audioClasses: () => audioClasses,
+  audioLabelClasses: () => audioLabelClasses,
+  createBackendClient: () => createBackendClient,
+  defaultDetectionClasses: () => defaultDetectionClasses,
+  detectionClassesDefaultMap: () => detectionClassesDefaultMap,
+  doorbellClasses: () => doorbellClasses,
+  faceClasses: () => faceClasses,
+  getBackendRequiredFeatures: () => getBackendRequiredFeatures,
+  getCanonicalDeviceType: () => getCanonicalDeviceType,
+  getClassesForTimelinePreset: () => getClassesForTimelinePreset,
+  getNextEvalInterval: () => getNextEvalInterval,
+  getParentClass: () => getParentClass,
+  getParentDetectionClass: () => getParentDetectionClass,
+  getSourceFeatures: () => getSourceFeatures,
+  isAnimalClassname: () => isAnimalClassname,
+  isAudioClassname: () => isAudioClassname,
+  isDoorbellClassname: () => isDoorbellClassname,
+  isFaceClassname: () => isFaceClassname,
+  isFeatureAvailable: () => isFeatureAvailable,
+  isLabelDetection: () => isLabelDetection,
+  isMotionClassname: () => isMotionClassname,
+  isPackageClassname: () => isPackageClassname,
+  isPersonClassname: () => isPersonClassname,
+  isPlateClassname: () => isPlateClassname,
+  isSensorLabelClassname: () => isSensorLabelClassname,
+  isVehicleClassname: () => isVehicleClassname,
+  licensePlateClasses: () => licensePlateClasses,
+  motionClasses: () => motionClasses,
+  packageClasses: () => packageClasses,
+  personClasses: () => personClasses,
+  selectOptimalStream: () => selectOptimalStream,
+  sensorLabelClasses: () => sensorLabelClasses,
+  vehicleClasses: () => vehicleClasses
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/backend-client.ts
+var import_client = require("@trpc/client");
+var import_superjson = __toESM(require("superjson"), 1);
+var BackendClient = class {
+  static {
+    __name(this, "BackendClient");
+  }
+  /** Raw tRPC client — for advanced usage / direct path access */
+  trpc;
+  serverUrl;
+  token;
+  wsClient = null;
+  constructor(config) {
+    this.serverUrl = config.serverUrl.replace(/\/+$/, "");
+    this.token = config.token;
+    const isBrowser = typeof window !== "undefined";
+    const useWs = config.useWebSocket ?? isBrowser;
+    const headers = /* @__PURE__ */ __name(() => {
+      const h = {};
+      if (this.token) {
+        h["Authorization"] = `Bearer ${this.token}`;
+      }
+      return h;
+    }, "headers");
+    if (useWs) {
+      const wsUrl = this.serverUrl.replace(/^http/, "ws") + "/trpc";
+      this.wsClient = (0, import_client.createWSClient)({
+        url: wsUrl,
+        connectionParams: /* @__PURE__ */ __name(() => ({
+          token: this.token
+        }), "connectionParams"),
+        retryDelayMs: /* @__PURE__ */ __name(() => 2e3, "retryDelayMs")
+      });
+      this.trpc = (0, import_client.createTRPCClient)({
+        links: [
+          (0, import_client.wsLink)({
+            client: this.wsClient,
+            transformer: import_superjson.default
+          })
+        ]
+      });
+    } else {
+      this.trpc = (0, import_client.createTRPCClient)({
+        links: [
+          (0, import_client.httpLink)({
+            url: `${this.serverUrl}/trpc`,
+            headers,
+            transformer: import_superjson.default
+          })
+        ]
+      });
+    }
+  }
+  /** Update the auth token (e.g. after login) */
+  setToken(token) {
+    this.token = token;
+  }
+  /** Close the WebSocket connection (if using WS transport) */
+  close() {
+    this.wsClient?.close();
+  }
+  // ─── Auth ──────────────────────────────────────────────────────────
+  async login(username, password) {
+    return this.trpc.auth.login.mutate({
+      username,
+      password
+    });
+  }
+  async getMe() {
+    return this.trpc.auth.me.query();
+  }
+  async logout() {
+    return this.trpc.auth.logout.mutate();
+  }
+  // ─── System ────────────────────────────────────────────────────────
+  async getSystemInfo() {
+    return this.trpc.system.info.query();
+  }
+  async getFeatureFlags() {
+    return this.trpc.system.featureFlags.query();
+  }
+  // ─── Providers ─────────────────────────────────────────────────────
+  async listProviders() {
+    return this.trpc.providers.list.query();
+  }
+  async getProvider(providerId) {
+    return this.trpc.providers.get.query({
+      id: providerId
+    });
+  }
+  async startProvider(providerId) {
+    return this.trpc.providers.start.mutate({
+      id: providerId
+    });
+  }
+  async stopProvider(providerId) {
+    return this.trpc.providers.stop.mutate({
+      id: providerId
+    });
+  }
+  async listProviderTypes() {
+    return this.trpc.providerConfig.getAvailableTypes.query();
+  }
+  // ─── Devices ───────────────────────────────────────────────────────
+  async listDevices() {
+    return this.trpc.devices.list.query();
+  }
+  async getDevice(deviceId) {
+    return this.trpc.devices.get.query({
+      id: deviceId
+    });
+  }
+  async discoverDevices(providerId) {
+    return this.trpc.devices.discoverDevices.query({
+      providerId
+    });
+  }
+  async adoptDevice(providerId, externalId) {
+    return this.trpc.devices.adoptDevice.mutate({
+      providerId,
+      externalId
+    });
+  }
+  async createDevice(providerId, config) {
+    return this.trpc.devices.createDevice.mutate({
+      providerId,
+      config
+    });
+  }
+  /** Returns the URL path for a static asset served by an addon. */
+  getAddonAssetUrl(addonId, assetPath) {
+    return `/api/addon-assets/${addonId}/${assetPath}`;
+  }
+  // ─── Addons ────────────────────────────────────────────────────────
+  async listAddons() {
+    return this.trpc.addons.list.query();
+  }
+  async getAddonConfigSchema(addonId) {
+    return this.trpc.addons.getConfigSchema.query({
+      addonId
+    });
+  }
+  async getAddonConfig(addonId) {
+    return this.trpc.addons.getConfig.query({
+      addonId
+    });
+  }
+  async updateAddonConfig(addonId, config) {
+    return this.trpc.addons.updateConfig.mutate({
+      addonId,
+      config
+    });
+  }
+  async getAddonLogs(addonId, options) {
+    return this.trpc.addons.getLogs.query({
+      addonId,
+      ...options
+    });
+  }
+  // ─── Known Faces ───────────────────────────────────────────────────
+  async listKnownFaces() {
+    return this.trpc.knownFaces.list.query();
+  }
+  async registerFace(label, cropBase64, group) {
+    return this.trpc.knownFaces.register.mutate({
+      label,
+      cropBase64,
+      group
+    });
+  }
+  // ─── Pipeline ──────────────────────────────────────────────────────
+  async listPipelines() {
+    return this.trpc.bridgePipeline.listAddons.query();
+  }
+  async getPipelineStatus(deviceId) {
+    return this.trpc.bridgePipeline.getPipeline.query({
+      deviceId
+    });
+  }
+  // ─── Agents ────────────────────────────────────────────────────────
+  async listAgents() {
+    return this.trpc.agents.listAgents.query();
+  }
+  async dispatchTask(agentId, task) {
+    return this.trpc.agents.dispatchTask.mutate({
+      capability: agentId,
+      input: task
+    });
+  }
+  async getProcessTree() {
+    return this.trpc.agent.processTree.query();
+  }
+  // ─── Bridge Pipeline ───────────────────────────────────────────────
+  async bridgeListAddons() {
+    return this.trpc.bridgePipeline.listAddons.query();
+  }
+  async bridgeGetPipeline(deviceId) {
+    return this.trpc.bridgePipeline.getPipeline.query({
+      deviceId
+    });
+  }
+  async bridgeSetPipeline(deviceId, config) {
+    return this.trpc.bridgePipeline.setPipeline.mutate({
+      deviceId,
+      config
+    });
+  }
+  async bridgeValidatePipeline(config) {
+    return this.trpc.bridgePipeline.validatePipeline.query(config);
+  }
+  async bridgeGetAddonConfig(addonId) {
+    return this.trpc.bridgePipeline.getAddonConfig.query({
+      addonId
+    });
+  }
+  async bridgeSetAddonConfig(addonId, config) {
+    return this.trpc.bridgePipeline.setAddonConfig.mutate({
+      addonId,
+      config
+    });
+  }
+  // ─── Bridge Addons ─────────────────────────────────────────────────
+  async bridgeListPackages() {
+    return this.trpc.bridgeAddons.listPackages.query();
+  }
+  async bridgeListAddonsPackages() {
+    return this.trpc.bridgeAddons.listAddons.query();
+  }
+  async bridgeInstallPackage(packageName, version) {
+    return this.trpc.bridgeAddons.installPackage.mutate({
+      packageName,
+      version
+    });
+  }
+  async bridgeUninstallPackage(packageName) {
+    return this.trpc.bridgeAddons.uninstallPackage.mutate({
+      packageName
+    });
+  }
+  // ─── Recording ─────────────────────────────────────────────────────
+  async getRecordingConfig(deviceId) {
+    return this.trpc.recording.getConfig.query({
+      deviceId
+    });
+  }
+  async getRecordingPolicy(deviceId) {
+    return this.trpc.recording.getPolicy.query({
+      deviceId
+    });
+  }
+  async getRecordingPolicyStatus(deviceId) {
+    return this.trpc.recording.getPolicyStatus.query({
+      deviceId
+    });
+  }
+  async getRecordingSegments(deviceId, streamId, startTime, endTime) {
+    return this.trpc.recording.getSegments.query({
+      deviceId,
+      streamId,
+      startTime,
+      endTime
+    });
+  }
+  // ─── Events ────────────────────────────────────────────────────────
+  async getEvents(deviceId, options) {
+    return this.trpc.events.query.query({
+      deviceId,
+      ...options
+    });
+  }
+  // ─── Logs ──────────────────────────────────────────────────────────
+  async getLogs(options) {
+    return this.trpc.logs.query.query(options ?? {});
+  }
+  // ─── REPL ──────────────────────────────────────────────────────────
+  async replEval(code, scope) {
+    return this.trpc.repl.execute.mutate({
+      code,
+      scope: scope ?? {
+        type: "system"
+      }
+    });
+  }
+  // ─── Users ─────────────────────────────────────────────────────────
+  async listUsers() {
+    return this.trpc.users.list.query();
+  }
+  async createUser(username, password, role) {
+    return this.trpc.users.create.mutate({
+      username,
+      password,
+      role
+    });
+  }
+  // ─── Session Tracker ───────────────────────────────────────────────
+  async getTrackingSessions(deviceId) {
+    return this.trpc.session.getActiveTracks.query({
+      deviceId
+    });
+  }
+  // ─── Processes ─────────────────────────────────────────────────────
+  async listProcesses() {
+    return this.trpc.processes.listProcesses.query();
+  }
+  async enableProvider(providerId) {
+    return this.trpc.processes.enableProvider.mutate({
+      id: providerId
+    });
+  }
+  async disableProvider(providerId) {
+    return this.trpc.processes.disableProvider.mutate({
+      id: providerId
+    });
+  }
+  // ─── Settings ──────────────────────────────────────────────────────
+  /** Fetch the UI schema for a single section, or all sections if omitted. */
+  async getSettingsSchema(section) {
+    return this.trpc.settings.getSchema.query({
+      section
+    });
+  }
+  async getSettings(section) {
+    return this.trpc.settings.get.query({
+      section
+    });
+  }
+  async updateSettings(section, data) {
+    return this.trpc.settings.update.mutate({
+      section,
+      data
+    });
+  }
+};
+function createBackendClient(config) {
+  return new BackendClient(config);
+}
+__name(createBackendClient, "createBackendClient");
+
+// src/detection.ts
+var DetectionClass = /* @__PURE__ */ (function(DetectionClass2) {
+  DetectionClass2["Motion"] = "motion";
+  DetectionClass2["Person"] = "person";
+  DetectionClass2["Vehicle"] = "vehicle";
+  DetectionClass2["Animal"] = "animal";
+  DetectionClass2["Audio"] = "audio";
+  DetectionClass2["Face"] = "face";
+  DetectionClass2["Plate"] = "plate";
+  DetectionClass2["Package"] = "package";
+  DetectionClass2["Doorbell"] = "doorbell";
+  DetectionClass2["Sensor"] = "sensor";
+  return DetectionClass2;
+})({});
+var animalClasses = [
+  "animal",
+  "dog_cat",
+  "dog",
+  "cat",
+  "horse",
+  "sheep",
+  "cow",
+  "elephant",
+  "bear",
+  "zebra",
+  "giraffe",
+  "mouse",
+  "rabbit",
+  "deer",
+  "lion",
+  "tiger",
+  "bird",
+  "eagle",
+  "owl",
+  "pigeon",
+  "fish",
+  "whale",
+  "dolphin",
+  "snake",
+  "turtle",
+  "lizard"
+];
+var personClasses = [
+  "person",
+  "people",
+  "pedestrian",
+  "rider",
+  "driver",
+  "cyclist",
+  "skier",
+  "skateboarder",
+  "face",
+  "hand",
+  "head",
+  "body"
+];
+var vehicleClasses = [
+  "vehicle",
+  "car",
+  "truck",
+  "bus",
+  "motorcycle",
+  "bicycle",
+  "van",
+  "ambulance",
+  "police_car",
+  "fire_truck",
+  "train",
+  "subway",
+  "tram",
+  "airplane",
+  "boat",
+  "ship",
+  "helicopter"
+];
+var faceClasses = [
+  "face",
+  "eyes",
+  "nose",
+  "mouth",
+  "ears",
+  "eyebrows",
+  "left_eye",
+  "right_eye",
+  "pupil",
+  "iris",
+  "eyelid",
+  "eye_corner",
+  "upper_lip",
+  "lower_lip",
+  "teeth",
+  "chin",
+  "cheek",
+  "forehead",
+  "jaw",
+  "glasses",
+  "sunglasses",
+  "facial_hair",
+  "beard",
+  "mustache",
+  "facial_landmark",
+  "facial_keypoint"
+];
+var licensePlateClasses = [
+  "plate",
+  "license_plate",
+  "front_plate",
+  "rear_plate",
+  "motorcycle_plate",
+  "temporary_plate",
+  "dealer_plate",
+  "licensePlate",
+  "plate_number",
+  "plate_character",
+  "plate_digit",
+  "plate_letter",
+  "plate_symbol",
+  "plate_region",
+  "plate_country_identifier",
+  "plate_frame",
+  "plate_bolt",
+  "plate_sticker",
+  "plate_validation_tag",
+  "damaged_plate",
+  "obscured_plate",
+  "dirty_plate"
+];
+var motionClasses = [
+  "motion",
+  "movement",
+  "other"
+];
+var packageClasses = [
+  "package",
+  "packet"
+];
+var audioClasses = [
+  "audio"
+];
+var audioLabelClasses = [
+  "speech",
+  "scream",
+  "babbling",
+  "yell",
+  "bellow",
+  "whoop",
+  "whispering",
+  "laughter",
+  "snicker",
+  "crying",
+  "cry",
+  "sigh",
+  "singing",
+  "choir",
+  "chant",
+  "mantra",
+  "child_singing",
+  "rapping",
+  "humming",
+  "groan",
+  "grunt",
+  "whistling",
+  "breathing",
+  "wheeze",
+  "snoring",
+  "gasp",
+  "pant",
+  "snort",
+  "cough",
+  "throat_clearing",
+  "sneeze",
+  "sniff",
+  "cheering",
+  "applause",
+  "chatter",
+  "crowd",
+  "children_playing",
+  "bark",
+  "yip",
+  "howl",
+  "bow-wow",
+  "growling",
+  "whimper_dog",
+  "purr",
+  "meow",
+  "hiss",
+  "caterwaul",
+  "pets",
+  "livestock",
+  "doorbell",
+  "ding-dong",
+  "door",
+  "slam",
+  "knock",
+  "alarm",
+  "telephone",
+  "music",
+  "dog",
+  "dogs"
+];
+var doorbellClasses = [
+  "doorbell",
+  "ring"
+];
+var sensorLabelClasses = [
+  "lock",
+  "binary",
+  "flood",
+  "entry",
+  "door",
+  "leak",
+  "door_open",
+  "flooded",
+  "entry_open"
+];
+var detectionClassesDefaultMap = {
+  ...animalClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "animal"
+  }), {}),
+  ...personClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "person"
+  }), {}),
+  ...vehicleClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "vehicle"
+  }), {}),
+  ...motionClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "motion"
+  }), {}),
+  ...packageClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "package"
+  }), {}),
+  ...faceClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "face"
+  }), {}),
+  ...licensePlateClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "plate"
+  }), {}),
+  ...audioClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "audio"
+  }), {}),
+  ...audioLabelClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "audio"
+  }), {}),
+  ...doorbellClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "doorbell"
+  }), {}),
+  ...sensorLabelClasses.reduce((tot, curr) => ({
+    ...tot,
+    [curr]: "sensor"
+  }), {})
+};
+var isFaceClassname = /* @__PURE__ */ __name((c) => faceClasses.includes(c), "isFaceClassname");
+var isPlateClassname = /* @__PURE__ */ __name((c) => licensePlateClasses.includes(c), "isPlateClassname");
+var isAnimalClassname = /* @__PURE__ */ __name((c) => animalClasses.includes(c), "isAnimalClassname");
+var isPersonClassname = /* @__PURE__ */ __name((c) => personClasses.includes(c), "isPersonClassname");
+var isVehicleClassname = /* @__PURE__ */ __name((c) => vehicleClasses.includes(c), "isVehicleClassname");
+var isMotionClassname = /* @__PURE__ */ __name((c) => motionClasses.includes(c), "isMotionClassname");
+var isDoorbellClassname = /* @__PURE__ */ __name((c) => doorbellClasses.includes(c), "isDoorbellClassname");
+var isPackageClassname = /* @__PURE__ */ __name((c) => packageClasses.includes(c), "isPackageClassname");
+var isAudioClassname = /* @__PURE__ */ __name((c) => audioClasses.includes(c) || audioLabelClasses.includes(c), "isAudioClassname");
+var isSensorLabelClassname = /* @__PURE__ */ __name((c) => sensorLabelClasses.includes(c), "isSensorLabelClassname");
+var isLabelDetection = /* @__PURE__ */ __name((c) => isFaceClassname(c) || isPlateClassname(c), "isLabelDetection");
+var getParentClass = /* @__PURE__ */ __name((className) => detectionClassesDefaultMap[className], "getParentClass");
+var getParentDetectionClass = /* @__PURE__ */ __name((det) => {
+  const { className } = det;
+  const baseMap = {
+    ["face"]: "person",
+    ["plate"]: "vehicle"
+  };
+  const parentGroup = detectionClassesDefaultMap[className];
+  if (parentGroup && parentGroup !== className) return parentGroup;
+  return baseMap[className];
+}, "getParentDetectionClass");
+var defaultDetectionClasses = Object.values(DetectionClass);
+var DEFAULT_ENABLED_CLASSES = defaultDetectionClasses.filter((c) => c !== "motion");
+var TIMELINE_PRESET_CRITICAL = [
+  "person",
+  "doorbell",
+  "package"
+];
+var TIMELINE_PRESET_IMPORTANT = [
+  ...TIMELINE_PRESET_CRITICAL,
+  "vehicle",
+  "animal",
+  "audio",
+  "face",
+  "plate"
+];
+var TIMELINE_PRESET_ALL = [
+  ...DEFAULT_ENABLED_CLASSES
+];
+function getClassesForTimelinePreset(preset, customClasses) {
+  switch (preset) {
+    case "critical":
+      return TIMELINE_PRESET_CRITICAL;
+    case "important":
+      return TIMELINE_PRESET_IMPORTANT;
+    case "all":
+      return TIMELINE_PRESET_ALL;
+    case "custom":
+      return customClasses?.length ? customClasses : DEFAULT_ENABLED_CLASSES;
+    default:
+      return DEFAULT_ENABLED_CLASSES;
+  }
+}
+__name(getClassesForTimelinePreset, "getClassesForTimelinePreset");
+
+// src/devices.ts
+var RAW_TO_CANONICAL = {
+  // Scrypted PascalCase
+  Light: "light",
+  Switch: "switch",
+  WindowCovering: "cover",
+  Lock: "lock",
+  SecuritySystem: "alarm",
+  Buttons: "button",
+  Select: "select",
+  Siren: "siren",
+  Sensor: "sensor",
+  Entry: "entry",
+  Program: "script",
+  MediaPlayer: "media_player",
+  Outlet: "switch",
+  // Home Assistant lowercase domains
+  light: "light",
+  switch: "switch",
+  input_boolean: "switch",
+  cover: "cover",
+  lock: "lock",
+  alarm_control_panel: "alarm",
+  input_button: "button",
+  button: "button",
+  input_select: "select",
+  select: "select",
+  siren: "siren",
+  sensor: "sensor",
+  media_player: "media_player",
+  script: "script"
+};
+var HA_DOMAIN_TYPE_MAP = {
+  light: "light",
+  switch: "switch",
+  input_boolean: "switch",
+  cover: "cover",
+  lock: "lock",
+  alarm_control_panel: "alarm",
+  input_button: "button",
+  button: "button",
+  input_select: "select",
+  select: "select",
+  siren: "siren",
+  sensor: "sensor",
+  binary_sensor: "sensor",
+  media_player: "media_player",
+  script: "script",
+  climate: "climate",
+  camera: "camera",
+  fan: "fan",
+  vacuum: "vacuum",
+  automation: "automation",
+  scene: "scene",
+  input_number: "sensor",
+  person: "person",
+  device_tracker: "tracker",
+  weather: "weather",
+  water_heater: "climate"
+};
+var SCRYPTED_TYPE_TO_CANONICAL = {
+  Light: "light",
+  Switch: "switch",
+  WindowCovering: "cover",
+  Lock: "lock",
+  SecuritySystem: "alarm",
+  Buttons: "button",
+  Select: "select",
+  Siren: "siren",
+  Sensor: "sensor",
+  Entry: "entry",
+  Program: "script",
+  MediaPlayer: "media_player",
+  Camera: "camera",
+  Doorbell: "doorbell",
+  Fan: "fan",
+  Outlet: "switch"
+};
+function getCanonicalDeviceType(rawType) {
+  const canonical = RAW_TO_CANONICAL[rawType];
+  if (canonical) return canonical;
+  const lower = rawType.toLowerCase();
+  return RAW_TO_CANONICAL[lower] ?? null;
+}
+__name(getCanonicalDeviceType, "getCanonicalDeviceType");
+var ELIGIBLE_SCRYPTED_DEVICE_TYPES = [
+  "Entry",
+  "Light",
+  "Switch",
+  "Lock",
+  "SecuritySystem",
+  "Buttons",
+  "WindowCovering",
+  "Siren",
+  "Sensor",
+  "Select",
+  "Program"
+];
+var ELIGIBLE_SCRYPTED_DEVICE_TYPES_SET = new Set(ELIGIBLE_SCRYPTED_DEVICE_TYPES);
+var ELIGIBLE_HA_DOMAINS = [
+  "light",
+  "switch",
+  "input_boolean",
+  "cover",
+  "lock",
+  "alarm_control_panel",
+  "input_button",
+  "button",
+  "input_select",
+  "select",
+  "siren",
+  "media_player",
+  "script"
+];
+var ELIGIBLE_HA_DOMAINS_SET = new Set(ELIGIBLE_HA_DOMAINS);
+
+// src/features.ts
+var FEATURE_MATRIX = [
+  {
+    id: "liveStream",
+    label: "Live Stream",
+    sources: {
+      frigate: true,
+      scrypted: true,
+      rtsp: true
+    },
+    adapterMethod: "getLiveStream"
+  },
+  {
+    id: "multiResolution",
+    label: "Multi-Resolution",
+    sources: {
+      frigate: true,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "getResolutions"
+  },
+  {
+    id: "motion",
+    label: "Motion Detection",
+    sources: {
+      frigate: false,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "getMotion"
+  },
+  {
+    id: "objectDetection",
+    label: "Object Detection",
+    sources: {
+      frigate: false,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "getObjectDetections"
+  },
+  {
+    id: "audioVolume",
+    label: "Audio Level",
+    sources: {
+      frigate: false,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "getAudioVolume"
+  },
+  {
+    id: "audioVolumes",
+    label: "Audio Volumes (dBFS)",
+    sources: {
+      frigate: false,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "getAudioVolumes"
+  },
+  {
+    id: "ptz",
+    label: "PTZ Control",
+    sources: {
+      frigate: false,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "getPTZ"
+  },
+  {
+    id: "intercom",
+    label: "Intercom (Mic)",
+    sources: {
+      frigate: false,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "getIntercomSupport"
+  },
+  {
+    id: "deviceStatus",
+    label: "Device Status",
+    sources: {
+      frigate: false,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "getStatus"
+  },
+  {
+    id: "timeline",
+    label: "Detection Timeline",
+    sources: {
+      frigate: true,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "getCameraDayData"
+  },
+  {
+    id: "clusteredTimeline",
+    label: "Clustered Timeline",
+    sources: {
+      frigate: true,
+      scrypted: true,
+      rtsp: false
+    },
+    requiresBackend: true,
+    adapterMethod: "getClusteredDayData"
+  },
+  {
+    id: "detectionClasses",
+    label: "Detection Classes",
+    sources: {
+      frigate: true,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "getDetectionClasses"
+  },
+  {
+    id: "videoClips",
+    label: "Video Clips",
+    sources: {
+      frigate: true,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "getVideoClips"
+  },
+  {
+    id: "nvrPlayback",
+    label: "NVR Playback",
+    sources: {
+      frigate: true,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "getNvrPlaybackSupported"
+  },
+  {
+    id: "nvrScrub",
+    label: "NVR Scrub/Seek",
+    sources: {
+      frigate: false,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "seekRecordingStream"
+  },
+  {
+    id: "recordingThumbnail",
+    label: "Recording Thumbnails",
+    sources: {
+      frigate: true,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "getRecordingStreamThumbnail"
+  },
+  {
+    id: "nvrSeekToLive",
+    label: "Seek to Live",
+    sources: {
+      frigate: false,
+      scrypted: true,
+      rtsp: false
+    },
+    adapterMethod: "seekNvrToLive"
+  }
+];
+function isFeatureAvailable(featureId, source, platform) {
+  const entry = FEATURE_MATRIX.find((f) => f.id === featureId);
+  if (!entry) return false;
+  if (!entry.sources[source]) return false;
+  if (entry.platforms && entry.platforms[platform] === false) return false;
+  return true;
+}
+__name(isFeatureAvailable, "isFeatureAvailable");
+function getSourceFeatures(source) {
+  return FEATURE_MATRIX.filter((f) => f.sources[source]);
+}
+__name(getSourceFeatures, "getSourceFeatures");
+function getBackendRequiredFeatures() {
+  return FEATURE_MATRIX.filter((f) => f.requiresBackend);
+}
+__name(getBackendRequiredFeatures, "getBackendRequiredFeatures");
+
+// src/adaptive-stream.ts
+function selectOptimalStream(streams, constraints, defaultTransport) {
+  if (streams.length === 0) return null;
+  const viewportPixels = constraints.viewportWidth * constraints.viewportHeight * (constraints.pixelRatio ?? 1);
+  const bw = constraints.bandwidthMbps ?? 100;
+  const loss = constraints.packetLoss ?? 0;
+  const rtt = constraints.rttMs ?? 50;
+  let targetTier = "high";
+  if (constraints.maxResolution === "low" || constraints.isCellular || bw < 1 || loss > 0.05) {
+    targetTier = "low";
+  } else if (constraints.maxResolution === "medium" || bw < 5 || viewportPixels < 5e5 || rtt > 200) {
+    targetTier = "medium";
+  } else if (constraints.maxResolution === "high" || viewportPixels > 2e6) {
+    targetTier = "high";
+  }
+  const PROFILE_TIER = {
+    main: "high",
+    sub: "medium",
+    ext: "low"
+  };
+  const preferTransport = defaultTransport ?? "native";
+  const scored = streams.map((s) => {
+    let score = 0;
+    const streamTier = PROFILE_TIER[s.profile] ?? "medium";
+    if (streamTier === targetTier) score += 100;
+    else if (targetTier === "high" && streamTier === "medium" || targetTier === "medium" && streamTier === "high" || targetTier === "medium" && streamTier === "low" || targetTier === "low" && streamTier === "medium") score += 50;
+    if (s.transport === preferTransport) score += 30;
+    else if (s.transport === "native") score += 20;
+    else if (s.transport === "rtsp") score += 15;
+    else if (s.transport === "rtmp") score += 10;
+    if (s.metadata?.width && s.metadata?.height) {
+      const streamPixels = s.metadata.width * s.metadata.height;
+      const ratio = streamPixels / Math.max(viewportPixels, 1);
+      if (ratio >= 0.8 && ratio <= 2) score += 25;
+      else if (ratio >= 0.5 && ratio <= 3) score += 15;
+      if (ratio > 4 && bw < 10) score -= 20;
+    }
+    if (s.metadata?.codec) {
+      if (bw < 5 && s.metadata.codec.includes("265")) score += 10;
+      if (bw >= 10 && s.metadata.codec.includes("264")) score += 5;
+    }
+    return {
+      ...s,
+      score,
+      targetTier
+    };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  const best = scored[0];
+  const tierNames = {
+    high: "main",
+    medium: "sub",
+    low: "ext"
+  };
+  return {
+    streamName: best.streamName,
+    profile: best.profile,
+    transport: best.transport,
+    label: best.label,
+    metadata: best.metadata,
+    reason: `${best.targetTier} quality \u2192 ${best.profile}/${best.transport} (score: ${best.score})`
+  };
+}
+__name(selectOptimalStream, "selectOptimalStream");
+function getNextEvalInterval(constraints, wasSwitch) {
+  if (wasSwitch) return 10;
+  if (constraints.isCellular) return 15;
+  if ((constraints.packetLoss ?? 0) > 0.02) return 15;
+  return 30;
+}
+__name(getNextEvalInterval, "getNextEvalInterval");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BackendClient,
+  DEFAULT_ENABLED_CLASSES,
+  DetectionClass,
+  ELIGIBLE_HA_DOMAINS,
+  ELIGIBLE_HA_DOMAINS_SET,
+  ELIGIBLE_SCRYPTED_DEVICE_TYPES,
+  ELIGIBLE_SCRYPTED_DEVICE_TYPES_SET,
+  FEATURE_MATRIX,
+  HA_DOMAIN_TYPE_MAP,
+  RAW_TO_CANONICAL,
+  SCRYPTED_TYPE_TO_CANONICAL,
+  TIMELINE_PRESET_ALL,
+  TIMELINE_PRESET_CRITICAL,
+  TIMELINE_PRESET_IMPORTANT,
+  animalClasses,
+  audioClasses,
+  audioLabelClasses,
+  createBackendClient,
+  defaultDetectionClasses,
+  detectionClassesDefaultMap,
+  doorbellClasses,
+  faceClasses,
+  getBackendRequiredFeatures,
+  getCanonicalDeviceType,
+  getClassesForTimelinePreset,
+  getNextEvalInterval,
+  getParentClass,
+  getParentDetectionClass,
+  getSourceFeatures,
+  isAnimalClassname,
+  isAudioClassname,
+  isDoorbellClassname,
+  isFaceClassname,
+  isFeatureAvailable,
+  isLabelDetection,
+  isMotionClassname,
+  isPackageClassname,
+  isPersonClassname,
+  isPlateClassname,
+  isSensorLabelClassname,
+  isVehicleClassname,
+  licensePlateClasses,
+  motionClasses,
+  packageClasses,
+  personClasses,
+  selectOptimalStream,
+  sensorLabelClasses,
+  vehicleClasses
+});
+//# sourceMappingURL=index.cjs.map