@camstack/core 0.1.13 → 0.1.15

package/dist/index.mjs

@@ -1,259 +1,85 @@
+import "./chunk-2QUFBZ7M.mjs";
+import {
+  DeviceManagerAddon
+} from "./chunk-O4V246GG.mjs";
+import "./chunk-TDYPZXK5.mjs";
+import {
+  ApiKeyManager,
+  AuthManager,
+  LocalAuthAddon,
+  ScopedTokenManager,
+  UserManager
+} from "./chunk-3BK2Y7GY.mjs";
+import {
+  getPidStats,
+  getSinglePidStats
+} from "./chunk-GL4OOB25.mjs";
+import {
+  FsStorageBackend,
+  StorageLocationManager
+} from "./chunk-6M2HSSTQ.mjs";
+import {
+  NativeMetricsAddon,
+  NativeMetricsProvider
+} from "./chunk-4XHB7IHT.mjs";
+import "./chunk-2CIYKDRN.mjs";
+import {
+  AlertCenterAddon
+} from "./chunk-4OOHFJHT.mjs";
+import "./chunk-W6RTHQGP.mjs";
+import {
+  SystemConfigAddon
+} from "./chunk-QT57H266.mjs";
 import {
   CORE_TABLE_DDL,
-  FileSystemStorage,
+  ConfigStore,
+  DeviceStore,
+  FilesystemStorageProvider,
   SettingsStore,
-  SqliteStorageAddon,
-  SqliteStorageProvider,
   addonTableToDdl
-} from "./chunk-R3DIIBBX.mjs";
-import "./chunk-SPA4JBKN.mjs";
-import "./chunk-SMNR44VG.mjs";
+} from "./chunk-ZELBCPDC.mjs";
+import {
+  FilesystemStorageAddon
+} from "./chunk-UJI4LN5P.mjs";
+import {
+  SqliteSettingsAddon,
+  SqliteSettingsBackend
+} from "./chunk-FZN56HGQ.mjs";
 import {
   WinstonDestination,
   WinstonLoggingAddon
-} from "./chunk-LQFPAEQF.mjs";
+} from "./chunk-KDG2NTDB.mjs";
+import {
+  ConsoleDestination,
+  ConsoleLoggingAddon
+} from "./chunk-TB562PZX.mjs";
+import {
+  HubForwarderAddon,
+  HubForwarderDestination
+} from "./chunk-QX4RH25I.mjs";
+import {
+  formatLogLine
+} from "./chunk-2F76X6NL.mjs";
 import {
   LocalBackupAddon,
   LocalBackupService
-} from "./chunk-SO4LROOT.mjs";
-import {
-  FsStorageBackend,
-  StorageLocationManager
-} from "./chunk-2F3XZYRW.mjs";
-
-// src/deps/binary-downloader.ts
-import { existsSync, mkdirSync, chmodSync, createWriteStream, unlinkSync } from "fs";
-import { join } from "path";
-import { pipeline } from "stream/promises";
-import { Readable } from "stream";
-import { execFileSync } from "child_process";
-function getPlatformInfo() {
-  return {
-    platform: process.platform,
-    arch: process.arch
-  };
-}
-function buildBinaryPath(dataDir, name, platform2) {
-  const ext = (platform2 ?? process.platform) === "win32" ? ".exe" : "";
-  return join(dataDir, "deps", `${name}${ext}`);
-}
-function findInPath(name) {
-  try {
-    execFileSync(name, ["--version"], { stdio: "pipe", timeout: 5e3 });
-    return name;
-  } catch {
-    return null;
-  }
-}
-async function downloadBinary(opts) {
-  const { name, url, targetDir, targetName, logger, isArchive, archiveFormat, archiveInnerPath } = opts;
-  const targetPath = join(targetDir, targetName);
-  if (existsSync(targetPath)) {
-    logger.debug(`${name} binary already exists at ${targetPath}`);
-    return targetPath;
-  }
-  mkdirSync(targetDir, { recursive: true });
-  logger.info(`Downloading ${name} from ${url}`);
-  const response = await fetch(url, { redirect: "follow" });
-  if (!response.ok || !response.body) {
-    throw new Error(`Failed to download ${name}: ${response.status} ${response.statusText}`);
-  }
-  if (isArchive) {
-    const ext = archiveFormat ?? "tar.gz";
-    const tmpArchive = join(targetDir, `${name}-download.${ext}`);
-    const nodeStream = Readable.fromWeb(response.body);
-    await pipeline(nodeStream, createWriteStream(tmpArchive));
-    const tmpExtractDir = join(targetDir, `${name}-extract`);
-    mkdirSync(tmpExtractDir, { recursive: true });
-    if (ext === "zip") {
-      try {
-        execFileSync("unzip", ["-o", "-q", tmpArchive, "-d", tmpExtractDir], { stdio: "pipe" });
-      } catch {
-        execFileSync("tar", ["-xf", tmpArchive, "-C", tmpExtractDir], { stdio: "pipe" });
-      }
-    } else if (ext === "tar.xz") {
-      execFileSync("tar", ["-xJf", tmpArchive, "-C", tmpExtractDir], { stdio: "pipe" });
-    } else {
-      execFileSync("tar", ["-xzf", tmpArchive, "-C", tmpExtractDir], { stdio: "pipe" });
-    }
-    if (archiveInnerPath) {
-      const { copyFileSync } = await import("fs");
-      const sourcePath = join(tmpExtractDir, archiveInnerPath);
-      if (!existsSync(sourcePath)) {
-        throw new Error(`Binary not found in archive at ${archiveInnerPath}`);
-      }
-      copyFileSync(sourcePath, targetPath);
-    }
-    unlinkSync(tmpArchive);
-    const { rmSync: rmSync2 } = await import("fs");
-    rmSync2(tmpExtractDir, { recursive: true, force: true });
-  } else {
-    const nodeStream = Readable.fromWeb(response.body);
-    await pipeline(nodeStream, createWriteStream(targetPath));
-  }
-  chmodSync(targetPath, 493);
-  logger.info(`${name} downloaded to ${targetPath}`);
-  return targetPath;
-}
-async function ensureBinary(opts) {
-  const ext = process.platform === "win32" ? ".exe" : "";
-  const targetName = `${opts.name}${ext}`;
-  const targetPath = join(opts.targetDir, targetName);
-  if (existsSync(targetPath)) {
-    opts.logger.debug(`${opts.name} found at ${targetPath}`);
-    return targetPath;
-  }
-  const inPath = findInPath(opts.name);
-  if (inPath) {
-    opts.logger.info(`${opts.name} found in system PATH`);
-    return inPath;
-  }
-  return downloadBinary({
-    name: opts.name,
-    url: opts.downloadUrl,
-    targetDir: opts.targetDir,
-    targetName,
-    logger: opts.logger,
-    isArchive: opts.isArchive,
-    archiveFormat: opts.archiveFormat,
-    archiveInnerPath: opts.archiveInnerPath
-  });
-}
-
-// src/deps/ffmpeg-downloader.ts
-import { join as join2 } from "path";
-var FFMPEG_VERSION = "7.1";
-function getFfmpegDownloadUrl(platform2, arch2) {
-  switch (platform2) {
-    case "linux": {
-      const archMap = { x64: "amd64", arm64: "arm64" };
-      const a = archMap[arch2];
-      if (!a) throw new Error(`Unsupported Linux architecture: ${arch2}`);
-      return `https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-${a}-static.tar.xz`;
-    }
-    case "darwin": {
-      const archMap = { arm64: "arm64", x64: "amd64" };
-      const a = archMap[arch2];
-      if (!a) throw new Error(`Unsupported macOS architecture: ${arch2}`);
-      return `https://www.osxexperts.net/ffmpeg${FFMPEG_VERSION.replace(".", "")}arm.zip`;
-    }
-    default:
-      throw new Error(`Unsupported platform: ${platform2}`);
-  }
-}
-function getFfmpegArchiveInfo(platform2) {
-  switch (platform2) {
-    case "linux":
-      return {
-        isArchive: true,
-        archiveFormat: "tar.xz",
-        archiveInnerPath: `ffmpeg-${FFMPEG_VERSION}-amd64-static/ffmpeg`
-      };
-    case "darwin":
-      return {
-        isArchive: true,
-        archiveFormat: "zip",
-        archiveInnerPath: "ffmpeg"
-      };
-    default:
-      throw new Error(`Unsupported platform: ${platform2}`);
-  }
-}
-async function ensureFfmpeg(dataDir, logger) {
-  const depsDir = join2(dataDir, "deps");
-  const platform2 = process.platform;
-  const arch2 = process.arch;
-  const archiveInfo = getFfmpegArchiveInfo(platform2);
-  return ensureBinary({
-    name: "ffmpeg",
-    targetDir: depsDir,
-    downloadUrl: getFfmpegDownloadUrl(platform2, arch2),
-    logger,
-    ...archiveInfo
-  });
-}
+} from "./chunk-7FI7SQS7.mjs";
 
-// src/deps/python-downloader.ts
-import { join as join3 } from "path";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, chmodSync as chmodSync2 } from "fs";
-import { execFileSync as execFileSync2 } from "child_process";
-import { pipeline as pipeline2 } from "stream/promises";
-import { Readable as Readable2 } from "stream";
-import { createWriteStream as createWriteStream2 } from "fs";
-var PYTHON_VERSION = "3.12.12";
-var PP_BASE = `https://github.com/bjia56/portable-python/releases/download/cpython-v${PYTHON_VERSION}-build.0`;
-function getPythonDownloadUrl(platform2, arch2) {
-  switch (platform2) {
-    case "linux": {
-      const archMap = { x64: "x86_64", arm64: "aarch64" };
-      const a = archMap[arch2];
-      if (!a) throw new Error(`Unsupported Linux architecture for Python: ${arch2}`);
-      return `${PP_BASE}/python-headless-${PYTHON_VERSION}-linux-${a}.zip`;
-    }
-    case "darwin": {
-      return `${PP_BASE}/python-headless-${PYTHON_VERSION}-darwin-universal2.zip`;
-    }
-    default:
-      throw new Error(`Unsupported platform for portable Python: ${platform2}`);
-  }
-}
-async function ensurePython(dataDir, logger) {
-  const pythonDir = join3(dataDir, "deps", "python");
-  const pythonBin = join3(pythonDir, "bin", "python3");
-  if (existsSync2(pythonBin)) {
-    logger.debug(`Portable Python found at ${pythonBin}`);
-    return pythonBin;
-  }
-  for (const name of ["python3", "python"]) {
-    const inPath = findInPath(name);
-    if (inPath) {
-      logger.info(`Python found in system PATH: ${name}`);
-      return inPath;
-    }
-  }
-  logger.info(`Downloading portable Python ${PYTHON_VERSION} (headless)...`);
-  const depsDir = join3(dataDir, "deps");
-  mkdirSync2(depsDir, { recursive: true });
-  const url = getPythonDownloadUrl(process.platform, process.arch);
-  const tmpArchive = join3(depsDir, "python-download.zip");
-  logger.info(`  Source: ${url}`);
-  const response = await fetch(url, { redirect: "follow" });
-  if (!response.ok || !response.body) {
-    logger.warn(`Failed to download Python: ${response.status} \u2014 ML detection will not be available`);
-    return null;
-  }
-  const nodeStream = Readable2.fromWeb(response.body);
-  await pipeline2(nodeStream, createWriteStream2(tmpArchive));
-  try {
-    execFileSync2("unzip", ["-o", "-q", tmpArchive, "-d", depsDir], { stdio: "pipe" });
-  } catch {
-    execFileSync2("python3", ["-m", "zipfile", "-e", tmpArchive, depsDir], { stdio: "pipe" });
-  }
-  const { unlinkSync: unlinkSync3 } = await import("fs");
-  unlinkSync3(tmpArchive);
-  if (!existsSync2(pythonBin)) {
-    logger.warn("Python extraction succeeded but binary not found at expected path");
-    return null;
-  }
-  chmodSync2(pythonBin, 493);
-  logger.info(`Portable Python ${PYTHON_VERSION} installed at ${pythonBin}`);
-  return pythonBin;
-}
-async function installPythonPackages(pythonPath, packages, logger) {
-  if (packages.length === 0) return;
-  logger.info(`Installing Python packages: ${packages.join(", ")}`);
-  try {
-    execFileSync2(pythonPath, ["-m", "pip", "install", "--quiet", ...packages], {
-      stdio: "pipe",
-      timeout: 3e5
-      // 5 minutes for large packages like torch
-    });
-    logger.info("Python packages installed successfully");
-  } catch (err) {
-    logger.error(`Failed to install Python packages: ${err instanceof Error ? err.message : err}`);
-    throw err;
-  }
-}
+// src/index.ts
+import {
+  ensureBinary,
+  downloadBinary,
+  findInPath,
+  getPlatformInfo,
+  buildBinaryPath,
+  ensureFfmpeg,
+  getFfmpegDownloadUrl,
+  ensurePython,
+  installPythonPackages,
+  installPythonRequirements,
+  getPythonDownloadUrl,
+  PYTHON_VERSION
+} from "@camstack/types/node";
 
 // src/events/event-bus.ts
 var EventBus = class {
@@ -324,7 +150,7 @@ async function downloadFile(url, destPath, onProgress) {
     try {
       for (; ; ) {
         const { done, value } = await reader.read();
-        if (done) break;
+        if (done || !value) break;
         fileStream.write(value);
         downloaded += value.length;
         onProgress?.(downloaded, total);
@@ -370,10 +196,10 @@ async function downloadModel(options) {
     try {
       await downloadFile(tryUrl, destPath, onProgress);
       if (expectedSha256) {
-        const hash2 = await computeSha256(destPath);
-        if (hash2 !== expectedSha256) {
+        const hash = await computeSha256(destPath);
+        if (hash !== expectedSha256) {
           fs.unlinkSync(destPath);
-          throw new Error(`SHA256 mismatch: expected ${expectedSha256}, got ${hash2}`);
+          throw new Error(`SHA256 mismatch: expected ${expectedSha256}, got ${hash}`);
         }
       }
       const stat = fs.statSync(destPath);
@@ -387,13 +213,102 @@ async function downloadModel(options) {
 }
 async function computeSha256(filePath) {
   return new Promise((resolve, reject) => {
-    const hash2 = createHash("sha256");
+    const hash = createHash("sha256");
     const stream = fs.createReadStream(filePath);
-    stream.on("data", (chunk) => hash2.update(chunk));
-    stream.on("end", () => resolve(hash2.digest("hex")));
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
     stream.on("error", reject);
   });
 }
+async function downloadDirectory(url, destDir, knownFiles, onProgress) {
+  const match = url.match(/huggingface\.co\/([^/]+\/[^/]+)\/resolve\/main\/(.+)/);
+  if (!match) throw new Error(`Cannot parse HuggingFace URL: ${url}`);
+  const [, repo, dirPath] = match;
+  const files = (knownFiles ?? []).map((f) => ({
+    relativePath: f,
+    fileUrl: `https://huggingface.co/${repo}/resolve/main/${dirPath}/${f}`
+  }));
+  if (files.length === 0) {
+    throw new Error(`Directory bundle requires explicit \`files\` list (got none for ${url})`);
+  }
+  const tmpDir = destDir + ".downloading";
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+  fs.mkdirSync(tmpDir, { recursive: true });
+  let totalDownloaded = 0;
+  try {
+    for (const file of files) {
+      const destPath = path.join(tmpDir, file.relativePath);
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      await downloadFile(file.fileUrl, destPath, (downloaded, _total) => {
+        onProgress?.(totalDownloaded + downloaded, void 0);
+      });
+      totalDownloaded += fs.statSync(destPath).size;
+    }
+    fs.rmSync(destDir, { recursive: true, force: true });
+    fs.renameSync(tmpDir, destDir);
+  } catch (err) {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    throw err;
+  }
+}
+async function ensureModel(modelsDir, entry, format, onProgress) {
+  const formatEntry = entry.formats[format];
+  if (!formatEntry) {
+    throw new Error(
+      `Model "${entry.id}" has no ${format} format. Available: ${Object.keys(entry.formats).join(", ")}`
+    );
+  }
+  if (entry.extraFiles) {
+    for (const extra of entry.extraFiles) {
+      await downloadFile(extra.url, path.join(modelsDir, extra.filename));
+    }
+  }
+  const filename = formatEntry.url.split("/").pop() ?? `${entry.id}.${format}`;
+  const modelPath = path.join(modelsDir, filename);
+  if (fs.existsSync(modelPath)) {
+    if (formatEntry.isDirectory && !fs.existsSync(path.join(modelPath, "Manifest.json"))) {
+      fs.rmSync(modelPath, { recursive: true, force: true });
+    } else {
+      return modelPath;
+    }
+  }
+  fs.mkdirSync(modelsDir, { recursive: true });
+  if (formatEntry.isDirectory) {
+    await downloadDirectory(formatEntry.url, modelPath, formatEntry.files, onProgress);
+  } else {
+    await downloadFile(
+      formatEntry.url,
+      modelPath,
+      (downloaded, total) => onProgress?.(downloaded, total === 0 ? void 0 : total)
+    );
+  }
+  return modelPath;
+}
+function getModelFilePath(modelsDir, entry, format) {
+  const formatEntry = entry.formats[format];
+  if (!formatEntry) return null;
+  const filename = formatEntry.url.split("/").pop() ?? `${entry.id}.${format}`;
+  return path.join(modelsDir, filename);
+}
+function isModelDownloaded(modelsDir, entry, format) {
+  const formatEntry = entry.formats[format];
+  if (!formatEntry) return false;
+  const modelPath = getModelFilePath(modelsDir, entry, format);
+  if (!modelPath || !fs.existsSync(modelPath)) return false;
+  if (formatEntry.isDirectory) return fs.existsSync(path.join(modelPath, "Manifest.json"));
+  return fs.statSync(modelPath).size > 0;
+}
+function deleteModelFromDisk(modelsDir, entry, format) {
+  const modelPath = getModelFilePath(modelsDir, entry, format);
+  if (!modelPath || !fs.existsSync(modelPath)) return false;
+  const formatEntry = entry.formats[format];
+  if (formatEntry?.isDirectory) {
+    fs.rmSync(modelPath, { recursive: true, force: true });
+  } else {
+    fs.unlinkSync(modelPath);
+  }
+  return true;
+}
 
 // src/download/model-download-service.ts
 import * as fs2 from "fs";
@@ -408,6 +323,8 @@ var ModelDownloadService = class {
     }
     this.catalog = map;
   }
+  modelsDir;
+  onProgress;
   catalog;
   /**
    * Ensure a model (and its extra files) is downloaded.
@@ -492,13 +409,6 @@ var ModelDownloadService = class {
     }
     return fs2.statSync(modelPath).size > 0;
   }
-  /**
-   * Legacy API: download a model by ID (delegates to ensure with default format).
-   * Required by IAddonModelManager interface.
-   */
-  async downloadModel(id) {
-    return this.ensure(id);
-  }
   /** Get the catalog entry for a model by ID. */
   getEntry(modelId) {
     return this.catalog.get(modelId);
@@ -528,7 +438,7 @@ var ModelDownloadService = class {
    * Download a directory bundle (e.g., .mlpackage) from HuggingFace.
    * ATOMIC: downloads to temp dir, renames only on complete success.
    */
-  async downloadDirectory(url, destDir, knownFiles, modelId) {
+  async downloadDirectory(url, destDir, knownFiles, _modelId) {
     const match = url.match(/huggingface\.co\/([^/]+\/[^/]+)\/resolve\/main\/(.+)/);
     if (!match) throw new Error(`Cannot parse HuggingFace URL: ${url}`);
     const [, repo, dirPath] = match;
@@ -588,12 +498,11 @@ import * as fs3 from "fs";
 import * as path3 from "path";
 var execFileAsync = promisify(execFile);
 var PythonEnvManager = class {
+  venvPath;
+  cachedProbe = null;
   constructor(dataDir) {
-    this.dataDir = dataDir;
     this.venvPath = path3.join(dataDir, ".venv");
   }
-  venvPath;
-  cachedProbe = null;
   async probe() {
     if (this.cachedProbe) return this.cachedProbe;
     for (const cmd of ["python3", "python"]) {
@@ -648,17 +557,18 @@ var PythonEnvManager = class {
 
 // src/pipeline/pipeline-validator.ts
 var PipelineValidator = class {
-  constructor(loader) {
-    this.loader = loader;
+  constructor(stepExists) {
+    this.stepExists = stepExists;
   }
+  stepExists;
   validate(config) {
     const errors = [];
     const warnings = [];
     for (const node of config.video) {
-      this.validateNode(node, errors, warnings, []);
+      this.validateNode(node, errors, warnings);
     }
     if (config.audio) {
-      this.validateNode(config.audio, errors, warnings, []);
+      this.validateNode(config.audio, errors, warnings);
     }
     return {
       valid: errors.length === 0,
@@ -666,24 +576,19 @@ var PipelineValidator = class {
       warnings
     };
   }
-  validateNode(node, errors, warnings, ancestors) {
-    if (!this.loader.hasAddon(node.addon)) {
+  validateNode(node, errors, warnings) {
+    if (!this.stepExists(node.addon)) {
       errors.push({
         step: node.step,
         addon: node.addon,
-        message: `Addon "${node.addon}" is not registered`,
+        message: `Step "${node.addon}" has no provider \u2014 the addon that provided it may have been removed`,
         severity: "error"
       });
       return;
     }
-    const registered = this.loader.getAddon(node.addon);
-    if (registered) {
-      const manifest = registered.declaration;
-      void manifest;
-    }
     if (node.children) {
       for (const child of node.children) {
-        this.validateNode(child, errors, warnings, [...ancestors, node]);
+        this.validateNode(child, errors, warnings);
       }
     }
   }
@@ -691,11 +596,12 @@ var PipelineValidator = class {
 
 // src/pipeline/pipeline-runner.ts
 import { randomUUID } from "crypto";
+import { errMsg } from "@camstack/types";
 var PipelineRunner = class {
-  constructor(engineManager, addonConfigs) {
-    this.engineManager = engineManager;
-    this.addonConfigs = addonConfigs;
+  constructor(addonResolver) {
+    this.addonResolver = addonResolver;
   }
+  addonResolver;
   async run(frame, config) {
     const startTime = performance.now();
     const results = [];
@@ -713,74 +619,12 @@ var PipelineRunner = class {
       frameTimestamp: frame.timestamp
     };
   }
-  /**
-   * Run only the audio classification node on an audio chunk.
-   * Used by the audio path in DetectionWiringService (separate from video pipeline).
-   */
-  async runAudioNode(chunk, audioNode) {
-    const startTime = performance.now();
-    const results = [];
-    const timings = {};
-    const resultId = randomUUID();
-    const stepStart = performance.now();
-    try {
-      const globalConfig = this.addonConfigs.get(audioNode.addon) ?? {};
-      const engine = await this.engineManager.getOrCreateEngine(
-        audioNode.addon,
-        globalConfig,
-        audioNode.configOverride
-      );
-      if (!("classifyAudio" in engine) || typeof engine["classifyAudio"] !== "function") {
-        throw new Error(`Addon "${audioNode.addon}" has no classifyAudio method`);
-      }
-      const output = await engine.classifyAudio(chunk);
-      const stepMs = performance.now() - stepStart;
-      const stepResult = {
-        addon: audioNode.addon,
-        slot: "classifier",
-        output,
-        resultId,
-        inferenceMs: output.inferenceMs,
-        preprocessMs: 0,
-        totalMs: stepMs
-      };
-      results.push(stepResult);
-      timings[audioNode.step] = stepMs;
-    } catch (error) {
-      const stepMs = performance.now() - stepStart;
-      const message = error instanceof Error ? error.message : String(error);
-      results.push({
-        addon: audioNode.addon,
-        slot: "classifier",
-        output: { classifications: [], inferenceMs: 0, modelId: "" },
-        resultId,
-        inferenceMs: 0,
-        preprocessMs: 0,
-        totalMs: stepMs,
-        error: {
-          code: "ADDON_ERROR",
-          message,
-          childrenSkipped: true
-        }
-      });
-    }
-    return {
-      results,
-      totalMs: performance.now() - startTime,
-      timings,
-      frameTimestamp: chunk.timestamp
-    };
-  }
   async executeNode(node, frame, parentDetection, results, timings) {
     const resultId = randomUUID();
     const stepStart = performance.now();
     try {
-      const globalConfig = this.addonConfigs.get(node.addon) ?? {};
-      const engine = await this.engineManager.getOrCreateEngine(
-        node.addon,
-        globalConfig,
-        node.configOverride
-      );
+      const effectiveConfig = { ...node.configOverride };
+      const caller = await this.addonResolver.resolve(node.addon, effectiveConfig);
       let output;
       if (parentDetection) {
         const cropInput = {
@@ -788,28 +632,9 @@ var PipelineRunner = class {
           roi: parentDetection.det.bbox,
           parentDetection: parentDetection.det
         };
-        if ("crop" in engine && typeof engine["crop"] === "function") {
-          output = await engine.crop(cropInput);
-        } else if ("classify" in engine && typeof engine["classify"] === "function") {
-          output = await engine.classify(cropInput);
-        } else if ("detect" in engine && typeof engine["detect"] === "function") {
-          output = await engine.detect(frame);
-        } else {
-          throw new Error(`Addon "${node.addon}" has no detect/crop/classify method`);
-        }
+        output = await caller.process(cropInput);
       } else {
-        if ("detect" in engine && typeof engine["detect"] === "function") {
-          output = await engine.detect(frame);
-        } else if ("classify" in engine && typeof engine["classify"] === "function") {
-          const rootCropInput = {
-            frame,
-            roi: { x: 0, y: 0, w: frame.width, h: frame.height },
-            parentDetection: { class: "", originalClass: "", score: 1, bbox: { x: 0, y: 0, w: frame.width, h: frame.height } }
-          };
-          output = await engine.classify(rootCropInput);
-        } else {
-          throw new Error(`Addon "${node.addon}" has no detect/classify method`);
-        }
+        output = await caller.process(frame);
       }
       const stepMs = performance.now() - stepStart;
       const slot = "detections" in output ? "detector" : "crops" in output ? "cropper" : "classifier";
@@ -831,7 +656,7 @@ var PipelineRunner = class {
       }
     } catch (error) {
       const stepMs = performance.now() - stepStart;
-      const message = error instanceof Error ? error.message : String(error);
+      const message = errMsg(error);
       results.push({
         addon: node.addon,
         slot: "detector",
@@ -852,6 +677,7 @@ var PipelineRunner = class {
   async executeChildren(children, frame, parentDetections, parentResultId, results, timings) {
     const promises2 = [];
     for (const detection of parentDetections) {
+      if (detection.bbox.w < 1 || detection.bbox.h < 1) continue;
       for (const child of children) {
         promises2.push(
           this.executeNode(child, frame, { det: detection, resultId: parentResultId }, results, timings)
@@ -862,207 +688,25 @@ var PipelineRunner = class {
   }
 };
 
-// src/process/managed-process.ts
-import { fork, spawn as spawn2 } from "child_process";
-var DEFAULT_MAX_RESTARTS = 10;
-var MAX_BACKOFF_MS = 6e4;
-var GRACEFUL_SHUTDOWN_MS = 5e3;
-var ManagedProcess = class {
-  constructor(config, events, logger) {
-    this.config = config;
-    this.events = events;
-    this.logger = logger;
-  }
-  childProcess = null;
-  _state = "stopped";
-  _startedAt;
-  restartTimer;
-  _restartCount = 0;
-  _lastCrashAt;
-  _lastCrashError;
-  get state() {
-    return this._state;
-  }
-  async start() {
-    this._state = "starting";
-    try {
-      if (this.config.modulePath) {
-        this.childProcess = fork(this.config.modulePath, this.config.args ?? [], {
-          env: { ...process.env, ...this.config.env },
-          stdio: ["pipe", "pipe", "pipe", "ipc"]
-        });
-      } else if (this.config.command) {
-        this.childProcess = spawn2(this.config.command, this.config.args ?? [], {
-          env: { ...process.env, ...this.config.env },
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-      } else {
-        throw new Error("No command or modulePath specified");
-      }
-      this.childProcess.stdout?.on("data", (data) => {
-        this.logger.debug(data.toString().trim());
-      });
-      this.childProcess.stderr?.on("data", (data) => {
-        this.logger.warn(data.toString().trim());
-      });
-      this.childProcess.on("exit", (code, signal) => {
-        const msg = `Process exited: code=${code}, signal=${signal}`;
-        if (code === 0) {
-          this.logger.info(msg);
-          this._state = "stopped";
-        } else {
-          this._lastCrashAt = Date.now();
-          this._lastCrashError = msg;
-          this.logger.error(msg);
-          this._state = "error";
-          this.events.emitProcessCrashed(
-            this.config.id,
-            code,
-            signal,
-            this._restartCount
-          );
-          const maxRestarts = this.config.maxRestarts ?? DEFAULT_MAX_RESTARTS;
-          if (this.config.autoRestart && this._restartCount < maxRestarts) {
-            this.scheduleRestart();
-          }
-        }
-        this.childProcess = null;
-      });
-      this.childProcess.on("error", (err) => {
-        this.logger.error(`Process error: ${err.message}`);
-        this._lastCrashError = err.message;
-        this._state = "error";
-      });
-      this._state = "running";
-      this._startedAt = Date.now();
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      this._state = "error";
-      this._lastCrashError = msg;
-      throw err;
-    }
-  }
-  async stop() {
-    if (this.restartTimer) {
-      clearTimeout(this.restartTimer);
-      this.restartTimer = void 0;
-    }
-    if (this._state === "stopped") {
-      return;
-    }
-    this._state = "stopping";
-    if (this.childProcess && !this.childProcess.killed) {
-      this.childProcess.kill("SIGTERM");
-      await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-          if (this.childProcess && !this.childProcess.killed) {
-            this.childProcess.kill("SIGKILL");
-          }
-          resolve();
-        }, GRACEFUL_SHUTDOWN_MS);
-        this.childProcess?.on("exit", () => {
-          clearTimeout(timeout);
-          resolve();
-        });
-      });
-    }
-    const currentState = this._state;
-    if (currentState !== "stopped") {
-      this._state = "stopped";
-    }
+// src/pipeline/engine-manager-resolver.ts
+var EngineManagerResolver = class {
+  constructor(engineManager, addonConfigs) {
+    this.engineManager = engineManager;
+    this.addonConfigs = addonConfigs;
   }
-  getStatus() {
+  engineManager;
+  addonConfigs;
+  async resolve(addonId, config) {
+    const globalConfig = this.addonConfigs.get(addonId) ?? {};
+    const engine = await this.engineManager.getOrCreateEngine(addonId, globalConfig, config);
     return {
-      id: this.config.id,
-      label: this.config.label,
-      state: this._state,
-      pid: this.childProcess?.pid,
-      stats: this.childProcess?.pid ? this.getStats() : void 0,
-      lastCrashAt: this._lastCrashAt,
-      lastCrashError: this._lastCrashError,
-      restartCount: this._restartCount,
-      nextRestartAt: this.restartTimer ? this.getNextRestartTime() : void 0
-    };
-  }
-  scheduleRestart() {
-    this._restartCount++;
-    const delayMs = Math.min(1e3 * Math.pow(2, this._restartCount - 1), MAX_BACKOFF_MS);
-    this.logger.info(`Scheduling restart #${this._restartCount} in ${delayMs}ms`);
-    this.events.emitProcessRestartScheduled(
-      this.config.id,
-      this._restartCount,
-      delayMs
-    );
-    this.restartTimer = setTimeout(async () => {
-      this.restartTimer = void 0;
-      try {
-        await this.start();
-        this.events.emitProcessRestarted(this.config.id, this._restartCount);
-      } catch (err) {
-        this.logger.error(`Restart failed: ${err}`);
+      process: async (input) => {
+        return engine.process(input);
       }
-    }, delayMs);
-  }
-  getStats() {
-    if (!this.childProcess?.pid) return void 0;
-    const uptime = this._startedAt ? Date.now() - this._startedAt : 0;
-    return {
-      pid: this.childProcess.pid,
-      cpu: 0,
-      memory: 0,
-      uptime,
-      restartCount: this._restartCount
     };
   }
-  getNextRestartTime() {
-    if (!this._lastCrashAt) return void 0;
-    const delayMs = Math.min(1e3 * Math.pow(2, this._restartCount - 1), MAX_BACKOFF_MS);
-    return this._lastCrashAt + delayMs;
-  }
-};
-
-// src/process/process-manager.ts
-var ProcessManager = class {
-  constructor(events, loggerFactory) {
-    this.events = events;
-    this.loggerFactory = loggerFactory;
-  }
-  processes = /* @__PURE__ */ new Map();
-  register(config) {
-    if (this.processes.has(config.id)) {
-      throw new Error(`Process already registered: ${config.id}`);
-    }
-    const logger = this.loggerFactory.createLogger(`process:${config.id}`);
-    const managed = new ManagedProcess(config, this.events, logger);
-    this.processes.set(config.id, managed);
-    return managed;
-  }
-  async start(id) {
-    const p = this.get(id);
-    await p.start();
-  }
-  async stop(id) {
-    const p = this.get(id);
-    await p.stop();
-  }
-  async restart(id) {
-    const p = this.get(id);
-    await p.stop();
-    await p.start();
-  }
-  get(id) {
-    const p = this.processes.get(id);
-    if (!p) throw new Error(`Process not found: ${id}`);
-    return p;
-  }
-  listAll() {
-    return [...this.processes.values()].map((p) => p.getStatus());
-  }
   async shutdownAll() {
-    const running = [...this.processes.values()].filter(
-      (p) => p.getStatus().state === "running"
-    );
-    await Promise.all(running.map((p) => p.stop()));
+    await this.engineManager.shutdownAll();
   }
 };
 
@@ -1134,14 +778,15 @@ var ReplEngine = class {
   constructor(contextProvider) {
     this.contextProvider = contextProvider;
   }
+  contextProvider;
   async execute(code, context) {
     const start = Date.now();
-    const sandbox = this.buildSandbox(context);
+    const sandbox = await this.buildSandbox(context);
     try {
       const vmContext = vm.createContext(sandbox);
       const script = new vm.Script(code);
       let result = script.runInContext(vmContext, { timeout: EXECUTION_TIMEOUT_MS });
-      if (result && typeof result.then === "function") {
+      if (result && typeof result === "object" && "then" in result && typeof result.then === "function") {
         result = await Promise.race([
           result,
           new Promise(
@@ -1173,7 +818,7 @@ var ReplEngine = class {
     }
   }
   async getCompletions(partial, context) {
-    const sandbox = this.buildSandbox(context);
+    const sandbox = await this.buildSandbox(context);
     const keys = Object.keys(sandbox);
     if (!partial) return keys;
     const lastDot = partial.lastIndexOf(".");
@@ -1194,7 +839,7 @@ var ReplEngine = class {
     }
     return [];
   }
-  buildSandbox(context) {
+  async buildSandbox(context) {
     const base = {
       console: {
         log: (...args) => util.inspect(args),
@@ -1223,583 +868,40 @@ var ReplEngine = class {
     };
     switch (context.scope.type) {
       case "system":
-        return { ...base, ...this.contextProvider.getSystemSandbox() };
+        return { ...base, ...await this.contextProvider.getSystemSandbox() };
       case "device":
-        return { ...base, ...this.contextProvider.getDeviceSandbox(context.scope.deviceId) };
+        return { ...base, ...await this.contextProvider.getDeviceSandbox(context.scope.deviceId) };
       case "provider":
-        return { ...base, ...this.contextProvider.getProviderSandbox(context.scope.providerId) };
+        return { ...base, ...await this.contextProvider.getProviderSandbox(context.scope.providerId) };
       case "addon":
-        return { ...base, ...this.contextProvider.getAddonSandbox(context.scope.addonId) };
+        return { ...base, ...await this.contextProvider.getAddonSandbox(context.scope.addonId) };
       default:
         return base;
     }
   }
 };
 
-// src/agent/agent-registry.ts
-var AgentRegistry = class {
-  constructor(events, heartbeatTimeoutMs = 3e4, heartbeatCheckIntervalMs = 1e4) {
-    this.events = events;
-    this.heartbeatTimeoutMs = heartbeatTimeoutMs;
-    this.heartbeatCheckIntervalMs = heartbeatCheckIntervalMs;
-  }
-  agents = /* @__PURE__ */ new Map();
-  heartbeatIntervals = /* @__PURE__ */ new Map();
-  /** Register a new agent */
-  registerAgent(info) {
-    const entry = {
-      info,
-      state: "online",
-      connectedSince: Date.now(),
-      lastHeartbeat: Date.now(),
-      activeTaskCount: 0,
-      completedTaskCount: 0,
-      failedTaskCount: 0
-    };
-    this.agents.set(info.id, entry);
-    this.startHeartbeatCheck(info.id);
-    this.events.emitAgentRegistered(info.id, [...info.capabilities]);
-  }
-  /** Remove agent */
-  unregisterAgent(id) {
-    const interval = this.heartbeatIntervals.get(id);
-    if (interval) {
-      clearInterval(interval);
-      this.heartbeatIntervals.delete(id);
-    }
-    this.agents.delete(id);
-    this.events.emitAgentUnregistered(id);
-  }
-  /** Update heartbeat timestamp */
-  heartbeat(id) {
-    const entry = this.agents.get(id);
-    if (!entry) return;
-    entry.lastHeartbeat = Date.now();
-    if (entry.state === "offline") {
-      entry.state = "online";
-      this.events.emitAgentOnline(id);
-    }
-  }
-  /** Find agents with a specific capability */
-  getAgentsWithCapability(capability) {
-    return [...this.agents.values()].filter(
-      (a) => a.state === "online" && a.info.capabilities.includes(capability)
-    );
-  }
-  /** Get best agent for a task (least loaded) */
-  selectAgent(capability, preferredId) {
-    const capable = this.getAgentsWithCapability(capability);
-    if (capable.length === 0) return null;
-    if (preferredId) {
-      const preferred = capable.find((a) => a.info.id === preferredId);
-      if (preferred) return preferred;
-    }
-    const sorted = [...capable].sort((a, b) => a.activeTaskCount - b.activeTaskCount);
-    return sorted[0] ?? null;
-  }
-  /** List all agents with status */
-  listAgents() {
-    return [...this.agents.values()].map((entry) => ({
-      id: entry.info.id,
-      name: entry.info.name,
-      state: entry.state,
-      capabilities: [...entry.info.capabilities],
-      lastHeartbeat: entry.lastHeartbeat,
-      connectedSince: entry.connectedSince,
-      resources: entry.info.resources,
-      activeTaskCount: entry.activeTaskCount,
-      completedTaskCount: entry.completedTaskCount,
-      failedTaskCount: entry.failedTaskCount
-    }));
-  }
-  /** Get single agent */
-  getAgent(id) {
-    return this.agents.get(id) ?? null;
-  }
-  /** Destroy all heartbeat intervals */
-  destroy() {
-    for (const interval of this.heartbeatIntervals.values()) {
-      clearInterval(interval);
-    }
-    this.heartbeatIntervals.clear();
-  }
-  startHeartbeatCheck(id) {
-    const interval = setInterval(() => {
-      const entry = this.agents.get(id);
-      if (!entry) return;
-      const elapsed = Date.now() - entry.lastHeartbeat;
-      if (elapsed > this.heartbeatTimeoutMs && entry.state === "online") {
-        entry.state = "offline";
-        this.events.emitAgentOffline(id);
-      }
-    }, this.heartbeatCheckIntervalMs);
-    this.heartbeatIntervals.set(id, interval);
-  }
+// src/lifecycle/lifecycle-state-machine.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var VALID_TRANSITIONS = {
+  stopped: ["starting", "disabled"],
+  starting: ["running", "error", "stopping"],
+  running: ["stopping", "error"],
+  stopping: ["stopped", "error"],
+  error: ["starting", "stopped", "disabled"],
+  disabled: ["stopped"]
 };
-
-// src/agent/task-dispatcher.ts
-var TaskDispatcher = class {
-  constructor(agentRegistry, events) {
-    this.agentRegistry = agentRegistry;
-    this.events = events;
-  }
-  pendingTasks = /* @__PURE__ */ new Map();
-  localExecutors = /* @__PURE__ */ new Map();
-  /** Dispatch a task to the best available agent */
-  async dispatch(task, options) {
-    const capability = options?.capability ?? task.capability;
-    const agent = this.agentRegistry.selectAgent(capability, options?.preferredAgent);
-    if (!agent && !options?.remoteOnly) {
-      return this.executeLocally(task);
-    }
-    if (!agent) {
-      return {
-        taskId: task.id,
-        agentId: "none",
-        status: "error",
-        error: "No agent available",
-        durationMs: 0
-      };
-    }
-    return this.sendToAgent(task, agent);
-  }
-  /** Register a local executor for a capability (in-process fallback) */
-  registerLocalExecutor(capability, executor) {
-    this.localExecutors.set(capability, executor);
-  }
-  /** Called when an agent returns a result */
-  handleTaskResult(result) {
-    const pending = this.pendingTasks.get(result.taskId);
-    if (pending) {
-      clearTimeout(pending.timeout);
-      this.pendingTasks.delete(result.taskId);
-      pending.resolve(result);
-    }
-    const agent = this.agentRegistry.getAgent(result.agentId);
-    if (agent) {
-      agent.activeTaskCount--;
-      if (result.status === "success") {
-        agent.completedTaskCount++;
-      } else {
-        agent.failedTaskCount++;
-      }
-    }
-  }
-  async executeLocally(task) {
-    const executor = this.localExecutors.get(task.capability);
-    if (!executor) {
-      return {
-        taskId: task.id,
-        agentId: "local",
-        status: "error",
-        error: `No local executor for ${task.capability}`,
-        durationMs: 0
-      };
-    }
-    const start = Date.now();
-    try {
-      const output = await executor(task.input);
-      return {
-        taskId: task.id,
-        agentId: "local",
-        status: "success",
-        output,
-        durationMs: Date.now() - start
-      };
-    } catch (err) {
-      return {
-        taskId: task.id,
-        agentId: "local",
-        status: "error",
-        error: String(err),
-        durationMs: Date.now() - start
-      };
-    }
+var LifecycleStateMachine = class {
+  constructor(elementId, elementType, eventBus, logger) {
+    this.elementId = elementId;
+    this.elementType = elementType;
+    this.eventBus = eventBus;
+    this.logger = logger;
   }
-  sendToAgent(task, agent) {
-    agent.activeTaskCount++;
-    return new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        this.pendingTasks.delete(task.id);
-        agent.activeTaskCount--;
-        agent.failedTaskCount++;
-        resolve({
-          taskId: task.id,
-          agentId: agent.info.id,
-          status: "timeout",
-          durationMs: task.timeout,
-          error: "Task timed out"
-        });
-      }, task.timeout);
-      this.pendingTasks.set(task.id, { resolve, reject: () => {
-      }, timeout });
-      this.events.emitTaskDispatched(task.id, agent.info.id, task.capability);
-    });
-  }
-};
-
-// src/agent/agent-client.ts
-var RECONNECT_BASE_MS = 1e3;
-var RECONNECT_MAX_MS = 3e4;
-var HEARTBEAT_INTERVAL_MS = 1e4;
-var AgentClient = class {
-  ws = null;
-  reconnectAttempt = 0;
-  reconnectTimer = null;
-  heartbeatTimer = null;
-  destroyed = false;
-  messageHandlers = [];
-  binaryHandlers = [];
-  connectHandlers = [];
-  disconnectHandlers = [];
+  elementId;
+  elementType;
+  eventBus;
   logger;
-  hubUrl;
-  token;
-  registrationInfo;
-  runtimeStatus = {
-    activeCameras: 0,
-    cpuPercent: 0,
-    memoryPercent: 0,
-    fps: {},
-    errors: []
-  };
-  constructor(config) {
-    this.hubUrl = config.hubUrl;
-    this.token = config.token;
-    this.logger = config.logger;
-    this.registrationInfo = config.registrationInfo;
-  }
-  /** Connect to the hub WebSocket */
-  async connect() {
-    return new Promise((resolve, reject) => {
-      this.destroyed = false;
-      this.doConnect(resolve, reject);
-    });
-  }
-  /** Disconnect and stop reconnecting */
-  disconnect() {
-    this.destroyed = true;
-    this.clearTimers();
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  /** Send a JSON control message to the hub */
-  send(msg) {
-    if (!this.ws || this.ws.readyState !== 1) {
-      this.logger.warn("send() called while not connected");
-      return;
-    }
-    this.ws.send(JSON.stringify(msg));
-  }
-  /** Send a binary frame to the hub */
-  sendBinary(data) {
-    if (!this.ws || this.ws.readyState !== 1) {
-      return;
-    }
-    this.ws.send(data);
-  }
-  /** Register a handler for JSON messages from hub */
-  onMessage(handler) {
-    this.messageHandlers.push(handler);
-  }
-  /** Register a handler for binary frames from hub */
-  onBinaryFrame(handler) {
-    this.binaryHandlers.push(handler);
-  }
-  /** Register a handler for successful connection */
-  onConnect(handler) {
-    this.connectHandlers.push(handler);
-  }
-  /** Register a handler for disconnection */
-  onDisconnect(handler) {
-    this.disconnectHandlers.push(handler);
-  }
-  /** Update the runtime status (used in heartbeat) */
-  updateStatus(status) {
-    this.runtimeStatus = status;
-  }
-  /** Whether currently connected */
-  get connected() {
-    return this.ws?.readyState === 1;
-  }
-  doConnect(onConnect, onError) {
-    if (this.destroyed) return;
-    import("ws").then(({ default: WebSocket }) => {
-      if (this.destroyed) return;
-      const url = this.token ? `${this.hubUrl}?token=${encodeURIComponent(this.token)}` : this.hubUrl;
-      const wsOptions = this.hubUrl.startsWith("wss://") ? { rejectUnauthorized: false } : {};
-      try {
-        this.ws = new WebSocket(url, wsOptions);
-      } catch (err) {
-        this.scheduleReconnect();
-        if (onError) {
-          onError(err instanceof Error ? err : new Error(String(err)));
-          onError = void 0;
-        }
-        return;
-      }
-      this.ws.once("open", () => {
-        this.reconnectAttempt = 0;
-        this.logger.info(`Connected to hub: ${this.hubUrl}`);
-        this.send({ type: "register", info: this.registrationInfo });
-        this.startHeartbeat();
-        for (const h of this.connectHandlers) h();
-        if (onConnect) {
-          onConnect();
-          onConnect = void 0;
-        }
-      });
-      this.ws.on("message", (data, isBinary) => {
-        const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
-        if (isBinary) {
-          for (const h of this.binaryHandlers) h(buf);
-        } else {
-          try {
-            const msg = JSON.parse(buf.toString());
-            this.handleBuiltinMessage(msg);
-            for (const h of this.messageHandlers) h(msg);
-          } catch {
-            this.logger.warn("Failed to parse message from hub");
-          }
-        }
-      });
-      this.ws.once("close", () => {
-        this.stopHeartbeat();
-        for (const h of this.disconnectHandlers) h();
-        if (!this.destroyed) {
-          this.logger.warn("Disconnected from hub, scheduling reconnect");
-          this.scheduleReconnect();
-        }
-      });
-      this.ws.once("error", (err) => {
-        this.logger.error("WebSocket error", { message: err.message });
-        if (onError) {
-          onError(err);
-          onError = void 0;
-        }
-      });
-    }).catch((err) => {
-      this.logger.error("Failed to import ws module", { message: String(err) });
-      if (onError) {
-        onError(err instanceof Error ? err : new Error(String(err)));
-      }
-    });
-  }
-  handleBuiltinMessage(msg) {
-    if (msg.type === "ping") {
-      this.send({ type: "pong" });
-    }
-  }
-  scheduleReconnect() {
-    if (this.destroyed) return;
-    const delay = Math.min(
-      RECONNECT_BASE_MS * Math.pow(2, this.reconnectAttempt),
-      RECONNECT_MAX_MS
-    );
-    this.reconnectAttempt++;
-    this.logger.info(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempt})`);
-    this.reconnectTimer = setTimeout(() => {
-      this.doConnect();
-    }, delay);
-  }
-  startHeartbeat() {
-    this.stopHeartbeat();
-    this.heartbeatTimer = setInterval(() => {
-      this.send({ type: "heartbeat", status: this.runtimeStatus });
-    }, HEARTBEAT_INTERVAL_MS);
-  }
-  stopHeartbeat() {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
-  }
-  clearTimers() {
-    this.stopHeartbeat();
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-  }
-};
-
-// src/agent/agent-task-runner.ts
-var AgentTaskRunner = class {
-  constructor(agentId, client, logger) {
-    this.agentId = agentId;
-    this.client = client;
-    this.logger = logger.child("TaskRunner");
-  }
-  handlers = /* @__PURE__ */ new Map();
-  runningTasks = /* @__PURE__ */ new Map();
-  logger;
-  /** Register a task handler for a given task type */
-  registerHandler(handler) {
-    if (this.handlers.has(handler.taskType)) {
-      this.logger.warn(`Overwriting handler for task type: ${handler.taskType}`);
-    }
-    this.handlers.set(handler.taskType, handler);
-    this.logger.debug(`Registered handler: ${handler.taskType}`);
-  }
-  /** Unregister a task handler */
-  unregisterHandler(taskType) {
-    this.handlers.delete(taskType);
-  }
-  /** Get all registered task types */
-  getTaskTypes() {
-    return [...this.handlers.keys()];
-  }
-  /** Get a handler by task type */
-  getHandler(taskType) {
-    return this.handlers.get(taskType);
-  }
-  /**
-   * Execute a task dispatched from the hub.
-   * Sends result or error back to hub via the AgentClient.
-   */
-  async executeTask(taskId, taskType, payload) {
-    const handler = this.handlers.get(taskType);
-    if (!handler) {
-      this.client.send({
-        type: "task.result",
-        taskId,
-        success: false,
-        error: `No handler registered for task type: ${taskType}`
-      });
-      return;
-    }
-    const runningTask = { taskId, taskType, cancelled: false };
-    this.runningTasks.set(taskId, runningTask);
-    const context = {
-      taskId,
-      agentId: this.agentId,
-      logger: this.logger.child(taskType),
-      reportProgress: (progress) => {
-        this.client.send({ type: "task.progress", taskId, progress });
-      },
-      isCancelled: () => runningTask.cancelled
-    };
-    try {
-      const result = await handler.handle(payload, context);
-      this.runningTasks.delete(taskId);
-      if (!runningTask.cancelled) {
-        this.client.send({
-          type: "task.result",
-          taskId,
-          success: true,
-          result
-        });
-      }
-    } catch (err) {
-      this.runningTasks.delete(taskId);
-      this.logger.error(`Task ${taskType} (${taskId}) failed`, {
-        message: err instanceof Error ? err.message : String(err)
-      });
-      this.client.send({
-        type: "task.result",
-        taskId,
-        success: false,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  /** Cancel a running task */
-  async cancelTask(taskId) {
-    const running = this.runningTasks.get(taskId);
-    if (!running) return;
-    running.cancelled = true;
-    const handler = this.handlers.get(running.taskType);
-    if (handler?.cancel) {
-      try {
-        await handler.cancel();
-      } catch (err) {
-        this.logger.error(`Error cancelling task ${taskId}`, {
-          message: err instanceof Error ? err.message : String(err)
-        });
-      }
-    }
-    this.runningTasks.delete(taskId);
-  }
-  /** Number of currently running tasks */
-  get activeTaskCount() {
-    return this.runningTasks.size;
-  }
-  /** Destroy: cancel all running tasks */
-  async destroy() {
-    const taskIds = [...this.runningTasks.keys()];
-    for (const taskId of taskIds) {
-      await this.cancelTask(taskId);
-    }
-    this.handlers.clear();
-  }
-};
-
-// src/agent/pipeline-task-handlers.ts
-var DecodeTaskHandler = class {
-  taskType = "pipeline.decode";
-  description = "Decode an RTSP stream and produce JPEG frames";
-  async handle(payload, context) {
-    const { logger } = context;
-    const config = payload;
-    if (!config.cameraId || !config.rtspUrl) {
-      throw new Error("pipeline.decode requires cameraId and rtspUrl in payload");
-    }
-    logger.info(`Decode task started: camera=${config.cameraId} url=${config.rtspUrl} fps=${config.fps ?? 1}`);
-    return { status: "started", cameraId: config.cameraId };
-  }
-  async cancel() {
-  }
-};
-var DetectTaskHandler = class {
-  taskType = "pipeline.detect";
-  description = "Run object detection on received frames";
-  async handle(payload, context) {
-    const { logger } = context;
-    const config = payload;
-    if (!config.cameraId) {
-      throw new Error("pipeline.detect requires cameraId in payload");
-    }
-    logger.info(`Detect task started: camera=${config.cameraId} model=${config.modelId ?? "default"} runtime=${config.runtime ?? "auto"}`);
-    return { status: "started", cameraId: config.cameraId };
-  }
-  async cancel() {
-  }
-};
-var RecordTaskHandler = class {
-  taskType = "pipeline.record";
-  description = "Record an RTSP stream to disk segments";
-  async handle(payload, context) {
-    const { logger } = context;
-    const config = payload;
-    if (!config.cameraId || !config.rtspUrl) {
-      throw new Error("pipeline.record requires cameraId and rtspUrl in payload");
-    }
-    logger.info(`Record task started: camera=${config.cameraId} url=${config.rtspUrl}`);
-    return { status: "started", cameraId: config.cameraId };
-  }
-  async cancel() {
-  }
-};
-
-// src/lifecycle/lifecycle-state-machine.ts
-import { randomUUID as randomUUID2 } from "crypto";
-var VALID_TRANSITIONS = {
-  stopped: ["starting", "disabled"],
-  starting: ["running", "error", "stopping"],
-  running: ["stopping", "error"],
-  stopping: ["stopped", "error"],
-  error: ["starting", "stopped", "disabled"],
-  disabled: ["stopped"]
-};
-var LifecycleStateMachine = class {
-  constructor(elementId, elementType, eventBus, logger) {
-    this.elementId = elementId;
-    this.elementType = elementType;
-    this.eventBus = eventBus;
-    this.logger = logger;
-  }
   _state = "stopped";
   _error;
   _startedAt;
@@ -1822,7 +924,7 @@ var LifecycleStateMachine = class {
   transition(to, error) {
     const from = this._state;
     if (!this.isValidTransition(from, to)) {
-      this.logger.warn(`Invalid state transition: ${from} \u2192 ${to}`);
+      this.logger.warn("Invalid state transition", { meta: { from, to } });
       return false;
     }
     this._state = to;
@@ -1838,7 +940,7 @@ var LifecycleStateMachine = class {
     if (to === "stopped" || to === "error" || to === "disabled") {
       this._stoppedAt = Date.now();
     }
-    this.logger.info(`State: ${from} \u2192 ${to}${error ? ` (${error})` : ""}`);
+    this.logger.info("State transition", { meta: { from, to, error } });
     this.eventBus.emit({
       id: randomUUID2(),
       timestamp: /* @__PURE__ */ new Date(),
@@ -1861,6 +963,7 @@ var FeatureManager = class {
   constructor(configReader) {
     this.configReader = configReader;
   }
+  configReader;
   isEnabled(flag) {
     return this.configReader.features[flag];
   }
@@ -1873,8 +976,9 @@ var FeatureManager = class {
 var EventRingBuffer = class {
   constructor(capacity) {
     this.capacity = capacity;
-    this.buffer = new Array(capacity);
+    this.buffer = Array.from({ length: capacity });
   }
+  capacity;
   buffer;
   head = 0;
   count = 0;
@@ -1912,14 +1016,36 @@ function matchesCategory(eventCategory, filterCategory) {
   return eventCategory === filterCategory;
 }
 function matchesFilter(event, filter) {
-  if (filter.category && !matchesCategory(event.category, filter.category)) {
-    return false;
+  if (filter.category) {
+    const raw = filter.category;
+    const categories = Array.isArray(raw) ? raw.map(String) : [String(raw)];
+    if (!categories.some((cat) => matchesCategory(event.category, cat))) {
+      return false;
+    }
   }
   if (filter.source) {
     if (event.source.type !== filter.source.type || event.source.id !== filter.source.id) {
       return false;
     }
   }
+  if (filter.agentId) {
+    const eventNodeId = event.source.nodeId;
+    if (!eventNodeId || !eventNodeId.startsWith(filter.agentId)) {
+      return false;
+    }
+  }
+  if (filter.addonId) {
+    const eventAddonId = event.source.addonId ?? (event.source.type === "addon" ? String(event.source.id) : void 0);
+    if (eventAddonId !== filter.addonId) {
+      return false;
+    }
+  }
+  if (filter.deviceId !== void 0) {
+    const eventDeviceId = event.source.deviceId ?? (event.source.type === "device" ? Number(event.source.id) : void 0);
+    if (eventDeviceId !== filter.deviceId) {
+      return false;
+    }
+  }
   if (filter.since && event.timestamp < filter.since) {
     return false;
   }
@@ -1945,6 +1071,10 @@ var SystemEventBus = class {
       }
     }
   }
+  /**
+   * Subscribe to events matching a filter.
+   * When called with a typed category filter, the handler receives typed event data.
+   */
   subscribe(filter, handler) {
     const subscriber = { filter, callback: handler };
     this.subscribers.push(subscriber);
@@ -1961,11 +1091,32 @@ var SystemEventBus = class {
 };
 
 // src/logging/log-ring-buffer.ts
+function matchesLogTags(entryTags, filterTags) {
+  if (!entryTags) return false;
+  for (const [key, value] of Object.entries(filterTags)) {
+    if (value === void 0) continue;
+    const entryValue = entryTags[key];
+    if (key === "addonId") {
+      const bare = typeof entryValue === "string" ? entryValue.split("@")[0] : entryValue;
+      if (bare !== value) return false;
+    } else if (key === "agentId") {
+      const nodeId = entryTags["nodeId"];
+      const matchEmitter = entryValue === value;
+      const matchExactNode = nodeId === value;
+      const matchWorker = typeof nodeId === "string" && nodeId.startsWith(`${value}/`);
+      if (!matchEmitter && !matchExactNode && !matchWorker) return false;
+    } else {
+      if (entryValue !== value) return false;
+    }
+  }
+  return true;
+}
 var LogRingBuffer = class {
   constructor(capacity = 1e4) {
     this.capacity = capacity;
-    this.buffer = new Array(capacity);
+    this.buffer = Array.from({ length: capacity });
   }
+  capacity;
   buffer;
   head = 0;
   count = 0;
@@ -1987,14 +1138,6 @@ var LogRingBuffer = class {
   query(filter) {
     const all = this.getAll();
     let result = all;
-    if (filter.scope && filter.scope.length > 0) {
-      result = result.filter((entry) => {
-        for (let i = 0; i < filter.scope.length; i++) {
-          if (entry.scope[i] !== filter.scope[i]) return false;
-        }
-        return true;
-      });
-    }
     if (filter.level) {
       result = result.filter((entry) => entry.level === filter.level);
     }
@@ -2004,44 +1147,98 @@ var LogRingBuffer = class {
     if (filter.until) {
       result = result.filter((entry) => entry.timestamp <= filter.until);
     }
+    if (filter.tags) {
+      const filterTags = filter.tags;
+      result = result.filter((entry) => matchesLogTags(entry.tags, filterTags));
+    }
     if (filter.limit !== void 0 && filter.limit > 0) {
       result = result.slice(0, filter.limit);
     }
     return result;
   }
+  /**
+   * Drop entries that match `filter`. Returns the number of entries
+   * removed. Triggered by the UI's "Clear logs" button so the operator
+   * can wipe the historical buffer for a specific scope (per-device,
+   * per-addon, per-agent) — without it, closing and reopening the
+   * panel re-populates the cleared rows from the server's ring buffer.
+   *
+   * Filter semantics mirror `query` (same level / since / until / tags
+   * handling) — whatever you'd see listed by `query(filter)` is what
+   * gets removed.
+   */
+  clear(filter = {}) {
+    if (this.count === 0) return 0;
+    const survivors = [];
+    for (let i = 0; i < this.count; i++) {
+      const index = (this.head - 1 - i + this.capacity) % this.capacity;
+      const entry = this.buffer[index];
+      let matches = true;
+      if (filter.level !== void 0 && entry.level !== filter.level) matches = false;
+      if (matches && filter.since !== void 0 && entry.timestamp < filter.since) matches = false;
+      if (matches && filter.until !== void 0 && entry.timestamp > filter.until) matches = false;
+      if (matches && filter.tags !== void 0 && !matchesLogTags(entry.tags, filter.tags)) matches = false;
+      if (!matches) survivors.push(entry);
+    }
+    const removed = this.count - survivors.length;
+    if (removed === 0) return 0;
+    this.buffer.fill(void 0);
+    this.head = 0;
+    this.count = 0;
+    for (let i = survivors.length - 1; i >= 0; i--) {
+      this.push(survivors[i]);
+    }
+    return removed;
+  }
 };
 
 // src/logging/scoped-logger.ts
 var ScopedLogger = class _ScopedLogger {
-  constructor(scope, writeFn) {
+  constructor(scope, writeFn, tags) {
     this.scope = scope;
     this.writeFn = writeFn;
+    this.tags = tags;
   }
-  debug(message, meta) {
-    this.write("debug", message, meta);
+  scope;
+  writeFn;
+  tags;
+  debug(message, extras) {
+    this.write("debug", message, extras);
   }
-  info(message, meta) {
-    this.write("info", message, meta);
+  info(message, extras) {
+    this.write("info", message, extras);
   }
-  warn(message, meta) {
-    this.write("warn", message, meta);
+  warn(message, extras) {
+    this.write("warn", message, extras);
   }
-  error(message, meta) {
-    this.write("error", message, meta);
+  error(message, extras) {
+    this.write("error", message, extras);
   }
   child(childScope) {
-    return new _ScopedLogger([...this.scope, childScope], this.writeFn);
+    return new _ScopedLogger(childScope, this.writeFn, this.tags);
+  }
+  withTags(tags) {
+    const merged = this.tags ? { ...this.tags, ...tags } : tags;
+    return new _ScopedLogger(this.scope, this.writeFn, merged);
   }
-  write(level, message, meta) {
+  write(level, message, extras) {
+    const mergedTags = this.mergeTags(extras?.tags);
     const entry = {
       timestamp: /* @__PURE__ */ new Date(),
       level,
-      scope: this.scope,
       message,
-      ...meta !== void 0 ? { meta } : {}
+      ...this.scope !== void 0 ? { scope: this.scope } : {},
+      ...extras?.meta !== void 0 ? { meta: extras.meta } : {},
+      ...mergedTags ? { tags: mergedTags } : {}
     };
     this.writeFn(entry);
   }
+  mergeTags(extraTags) {
+    if (!this.tags && !extraTags) return void 0;
+    if (!this.tags) return extraTags;
+    if (!extraTags) return this.tags;
+    return { ...this.tags, ...extraTags };
+  }
 };
 
 // src/logging/log-manager.ts
@@ -2049,25 +1246,50 @@ var LogManager = class {
   ringBuffer;
   destinations = [];
   subscribers = /* @__PURE__ */ new Map();
+  deviceNameLookup = null;
   constructor(bufferSize = 1e4) {
     this.ringBuffer = new LogRingBuffer(bufferSize);
   }
+  /**
+   * Register a callback that resolves `deviceId → deviceName`. Called
+   * for every emitted entry that carries `tags.deviceId` but no
+   * explicit `tags.deviceName` — the LogManager injects the resolved
+   * name directly into the entry's tags BEFORE ring-buffer / destination
+   * write, so every destination (local console, file, remote forwarder,
+   * addon-bundled copies of core) sees the enriched shape regardless of
+   * which module instance the destination was built from.
+   */
+  setDeviceNameLookup(lookup) {
+    this.deviceNameLookup = lookup;
+  }
   createLogger(scope) {
-    return new ScopedLogger([scope], (entry) => {
-      this.ringBuffer.push(entry);
+    return new ScopedLogger(scope, (entry) => {
+      const enriched = this.enrichDeviceName(entry);
+      this.ringBuffer.push(enriched);
       for (const dest of this.destinations) {
-        dest.write(entry);
+        dest.write(enriched);
       }
       for (const [, sub] of this.subscribers) {
-        if (this.matchesFilter(entry, sub.filter)) {
+        if (this.matchesFilter(enriched, sub.filter)) {
           try {
-            sub.callback(entry);
+            sub.callback(enriched);
           } catch {
           }
         }
       }
     });
   }
+  enrichDeviceName(entry) {
+    if (!this.deviceNameLookup) return entry;
+    const tags = entry.tags;
+    if (!tags) return entry;
+    const deviceId = tags.deviceId;
+    if (typeof deviceId !== "number" || !Number.isFinite(deviceId)) return entry;
+    if (typeof tags.deviceName === "string") return entry;
+    const name = this.deviceNameLookup(deviceId);
+    if (!name) return entry;
+    return { ...entry, tags: { ...tags, deviceName: name } };
+  }
   /** Subscribe to live logs matching a filter. Returns an unsubscribe function. */
   subscribe(filter, callback) {
     const id = Math.random().toString(36).slice(2);
@@ -2077,20 +1299,36 @@ var LogManager = class {
     };
   }
   matchesFilter(entry, filter) {
-    if (filter.scope && filter.scope.length > 0) {
-      const entryScope = entry.scope?.[0] ?? "";
-      if (!filter.scope.some((s) => entryScope === s || entryScope.startsWith(s))) return false;
-    }
     if (filter.level) {
       const levels = ["debug", "info", "warn", "error"];
       const minIdx = levels.indexOf(filter.level);
       const entryIdx = levels.indexOf(entry.level);
       if (entryIdx < minIdx) return false;
     }
+    if (filter.tags) {
+      if (!matchesLogTags(entry.tags, filter.tags)) return false;
+    }
     return true;
   }
-  addDestination(dest) {
+  /**
+   * Register a log destination.
+   *
+   * @param opts.replay  If true (default), replay every entry currently in
+   *                     the ring buffer to the new destination before live
+   *                     traffic starts. Lets a destination added mid-boot
+   *                     still receive boot-time log entries.
+   */
+  addDestination(dest, opts = {}) {
+    const replay = opts.replay ?? true;
     this.destinations.push(dest);
+    if (replay) {
+      for (const entry of this.ringBuffer.query({})) {
+        try {
+          dest.write(entry);
+        } catch {
+        }
+      }
+    }
   }
   removeDestination(dest) {
     const index = this.destinations.indexOf(dest);
@@ -2101,6 +1339,16 @@ var LogManager = class {
   query(filter) {
     return this.ringBuffer.query(filter);
   }
+  /**
+   * Drop ring-buffer entries matching `filter`. Returns the count
+   * removed. Backs the UI's "Clear logs" admin action so an operator
+   * can wipe the historical window for a scope (per-device, per-addon,
+   * agent-level) without restarting the server. External destinations
+   * (file, forwarder) are NOT touched — only the in-memory ring.
+   */
+  clear(filter = {}) {
+    return this.ringBuffer.clear(filter);
+  }
 };
 
 // src/storage/storage-manager.ts
@@ -2113,7 +1361,7 @@ var StorageManager = class {
   settingsBackend = null;
   /** @deprecated Set by legacy capability consumer — use setNewStorageProvider instead */
   setProvider(provider) {
-    if ("getLocation" in provider && typeof provider.getLocation === "function") {
+    if ("getLocation" in provider) {
       this.legacyProvider = provider;
     } else {
       this.newStorageProvider = provider;
@@ -2125,6 +1373,12 @@ var StorageManager = class {
   setSettingsBackend(backend) {
     this.settingsBackend = backend;
   }
+  getSettingsBackend() {
+    if (!this.settingsBackend) {
+      throw new Error("SettingsBackend not initialized \u2014 storage addon not yet loaded");
+    }
+    return this.settingsBackend;
+  }
   getProvider() {
     if (this.legacyProvider) return this.legacyProvider;
     if (!this.newStorageProvider && !this.settingsBackend && !this.locationManager) {
@@ -2142,7 +1396,7 @@ var StorageManager = class {
     return this.locationManager;
   }
   async initializeLocations(dataPath) {
-    const { StorageLocationManager: StorageLocationManager2 } = await import("./storage-location-manager-KKDQNAKA.mjs");
+    const { StorageLocationManager: StorageLocationManager2 } = await import("./storage-location-manager-HFNB3PCS.mjs");
     const manager = new StorageLocationManager2(dataPath);
     await manager.initializeDefaults();
     this.locationManager = manager;
@@ -2161,7 +1415,8 @@ var StorageManager = class {
     if (this.legacyProvider) {
       try {
         const LEGACY_MAP = { config: "data", events: "data", addon: "data" };
-        const mappedName = LEGACY_MAP[name] ?? name;
+        const mapped = name in LEGACY_MAP ? LEGACY_MAP[name] : name;
+        const mappedName = mapped;
         const location2 = this.legacyProvider.getLocation(mappedName);
         return namespace ? this.createNamespacedLocation(location2, namespace) : location2;
       } catch {
@@ -2172,29 +1427,29 @@ var StorageManager = class {
       const backend = this.settingsBackend;
       location.structured = {
         async query(collection, filter) {
-          const results = await backend.query(collection, filter);
+          const results = await backend.query({ collection, filter });
           return results.map((r) => ({ collection, id: r.id, data: r.data }));
         },
         async insert(record) {
           const id = record.id || (await import("crypto")).randomUUID();
-          await backend.insert(record.collection, { id, data: record.data });
+          await backend.insert({ collection: record.collection, record: { id, data: record.data } });
           return { ...record, id };
         },
         async update(collection, id, data) {
-          await backend.update(collection, id, data);
+          await backend.update({ collection, id, data });
           return { collection, id, data };
         },
         async delete(collection, id) {
-          await backend.delete(collection, id);
+          await backend.delete({ collection, key: id });
         },
         async count(collection, filter) {
-          return backend.count(collection, filter);
+          return backend.count({ collection, filter });
         }
       };
     }
     if (this.locationManager) {
       const LEGACY_MAP = { config: "data", events: "data", addon: "data" };
-      const mappedName = LEGACY_MAP[name] ?? name;
+      const mappedName = name in LEGACY_MAP ? LEGACY_MAP[name] : name;
       try {
         const basePath = this.locationManager.getBackend(mappedName).basePath;
         location.files = {
@@ -2290,387 +1545,13 @@ var StorageManager = class {
   }
 };
 
-// src/auth/auth-manager.ts
-import * as jwt from "jsonwebtoken";
-import * as bcrypt from "bcryptjs";
-import * as crypto from "crypto";
-var AuthManager = class {
-  constructor(config) {
-    this.config = config;
-    const configured = this.config.get("auth.jwtSecret");
-    if (configured) {
-      this.jwtSecret = configured;
-    } else {
-      const secret = crypto.randomBytes(32).toString("hex");
-      this.config.update("auth", { jwtSecret: secret });
-      console.log("[AuthManager] Generated JWT secret and saved to config.yaml (auth.jwtSecret)");
-      this.jwtSecret = secret;
-    }
-  }
-  jwtSecret;
-  scopedTokenManager = null;
-  signToken(payload) {
-    return jwt.sign({ ...payload }, this.jwtSecret, { expiresIn: "24h" });
-  }
-  verifyToken(token) {
-    return jwt.verify(token, this.jwtSecret);
-  }
-  async hashPassword(password) {
-    return bcrypt.hash(password, 10);
-  }
-  async comparePassword(password, hash2) {
-    return bcrypt.compare(password, hash2);
-  }
-  generateApiKey() {
-    const token = crypto.randomBytes(32).toString("hex");
-    const hash2 = crypto.createHash("sha256").update(token).digest("hex");
-    const prefix = token.slice(0, 8);
-    return { token, hash: hash2, prefix };
-  }
-  validateApiKey(token, storedHash) {
-    const hash2 = crypto.createHash("sha256").update(token).digest("hex");
-    return hash2 === storedHash;
-  }
-  /**
-   * Create a service token for agent/worker authentication.
-   * Used when forking workers or when agents register.
-   */
-  createServiceToken(opts) {
-    const payload = {
-      userId: opts.agentId,
-      username: opts.agentId,
-      role: opts.role ?? "agent",
-      type: "service",
-      agentId: opts.agentId,
-      allowedProviders: "*",
-      allowedDevices: {}
-    };
-    const expiresIn = opts.expiresIn ?? "24h";
-    return jwt.sign(payload, this.jwtSecret, { expiresIn });
-  }
-  /**
-   * Set the scoped token manager for the auth chain.
-   */
-  setScopedTokenManager(manager) {
-    this.scopedTokenManager = manager;
-  }
-  /**
-   * Validate a scoped token string.
-   * Returns the token record if valid, null otherwise.
-   */
-  async validateScopedToken(rawToken) {
-    if (!this.scopedTokenManager) {
-      return null;
-    }
-    return this.scopedTokenManager.validate(rawToken);
-  }
-  /**
-   * Check whether a scoped token grants access to a given addon/route/capability.
-   */
-  matchesScopedTokenScope(token, addonId, routePath, capability) {
-    if (!this.scopedTokenManager) {
-      return false;
-    }
-    return this.scopedTokenManager.matchesScope(token, addonId, routePath, capability);
-  }
-};
-
-// src/auth/api-key-manager.ts
-import * as crypto2 from "crypto";
-var API_KEYS_COLLECTION = "api_keys";
-var ApiKeyManager = class {
-  constructor(storageAccess, auth) {
-    this.storageAccess = storageAccess;
-    this.auth = auth;
-  }
-  get structured() {
-    return this.storageAccess.getStructuredStorage();
-  }
-  async create(input) {
-    const { token, hash: hash2, prefix } = this.auth.generateApiKey();
-    const now = Date.now();
-    const record = {
-      id: crypto2.randomUUID(),
-      label: input.label,
-      role: input.role,
-      allowedProviders: input.allowedProviders ?? "*",
-      allowedDevices: input.allowedDevices ?? {},
-      tokenHash: hash2,
-      tokenPrefix: prefix,
-      createdAt: now
-    };
-    await this.structured.insert({
-      collection: API_KEYS_COLLECTION,
-      id: record.id,
-      data: record
-    });
-    return { record, token };
-  }
-  async validateToken(token) {
-    const allKeys = await this.structured.query(API_KEYS_COLLECTION);
-    for (const entry of allKeys) {
-      const record = entry.data;
-      if (this.auth.validateApiKey(token, record.tokenHash)) {
-        const updatedData = {
-          ...record,
-          lastUsedAt: Date.now()
-        };
-        await this.structured.update(API_KEYS_COLLECTION, record.id, updatedData);
-        return { ...record, lastUsedAt: updatedData.lastUsedAt };
-      }
-    }
-    return null;
-  }
-  async listAll() {
-    const results = await this.structured.query(API_KEYS_COLLECTION);
-    return results.map((r) => {
-      const { tokenHash, ...rest } = r.data;
-      return rest;
-    });
-  }
-  async revoke(id) {
-    await this.structured.delete(API_KEYS_COLLECTION, id);
-  }
-  async findById(id) {
-    const results = await this.structured.query(API_KEYS_COLLECTION, {
-      where: { id }
-    });
-    if (results.length === 0) {
-      return null;
-    }
-    return results[0].data;
-  }
-};
-
-// src/auth/user-manager.ts
-import * as crypto3 from "crypto";
-var USERS_COLLECTION = "users";
-var UserManager = class {
-  constructor(storageAccess, auth, config) {
-    this.storageAccess = storageAccess;
-    this.auth = auth;
-    this.config = config;
-  }
-  get structured() {
-    return this.storageAccess.getStructuredStorage();
-  }
-  async create(input) {
-    const existing = await this.findByUsername(input.username);
-    if (existing) {
-      throw new Error(`User with username "${input.username}" already exists`);
-    }
-    const passwordHash = await this.auth.hashPassword(input.password);
-    const now = Date.now();
-    const record = {
-      id: crypto3.randomUUID(),
-      username: input.username,
-      passwordHash,
-      role: input.role,
-      allowedProviders: input.allowedProviders ?? "*",
-      allowedDevices: input.allowedDevices ?? {},
-      createdAt: now,
-      updatedAt: now
-    };
-    await this.structured.insert({
-      collection: USERS_COLLECTION,
-      id: record.id,
-      data: record
-    });
-    return record;
-  }
-  async findByUsername(username) {
-    const results = await this.structured.query(USERS_COLLECTION, {
-      where: { username }
-    });
-    if (results.length === 0) {
-      return null;
-    }
-    return results[0].data;
-  }
-  async findById(id) {
-    const results = await this.structured.query(USERS_COLLECTION, {
-      where: { id }
-    });
-    if (results.length === 0) {
-      return null;
-    }
-    return results[0].data;
-  }
-  async validateCredentials(username, password) {
-    const user = await this.findByUsername(username);
-    if (!user) {
-      return null;
-    }
-    const valid = await this.auth.comparePassword(password, user.passwordHash);
-    return valid ? user : null;
-  }
-  async listAll() {
-    const results = await this.structured.query(USERS_COLLECTION);
-    return results.map((r) => {
-      const { passwordHash, ...rest } = r.data;
-      return rest;
-    });
-  }
-  async update(id, data) {
-    const existing = await this.findById(id);
-    if (!existing) {
-      throw new Error(`User with id "${id}" not found`);
-    }
-    const updatedData = {
-      ...existing,
-      ...data,
-      updatedAt: Date.now()
-    };
-    await this.structured.update(USERS_COLLECTION, id, updatedData);
-  }
-  async delete(id) {
-    await this.structured.delete(USERS_COLLECTION, id);
-  }
-  async resetPassword(id, newPassword) {
-    const existing = await this.findById(id);
-    if (!existing) {
-      throw new Error(`User with id "${id}" not found`);
-    }
-    const passwordHash = await this.auth.hashPassword(newPassword);
-    const updatedData = {
-      ...existing,
-      passwordHash,
-      updatedAt: Date.now()
-    };
-    await this.structured.update(USERS_COLLECTION, id, updatedData);
-  }
-  async ensureAdminExists() {
-    const adminUsername = this.config.get("auth.adminUsername");
-    const adminPassword = this.config.get("auth.adminPassword");
-    if (!adminUsername || !adminPassword) {
-      return;
-    }
-    const existing = await this.findByUsername(adminUsername);
-    if (existing) {
-      return;
-    }
-    await this.create({
-      username: adminUsername,
-      password: adminPassword,
-      role: "super_admin",
-      allowedProviders: "*",
-      allowedDevices: {}
-    });
-  }
-};
-
-// src/auth/scoped-token-manager.ts
-import * as crypto4 from "crypto";
-var TOKENS_COLLECTION = "scoped_tokens";
-var TOKEN_PREFIX = "cst_";
-var ScopedTokenManager = class {
-  constructor(storage) {
-    this.storage = storage;
-  }
-  /**
-   * Create a new scoped token. Returns the raw token string (shown once)
-   * and the stored record (with hash, not the raw token).
-   */
-  async create(userId, name, scopes, expiresAt) {
-    const rawHex = crypto4.randomBytes(32).toString("hex");
-    const rawToken = `${TOKEN_PREFIX}${rawHex}`;
-    const tokenHash = crypto4.createHash("sha256").update(rawToken).digest("hex");
-    const tokenPrefix = rawToken.slice(0, 12);
-    const record = {
-      id: crypto4.randomUUID(),
-      userId,
-      name,
-      tokenHash,
-      tokenPrefix,
-      scopes: scopes.map((s) => ({ ...s })),
-      expiresAt,
-      lastUsedAt: void 0,
-      createdAt: Date.now()
-    };
-    await this.storage.insert({
-      collection: TOKENS_COLLECTION,
-      id: record.id,
-      data: record
-    });
-    return { token: rawToken, record };
-  }
-  /**
-   * Validate a raw token string. Returns the token record if valid, null otherwise.
-   */
-  async validate(rawToken) {
-    if (!rawToken.startsWith(TOKEN_PREFIX)) {
-      return null;
-    }
-    const tokenHash = crypto4.createHash("sha256").update(rawToken).digest("hex");
-    const results = await this.storage.query(TOKENS_COLLECTION, {
-      where: { tokenHash }
-    });
-    if (results.length === 0) {
-      return null;
-    }
-    const record = results[0].data;
-    if (record.expiresAt !== void 0 && record.expiresAt !== null && Date.now() > record.expiresAt) {
-      return null;
-    }
-    this.updateLastUsed(record.id).catch(() => {
-    });
-    return record;
-  }
-  /**
-   * Check whether a token's scopes grant access to the given addon, route, or capability.
-   */
-  matchesScope(token, addonId, routePath, capability) {
-    for (const scope of token.scopes) {
-      switch (scope.type) {
-        case "addon":
-          if (addonId && scope.target === addonId) return true;
-          break;
-        case "route-prefix":
-          if (routePath && routePath.startsWith(scope.target)) return true;
-          break;
-        case "capability":
-          if (capability && scope.target === capability) return true;
-          break;
-      }
-    }
-    return false;
-  }
-  /**
-   * Revoke a token by ID.
-   */
-  async revoke(tokenId) {
-    await this.storage.delete(TOKENS_COLLECTION, tokenId);
-  }
-  /**
-   * List all tokens for a user (without exposing the raw token).
-   */
-  async listForUser(userId) {
-    const results = await this.storage.query(TOKENS_COLLECTION, {
-      where: { userId }
-    });
-    return results.map((r) => r.data);
-  }
-  /**
-   * Update the lastUsedAt timestamp for a token.
-   */
-  async updateLastUsed(tokenId) {
-    const results = await this.storage.query(TOKENS_COLLECTION, {
-      where: { id: tokenId }
-    });
-    if (results.length === 0) return;
-    const existing = results[0].data;
-    await this.storage.update(TOKENS_COLLECTION, tokenId, {
-      ...existing,
-      lastUsedAt: Date.now()
-    });
-  }
-};
-
 // src/notification/notification-service.ts
+import { errMsg as errMsg2 } from "@camstack/types";
 var NotificationService = class {
   constructor(logger) {
     this.logger = logger;
   }
+  logger;
   localOutputs = /* @__PURE__ */ new Map();
   routing = /* @__PURE__ */ new Map();
   rateLimits = /* @__PURE__ */ new Map();
@@ -2692,15 +1573,15 @@ var NotificationService = class {
     }
     return this.localOutputs;
   }
-  /** @deprecated Use registry-based resolution. Kept for backward compat only. */
-  addOutput(output) {
+  /** Register an output in the local fallback map (used when no registry is set). */
+  registerLocalOutput(output) {
     this.localOutputs.set(output.id, output);
-    this.logger.info(`Notification output added: ${output.name} (${output.id})`);
+    this.logger.info("Notification output added", { meta: { name: output.name, outputId: output.id } });
   }
-  /** @deprecated Use registry-based resolution. Kept for backward compat only. */
-  removeOutput(id) {
+  /** Remove an output from the local fallback map. */
+  unregisterLocalOutput(id) {
     this.localOutputs.delete(id);
-    this.logger.info(`Notification output removed: ${id}`);
+    this.logger.info("Notification output removed", { meta: { outputId: id } });
   }
   setRouting(category, outputIds) {
     this.routing.set(category, [...outputIds]);
@@ -2715,13 +1596,13 @@ var NotificationService = class {
     if (minInterval > 0) {
       const last = this.lastSent.get(rateLimitKey) ?? 0;
       if (notification.timestamp - last < minInterval) {
-        this.logger.debug(`Rate limited: ${rateLimitKey}`);
+        this.logger.debug("Rate limited", { meta: { rateLimitKey } });
         return;
       }
     }
     const targetIds = this.routing.get(category) ?? this.routing.get("*") ?? [];
     if (targetIds.length === 0) {
-      this.logger.debug(`No routing configured for category "${category}"`);
+      this.logger.debug("No routing configured for category", { meta: { category } });
       return;
     }
     const currentOutputs = this.outputs;
@@ -2731,8 +1612,8 @@ var NotificationService = class {
         try {
           await output.send(notification);
         } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          this.logger.error(`Notification output "${output.id}" failed: ${msg}`);
+          const msg = errMsg2(err);
+          this.logger.error("Notification output failed", { meta: { outputId: output.id, error: msg } });
         }
       })
     );
@@ -2865,142 +1746,19 @@ function matchPath(pattern, path5) {
   return params;
 }
 
-// src/device/device-registry.ts
-import { randomUUID as randomUUID6 } from "crypto";
-var DeviceRegistry = class {
-  constructor(eventBus, loggingService) {
-    this.eventBus = eventBus;
-    this.logger = loggingService.createLogger("device-registry");
-  }
-  devices = /* @__PURE__ */ new Map();
-  logger;
-  registerDevice(device) {
-    this.devices.set(device.id, device);
-    this.logger.info(`Device registered: ${device.id} (${device.name})`);
-    this.eventBus.emit({
-      id: randomUUID6(),
-      timestamp: /* @__PURE__ */ new Date(),
-      source: { type: "core", id: "device-registry" },
-      category: "device.registered",
-      data: { deviceId: device.id, name: device.name, providerId: device.providerId }
-    });
-  }
-  unregisterDevice(id) {
-    const device = this.devices.get(id);
-    if (!device) {
-      return;
-    }
-    this.devices.delete(id);
-    this.logger.info(`Device unregistered: ${id}`);
-    this.eventBus.emit({
-      id: randomUUID6(),
-      timestamp: /* @__PURE__ */ new Date(),
-      source: { type: "core", id: "device-registry" },
-      category: "device.unregistered",
-      data: { deviceId: id }
-    });
-  }
-  getDevice(id) {
-    return this.devices.get(id) ?? null;
-  }
-  listDevices() {
-    return Array.from(this.devices.values());
-  }
-  getDevicesByProvider(providerId) {
-    return Array.from(this.devices.values()).filter(
-      (device) => device.providerId === providerId
-    );
-  }
-  getDevicesWithCapability(cap) {
-    return Array.from(this.devices.values()).filter(
-      (device) => device.capabilities.includes(cap)
-    );
-  }
-  registerProviderDevices(providerId, devices) {
-    for (const device of devices) {
-      this.registerDevice(device);
-    }
-    this.logger.info(`Bulk registered ${devices.length} devices for provider ${providerId}`);
-  }
-  unregisterProviderDevices(providerId) {
-    const providerDevices = this.getDevicesByProvider(providerId);
-    for (const device of providerDevices) {
-      this.unregisterDevice(device.id);
-    }
-    this.logger.info(`Bulk unregistered ${providerDevices.length} devices for provider ${providerId}`);
-  }
-};
-
-// src/device/capability-resolver.ts
-var CapabilityResolver = class {
-  constructor(addonRegistry) {
-    this.addonRegistry = addonRegistry;
-  }
-  bindings = /* @__PURE__ */ new Map();
-  resolve(device, cap) {
-    const deviceBindings = this.bindings.get(device.id);
-    const binding = deviceBindings?.[cap];
-    if (binding) {
-      if (binding.source === "disabled") {
-        return null;
-      }
-      if (binding.source === "addon" && binding.addonId) {
-        const addon = this.addonRegistry.getAddon(binding.addonId);
-        if (addon && typeof addon.getCapabilityForDevice === "function") {
-          return addon.getCapabilityForDevice(device, cap, binding.config) ?? null;
-        }
-        return null;
-      }
-    }
-    return device.getCapability(cap);
-  }
-  setBinding(deviceId, cap, binding) {
-    const existing = this.bindings.get(deviceId) ?? {};
-    this.bindings.set(deviceId, { ...existing, [cap]: binding });
-  }
-  removeBinding(deviceId, cap) {
-    const existing = this.bindings.get(deviceId);
-    if (!existing) {
-      return;
-    }
-    const updated = { ...existing };
-    delete updated[cap];
-    this.bindings.set(deviceId, updated);
-  }
-  getBindings(deviceId) {
-    return this.bindings.get(deviceId) ?? {};
-  }
-  getEffectiveCapabilities(device) {
-    const deviceBindings = this.bindings.get(device.id) ?? {};
-    const result = [];
-    for (const cap of device.capabilities) {
-      const binding = deviceBindings[cap];
-      if (!binding || binding.source !== "disabled") {
-        result.push(cap);
-      }
-    }
-    for (const [cap, binding] of Object.entries(deviceBindings)) {
-      if (binding && binding.source === "addon" && !device.capabilities.includes(cap)) {
-        result.push(cap);
-      }
-    }
-    return result;
-  }
-};
-
 // src/tls/cert-manager.ts
 import { X509Certificate } from "crypto";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync } from "fs";
+import { join as join5 } from "path";
 import * as os from "os";
 var execFileAsync2 = promisify2(execFile2);
 async function ensureTlsCert(dataDir, options) {
-  const tlsDir = join8(dataDir, "tls");
-  const certPath = join8(tlsDir, "camstack.crt");
-  const keyPath = join8(tlsDir, "camstack.key");
-  if (existsSync6(certPath) && existsSync6(keyPath)) {
+  const tlsDir = join5(dataDir, "tls");
+  const certPath = join5(tlsDir, "camstack.crt");
+  const keyPath = join5(tlsDir, "camstack.key");
+  if (existsSync4(certPath) && existsSync4(keyPath)) {
     try {
       const certPem = readFileSync(certPath);
       const x509 = new X509Certificate(certPem);
@@ -3011,7 +1769,7 @@ async function ensureTlsCert(dataDir, options) {
     } catch {
     }
   }
-  mkdirSync5(tlsDir, { recursive: true });
+  mkdirSync3(tlsDir, { recursive: true });
   const cn = options?.commonName ?? "camstack.local";
   const validDays = options?.validDays ?? 825;
   const sanDns = /* @__PURE__ */ new Set(["localhost", cn, os.hostname()]);
@@ -3069,316 +1827,52 @@ function loadTlsCert(certPath, keyPath) {
 }
 
 // src/addon/addon-api-factory.ts
+function wrapCallerAsClient(caller) {
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, prop) {
+      if (typeof prop !== "string") return void 0;
+      if (prop === "query" || prop === "mutate") {
+        if (typeof caller !== "function") {
+          throw new Error(
+            `Cannot call .${prop}() \u2014 this tRPC node is not a procedure`
+          );
+        }
+        const fn = caller;
+        return (input) => fn(input);
+      }
+      if (prop === "subscribe") {
+        return () => {
+          throw new Error(
+            `subscribe() is not supported on direct caller \u2014 use the WSS client for subscriptions`
+          );
+        };
+      }
+      const child = caller?.[prop];
+      if (child === void 0 || child === null) return void 0;
+      return wrapCallerAsClient(child);
+    }
+  });
+}
 var AddonApiFactory = class {
-  /**
-   * Build a WSS URL from host and port.
-   */
-  buildWssUrl(host, port) {
-    return `wss://${host}:${port}/trpc`;
-  }
   /**
    * Create a direct caller -- calls tRPC procedures directly in-process.
    * Zero network overhead. Used for in-process addons and dev mode.
    *
-   * @param options.router - The tRPC router from buildAppRouter()
-   * @param options.context - The auth context (service account)
-   * @returns A tRPC caller that can be used as context.api
+   * Returns `AddonApi` — the same tRPC client surface that broker-routed
+   * callers get. Callers treat it uniformly as `context.api` regardless
+   * of the underlying transport.
    */
   async createDirectCaller(options) {
     const { initTRPC } = await import("@trpc/server");
     const t = initTRPC.create();
     const callerFactory = t.createCallerFactory(options.router);
-    return callerFactory(options.context);
-  }
-  /**
-   * Create a WSS tRPC client -- connects to the server via WebSocket.
-   * Used for forked workers and remote agents.
-   *
-   * @param options.url - WSS URL (e.g., wss://localhost:4443/trpc)
-   * @param options.token - Bearer token for authentication
-   * @returns A tRPC client that can be used as context.api
-   */
-  async createWssClient(options) {
-    const { createTRPCClient, createWSClient, wsLink } = await import("./dist-3BY63UQ5.mjs");
-    const wsClient = createWSClient({
-      url: options.url,
-      connectionParams: () => ({ token: options.token })
-    });
-    const client = createTRPCClient({
-      links: [wsLink({ client: wsClient })]
-    });
-    return {
-      client,
-      close: () => wsClient.close()
-    };
-  }
-};
-
-// src/platform/platform-scorer.ts
-import * as os2 from "os";
-import { execFileSync as execFileSync3 } from "child_process";
-async function getAvailableRAM_MB() {
-  try {
-    const si = await import("systeminformation");
-    const mem = await si.mem();
-    return Math.round(mem.available / 1024 / 1024);
-  } catch {
-    const platform2 = os2.platform();
-    try {
-      if (platform2 === "darwin") {
-        const output = execFileSync3("vm_stat", { encoding: "utf8", timeout: 3e3 });
-        const pageSize = parseInt(output.match(/page size of (\d+)/)?.[1] ?? "16384");
-        const free = parseInt(output.match(/Pages free:\s+(\d+)/)?.[1] ?? "0");
-        const inactive = parseInt(output.match(/Pages inactive:\s+(\d+)/)?.[1] ?? "0");
-        const purgeable = parseInt(output.match(/Pages purgeable:\s+(\d+)/)?.[1] ?? "0");
-        return Math.round((free + inactive + purgeable) * pageSize / 1024 / 1024);
-      } else if (platform2 === "linux") {
-        const { readFileSync: readFileSync2 } = await import("fs");
-        const meminfo = readFileSync2("/proc/meminfo", "utf8");
-        const match = meminfo.match(/MemAvailable:\s+(\d+)\s+kB/);
-        if (match) return Math.round(parseInt(match[1]) / 1024);
-      }
-    } catch {
-    }
-    return Math.round(os2.totalmem() / 1024 / 1024);
-  }
-}
-var PlatformScorer = class {
-  cached = null;
-  /** Probe hardware + runtimes and score all backend combos. Cached after first call. */
-  async probe() {
-    if (this.cached) return this.cached;
-    const start = Date.now();
-    console.log("[PlatformScorer] Probing hardware...");
-    const hardware = await this.probeHardware();
-    console.log(`[PlatformScorer] Hardware: ${hardware.platform}/${hardware.arch}, ${hardware.cpuModel} (${hardware.cpuCores} cores), RAM ${Math.round(hardware.totalRAM_MB / 1024)}GB`);
-    if (hardware.gpu) console.log(`[PlatformScorer] GPU: ${hardware.gpu.name}`);
-    if (hardware.npu) console.log(`[PlatformScorer] NPU: ${hardware.npu.type}`);
-    console.log("[PlatformScorer] Probing Node.js backends...");
-    const nodeBackends = await this.probeNodeBackends();
-    console.log(`[PlatformScorer] Node backends: ${nodeBackends.map((b) => b.id).join(", ")}`);
-    console.log("[PlatformScorer] Probing Python backends...");
-    const pythonInfo = this.probePythonBackends();
-    if (pythonInfo.pythonPath) {
-      console.log(`[PlatformScorer] Python: ${pythonInfo.pythonPath} \u2192 ${pythonInfo.backends.filter((b) => b.available).map((b) => b.id).join(", ") || "no backends"}`);
-    } else {
-      console.log("[PlatformScorer] Python: not found");
-    }
-    const scores = this.scoreBackends(hardware, nodeBackends, pythonInfo.backends);
-    const bestScore = scores.find((s) => s.available) ?? scores[scores.length - 1];
-    const elapsed = Date.now() - start;
-    console.log(`[PlatformScorer] Scoring complete in ${elapsed}ms \u2014 ${scores.length} combos`);
-    console.log(`[PlatformScorer] Best: ${bestScore.runtime}/${bestScore.backend} (${bestScore.format}) \u2014 ${bestScore.reason} [score: ${bestScore.score}]`);
-    for (const s of scores) {
-      console.log(`[PlatformScorer]   ${s.available ? "\u2713" : "\u2717"} ${s.runtime}/${s.backend} (${s.format}) \u2014 score ${s.score} \u2014 ${s.reason}`);
-    }
-    this.cached = {
-      hardware,
-      scores,
-      bestScore,
-      pythonPath: pythonInfo.pythonPath
-    };
-    return this.cached;
-  }
-  async probeHardware() {
-    const platform2 = os2.platform();
-    const arch2 = os2.arch();
-    const cpus2 = os2.cpus();
-    const cpuModel = cpus2[0]?.model ?? "unknown";
-    const cpuCores = cpus2.length;
-    const totalRAM_MB = Math.round(os2.totalmem() / 1024 / 1024);
-    const availableRAM_MB = await getAvailableRAM_MB();
-    console.log(`[PlatformScorer] RAM: total=${totalRAM_MB}MB, available=${availableRAM_MB}MB (via systeminformation)`);
-    let gpu = null;
-    let npu = null;
-    if (platform2 === "darwin" && arch2 === "arm64") {
-      gpu = { type: "apple", name: "Apple Silicon GPU" };
-      npu = { type: "apple-ane" };
-    }
-    if (platform2 === "linux") {
-      try {
-        const output = execFileSync3("nvidia-smi", ["--query-gpu=name,memory.total", "--format=csv,noheader"], {
-          encoding: "utf8",
-          timeout: 5e3,
-          stdio: ["pipe", "pipe", "pipe"]
-        }).trim();
-        if (output) {
-          const [name, mem] = output.split(",").map((s) => s.trim());
-          gpu = {
-            type: "nvidia",
-            name: name ?? "NVIDIA GPU",
-            memoryMB: parseInt(mem ?? "0")
-          };
-        }
-      } catch {
-      }
-    }
-    return { platform: platform2, arch: arch2, cpuModel, cpuCores, totalRAM_MB, availableRAM_MB, gpu, npu };
-  }
-  async probeNodeBackends() {
-    const backends = [
-      { id: "cpu", available: true }
-    ];
-    try {
-      const ort = await import("onnxruntime-node");
-      const providers = ort.InferenceSession?.getAvailableProviders?.() ?? [];
-      for (const p of providers) {
-        const n = p.toLowerCase().replace("executionprovider", "");
-        if (n === "coreml") backends.push({ id: "coreml", available: true });
-        else if (n === "cuda") backends.push({ id: "cuda", available: true });
-        else if (n === "tensorrt") backends.push({ id: "tensorrt", available: true });
-      }
-    } catch {
-    }
-    if (os2.platform() === "darwin" && !backends.some((b) => b.id === "coreml")) {
-      backends.push({ id: "coreml", available: true });
-    }
-    return backends;
-  }
-  probePythonBackends() {
-    let pythonPath = null;
-    for (const cmd of ["python3", "python"]) {
-      try {
-        execFileSync3(cmd, ["--version"], { timeout: 5e3, stdio: "pipe" });
-        pythonPath = cmd;
-        break;
-      } catch {
-      }
-    }
-    if (!pythonPath) return { pythonPath: null, backends: [] };
-    const checks = [
-      // [pythonModule, backendId, modelFormat]
-      ["coremltools", "coreml", "coreml"],
-      ["openvino.runtime", "openvino", "openvino"],
-      ["torch", "pytorch", "onnx"],
-      ["onnxruntime", "onnx-py", "onnx"]
-    ];
-    const backends = [];
-    for (const [mod, id, format] of checks) {
-      let available = false;
-      const probeStart = Date.now();
-      try {
-        execFileSync3(pythonPath, ["-c", `import ${mod}`], { timeout: 3e4, stdio: "ignore" });
-        available = true;
-      } catch {
-      }
-      const probeMs = Date.now() - probeStart;
-      console.log(`[PlatformScorer]   Python ${mod}: ${available ? "\u2713" : "\u2717"} (${probeMs}ms)`);
-      if (id === "coreml" && os2.platform() === "darwin") {
-        backends.push({ id, format, available });
-      } else if (available) {
-        backends.push({ id, format, available });
-      }
-    }
-    return { pythonPath, backends };
-  }
-  scoreBackends(hardware, nodeBackends, pythonBackends) {
-    const scores = [];
-    if (hardware.platform === "darwin" && hardware.arch === "arm64") {
-      const pyCoreMl = pythonBackends.find((b) => b.id === "coreml");
-      if (pyCoreMl) {
-        scores.push({ runtime: "python", backend: "coreml", format: "coreml", score: 95, reason: "Apple Neural Engine (Python CoreML)", available: pyCoreMl.available });
-      }
-      const nodeCoreMl = nodeBackends.find((b) => b.id === "coreml");
-      if (nodeCoreMl) {
-        scores.push({ runtime: "node", backend: "coreml", format: "onnx", score: 90, reason: "CoreML via ONNX Runtime", available: nodeCoreMl.available });
-      }
-    }
-    if (hardware.gpu?.type === "nvidia") {
-      const tensorrt = nodeBackends.find((b) => b.id === "tensorrt");
-      if (tensorrt) scores.push({ runtime: "node", backend: "tensorrt", format: "onnx", score: 95, reason: "NVIDIA TensorRT", available: true });
-      const cuda = nodeBackends.find((b) => b.id === "cuda");
-      if (cuda) scores.push({ runtime: "node", backend: "cuda", format: "onnx", score: 85, reason: "NVIDIA CUDA", available: true });
-    }
-    const openvino = pythonBackends.find((b) => b.id === "openvino");
-    if (openvino) {
-      const score = hardware.npu?.type === "intel-npu" ? 90 : 80;
-      scores.push({ runtime: "python", backend: "openvino", format: "openvino", score, reason: "Intel OpenVINO", available: openvino.available });
-    }
-    scores.push({ runtime: "node", backend: "cpu", format: "onnx", score: 50, reason: "CPU (ONNX Runtime Node)", available: true });
-    const pyOnnx = pythonBackends.find((b) => b.id === "onnx-py");
-    if (pyOnnx) {
-      scores.push({ runtime: "python", backend: "cpu", format: "onnx", score: 45, reason: "CPU (Python ONNX)", available: pyOnnx.available });
-    }
-    return scores.sort((a, b) => b.score - a.score);
-  }
-};
-
-// src/platform/inference-config-resolver.ts
-var InferenceConfigResolver = class {
-  constructor(scores, hardware) {
-    this.scores = scores;
-    this.hardware = hardware;
-  }
-  /**
-   * Compute accuracy/backend weights based on available system RAM.
-   * availableRAM_MB is now sourced from systeminformation (reliable cross-platform),
-   * not os.freemem() which is broken on macOS.
-   *
-   * - > 16 GB available: prefer larger, more accurate models (accuracy 0.6, backend 0.4)
-   * - > 8 GB available:  balanced (accuracy 0.5, backend 0.5)
-   * - <= 8 GB available: prefer speed (accuracy 0.4, backend 0.6)
-   */
-  getWeights() {
-    const ramMB = this.hardware.availableRAM_MB;
-    if (ramMB > 16384) return { accuracyWeight: 0.6, backendWeight: 0.4 };
-    if (ramMB > 8192) return { accuracyWeight: 0.5, backendWeight: 0.5 };
-    return { accuracyWeight: 0.4, backendWeight: 0.6 };
-  }
-  /**
-   * Given an addon's model requirements, pick the best model + runtime + backend.
-   *
-   * Algorithm:
-   * 1. Filter models by available RAM (minRAM_MB < 25% of available RAM)
-   * 2. For each remaining model, find the best platform score whose format
-   *    is available in the model's formats
-   * 3. Pick the model with the highest combined score using RAM-adaptive weights:
-   *    - High RAM (>16 GB): accuracy × 0.6 + backend × 0.4  (prefer accuracy)
-   *    - Mid RAM  (>8 GB):  accuracy × 0.5 + backend × 0.5  (balanced)
-   *    - Low RAM  (<=8 GB): accuracy × 0.4 + backend × 0.6  (prefer speed)
-   */
-  resolve(requirements) {
-    if (requirements.length === 0) {
-      return { modelId: "", runtime: "node", backend: "cpu", format: "onnx", reason: "No models declared" };
-    }
-    const ramBudget = this.hardware.availableRAM_MB * 0.25;
-    const { accuracyWeight, backendWeight } = this.getWeights();
-    console.log(`[InferenceConfigResolver] availableRAM: ${this.hardware.availableRAM_MB}MB, budget: ${Math.round(ramBudget)}MB, weights: accuracy=${accuracyWeight}, backend=${backendWeight}`);
-    const fits = requirements.filter((m) => m.minRAM_MB < ramBudget);
-    const candidates = fits.length > 0 ? fits : [requirements[0]];
-    console.log(`[InferenceConfigResolver] ${candidates.length}/${requirements.length} models fit RAM budget`);
-    let bestCombo = null;
-    for (const model of candidates) {
-      for (const score of this.scores) {
-        if (!score.available) continue;
-        if (!model.formats.includes(score.format)) continue;
-        const combined = model.accuracyScore * accuracyWeight + score.score * backendWeight;
-        if (!bestCombo || combined > bestCombo.combined) {
-          console.log(`[InferenceConfigResolver] New best: ${model.modelId} (accuracy=${model.accuracyScore}) + ${score.backend}/${score.format} (score=${score.score}) \u2192 combined=${Math.round(combined)}`);
-          bestCombo = { model, score, combined };
-        }
-      }
-    }
-    if (!bestCombo) {
-      return {
-        modelId: candidates[0].modelId,
-        runtime: "node",
-        backend: "cpu",
-        format: "onnx",
-        reason: "No compatible backend \u2014 CPU fallback"
-      };
-    }
-    return {
-      modelId: bestCombo.model.modelId,
-      runtime: bestCombo.score.runtime,
-      backend: bestCombo.score.backend,
-      format: bestCombo.score.format,
-      reason: `${bestCombo.model.name} on ${bestCombo.score.reason} (score: ${Math.round(bestCombo.combined)})`
-    };
+    const caller = callerFactory(options.context);
+    return wrapCallerAsClient(caller);
   }
 };
 
 // src/builtins/sqlite-storage/integration-registry.ts
+import { parseJsonObject } from "@camstack/types";
 function serializeSetting(value) {
   if (typeof value === "number") return { value: String(value), valueType: "number" };
   if (typeof value === "boolean") return { value: String(value), valueType: "boolean" };
@@ -3479,10 +1973,10 @@ var IntegrationRegistry = class {
     }
   }
   // --- Integrations ---
-  createIntegration(input) {
+  async createIntegration(input) {
     const id = nextIntegrationId();
     const now = Math.floor(Date.now() / 1e3);
-    void this.backend.tableInsert?.("integrations", {
+    await this.backend.tableInsert?.("integrations", {
       id,
       addon_id: input.addonId,
       name: input.name,
@@ -3492,7 +1986,7 @@ var IntegrationRegistry = class {
       updated_at: now
     });
     if (input.settings) {
-      this.setIntegrationSettings(id, input.settings);
+      await this.setIntegrationSettings(id, input.settings);
     }
     return {
       id,
@@ -3504,75 +1998,65 @@ var IntegrationRegistry = class {
       updatedAt: now
     };
   }
-  getIntegration(id) {
-    let result = null;
-    void this.backend.tableGet?.("integrations", { id }).then((row) => {
-      if (row) result = this.mapIntegration(row);
-    });
-    return result;
+  async getIntegration(id) {
+    const row = await this.backend.tableGet?.("integrations", { id });
+    return row ? this.mapIntegration(row) : null;
   }
-  getIntegrationByAddonId(addonId) {
-    let result = null;
-    void this.backend.tableGet?.("integrations", { addon_id: addonId }).then((row) => {
-      if (row) result = this.mapIntegration(row);
-    });
-    return result;
+  async getIntegrationByAddonId(addonId) {
+    const row = await this.backend.tableGet?.("integrations", { addon_id: addonId });
+    return row ? this.mapIntegration(row) : null;
   }
-  listIntegrations() {
-    let result = [];
-    void this.backend.tableQuery?.("integrations", { orderBy: { field: "created_at", direction: "asc" } }).then((rows) => {
-      result = rows.map((r) => this.mapIntegration(r));
-    });
-    return result;
+  async listIntegrations() {
+    const rows = await this.backend.tableQuery?.("integrations", { orderBy: { field: "created_at", direction: "asc" } }) ?? [];
+    return rows.map((r) => this.mapIntegration(r));
   }
-  updateIntegration(id, updates) {
+  async updateIntegration(id, updates) {
     const updateRow = { updated_at: Math.floor(Date.now() / 1e3) };
     if (updates.name !== void 0) updateRow["name"] = updates.name;
     if (updates.enabled !== void 0) updateRow["enabled"] = updates.enabled ? 1 : 0;
     if (updates.info !== void 0) updateRow["info"] = JSON.stringify(updates.info);
-    void this.backend.tableUpdate?.("integrations", { id }, updateRow);
+    await this.backend.tableUpdate?.("integrations", { id }, updateRow);
     return this.getIntegration(id);
   }
-  deleteIntegration(id) {
-    const devices = this.listDevices(id);
+  async deleteIntegration(id) {
+    const devices = await this.listDevices(id);
     for (const d of devices) {
-      void this.backend.tableDelete?.("device_settings_kv", { device_id: d.id });
+      await this.backend.tableDelete?.("device_settings_kv", { device_id: d.id });
     }
-    void this.backend.tableDelete?.("devices", { integration_id: id });
-    void this.backend.tableDelete?.("integration_settings", { integration_id: id });
-    void this.backend.tableDelete?.("integrations", { id });
+    await this.backend.tableDelete?.("devices", { integration_id: id });
+    await this.backend.tableDelete?.("integration_settings", { integration_id: id });
+    await this.backend.tableDelete?.("integrations", { id });
     return true;
   }
   // --- Integration Settings ---
-  getIntegrationSettings(integrationId) {
+  async getIntegrationSettings(integrationId) {
     const result = {};
-    void this.backend.tableQuery?.("integration_settings", { where: { integration_id: integrationId } }).then((rows) => {
-      for (const row of rows) {
-        result[String(row["key"])] = deserializeSetting(String(row["value"]), String(row["value_type"]));
-      }
-    });
+    const rows = await this.backend.tableQuery?.("integration_settings", { where: { integration_id: integrationId } }) ?? [];
+    for (const row of rows) {
+      result[String(row["key"])] = deserializeSetting(String(row["value"]), String(row["value_type"]));
+    }
     return result;
   }
-  setIntegrationSetting(integrationId, key, value) {
+  async setIntegrationSetting(integrationId, key, value) {
     const s = serializeSetting(value);
-    void this.backend.tableDelete?.("integration_settings", { integration_id: integrationId, key });
-    void this.backend.tableInsert?.("integration_settings", {
+    await this.backend.tableDelete?.("integration_settings", { integration_id: integrationId, key });
+    await this.backend.tableInsert?.("integration_settings", {
       integration_id: integrationId,
       key,
       value: s.value,
       value_type: s.valueType
     });
   }
-  setIntegrationSettings(integrationId, settings) {
+  async setIntegrationSettings(integrationId, settings) {
     for (const [key, value] of Object.entries(settings)) {
-      this.setIntegrationSetting(integrationId, key, value);
+      await this.setIntegrationSetting(integrationId, key, value);
     }
   }
   // --- Devices ---
-  createDevice(input) {
+  async createDevice(input) {
     const id = nextDeviceId();
     const now = Math.floor(Date.now() / 1e3);
-    void this.backend.tableInsert?.("devices", {
+    await this.backend.tableInsert?.("devices", {
       id,
       integration_id: input.integrationId,
       stable_id: input.stableId,
@@ -3584,7 +2068,7 @@ var IntegrationRegistry = class {
       updated_at: now
     });
     if (input.settings) {
-      this.setDeviceSettings(id, input.settings);
+      await this.setDeviceSettings(id, input.settings);
     }
     return {
       id,
@@ -3598,71 +2082,58 @@ var IntegrationRegistry = class {
       updatedAt: now
     };
   }
-  getDevice(id) {
-    let result = null;
-    void this.backend.tableGet?.("devices", { id }).then((row) => {
-      if (row) result = this.mapDevice(row);
-    });
-    return result;
+  async getDevice(id) {
+    const row = await this.backend.tableGet?.("devices", { id });
+    return row ? this.mapDevice(row) : null;
   }
-  getDeviceByStableId(stableId) {
-    let result = null;
-    void this.backend.tableGet?.("devices", { stable_id: stableId }).then((row) => {
-      if (row) result = this.mapDevice(row);
-    });
-    return result;
+  async getDeviceByStableId(stableId) {
+    const row = await this.backend.tableGet?.("devices", { stable_id: stableId });
+    return row ? this.mapDevice(row) : null;
   }
-  listDevices(integrationId) {
-    let result = [];
+  async listDevices(integrationId) {
     const options = integrationId ? { where: { integration_id: integrationId }, orderBy: { field: "created_at", direction: "asc" } } : { orderBy: { field: "created_at", direction: "asc" } };
-    void this.backend.tableQuery?.("devices", options).then((rows) => {
-      result = rows.map((r) => this.mapDevice(r));
-    });
-    return result;
+    const rows = await this.backend.tableQuery?.("devices", options) ?? [];
+    return rows.map((r) => this.mapDevice(r));
   }
-  listCameras() {
-    let result = [];
-    void this.backend.tableQuery?.("devices", { where: { type: "camera" }, orderBy: { field: "created_at", direction: "asc" } }).then((rows) => {
-      result = rows.map((r) => this.mapDevice(r));
-    });
-    return result;
+  async listCameras() {
+    const rows = await this.backend.tableQuery?.("devices", { where: { type: "camera" }, orderBy: { field: "created_at", direction: "asc" } }) ?? [];
+    return rows.map((r) => this.mapDevice(r));
   }
-  updateDevice(id, updates) {
+  async updateDevice(id, updates) {
     const updateRow = { updated_at: Math.floor(Date.now() / 1e3) };
     if (updates.name !== void 0) updateRow["name"] = updates.name;
     if (updates.enabled !== void 0) updateRow["enabled"] = updates.enabled ? 1 : 0;
     if (updates.info !== void 0) updateRow["info"] = JSON.stringify(updates.info);
-    void this.backend.tableUpdate?.("devices", { id }, updateRow);
+    await this.backend.tableUpdate?.("devices", { id }, updateRow);
     return this.getDevice(id);
   }
-  deleteDevice(id) {
-    void this.backend.tableDelete?.("device_settings_kv", { device_id: id });
-    void this.backend.tableDelete?.("devices", { id });
+  async deleteDevice(id) {
+    await this.backend.tableDelete?.("device_settings_kv", { device_id: id });
+    await this.backend.tableDelete?.("devices", { id });
     return true;
   }
   // --- Device Settings ---
-  getDeviceSettings(deviceId) {
+  async getDeviceSettings(deviceId) {
     const result = {};
-    void this.backend.tableQuery?.("device_settings_kv", { where: { device_id: deviceId } }).then((rows) => {
-      for (const row of rows) {
-        result[String(row["key"])] = deserializeSetting(String(row["value"]), String(row["value_type"]));
-      }
-    });
+    const rows = await this.backend.tableQuery?.("device_settings_kv", { where: { device_id: deviceId } }) ?? [];
+    for (const row of rows) {
+      result[String(row["key"])] = deserializeSetting(String(row["value"]), String(row["value_type"]));
+    }
     return result;
   }
-  setDeviceSetting(deviceId, key, value) {
+  async setDeviceSetting(deviceId, key, value) {
     const s = serializeSetting(value);
-    void this.backend.tableDelete?.("device_settings_kv", { device_id: deviceId, key });
-    void this.backend.tableInsert?.("device_settings_kv", {
+    await this.backend.tableDelete?.("device_settings_kv", { device_id: deviceId, key });
+    await this.backend.tableInsert?.("device_settings_kv", {
       device_id: deviceId,
       key,
       value: s.value,
       value_type: s.valueType
     });
   }
-  setDeviceSettings(deviceId, settings) {
+  async setDeviceSettings(deviceId, settings) {
     for (const [key, value] of Object.entries(settings)) {
-      this.setDeviceSetting(deviceId, key, value);
+      await this.setDeviceSetting(deviceId, key, value);
     }
   }
   // --- Mappers ---
@@ -3672,7 +2143,7 @@ var IntegrationRegistry = class {
       addonId: String(row["addon_id"]),
       name: String(row["name"]),
       enabled: row["enabled"] === 1,
-      info: typeof row["info"] === "string" ? JSON.parse(row["info"]) : {},
+      info: typeof row["info"] === "string" ? parseJsonObject(row["info"]) ?? {} : {},
       createdAt: Number(row["created_at"]),
       updatedAt: Number(row["updated_at"])
     };
@@ -3685,214 +2156,85 @@ var IntegrationRegistry = class {
       type: String(row["type"]),
       name: String(row["name"]),
       enabled: row["enabled"] === 1,
-      info: typeof row["info"] === "string" ? JSON.parse(row["info"]) : {},
+      info: typeof row["info"] === "string" ? parseJsonObject(row["info"]) ?? {} : {},
       createdAt: Number(row["created_at"]),
       updatedAt: Number(row["updated_at"])
     };
   }
 };
-
-// src/provider/provider-manager.ts
-import { randomUUID as randomUUID7 } from "crypto";
-var ProviderManager = class {
-  constructor(deviceRegistry, eventBus, loggingService) {
-    this.deviceRegistry = deviceRegistry;
-    this.eventBus = eventBus;
-    this.loggingService = loggingService;
-    this.logger = loggingService.createLogger("provider-manager");
-  }
-  providers = /* @__PURE__ */ new Map();
-  logger;
-  registerProvider(provider) {
-    const providerLogger = this.loggingService.createLogger(`provider:${provider.id}`);
-    const lifecycle = new LifecycleStateMachine(
-      provider.id,
-      "provider",
-      this.eventBus,
-      providerLogger
-    );
-    this.providers.set(provider.id, { provider, lifecycle, started: false });
-    this.logger.info(`Provider registered: ${provider.id} (${provider.name})`);
-  }
-  async startProvider(id) {
-    const entry = this.providers.get(id);
-    if (!entry) {
-      throw new Error(`Provider "${id}" is not registered`);
-    }
-    if (entry.lifecycle.state === "disabled") {
-      throw new Error(`Provider "${id}" is disabled`);
-    }
-    entry.lifecycle.transition("starting");
-    try {
-      await entry.provider.start();
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      entry.lifecycle.transition("error", message);
-      throw err;
-    }
-    entry.lifecycle.transition("running");
-    const devices = entry.provider.getDevices();
-    this.deviceRegistry.registerProviderDevices(id, devices);
-    const unsubscribe = entry.provider.subscribeLiveEvents((event) => {
-      this.eventBus.emit({
-        id: randomUUID7(),
-        timestamp: /* @__PURE__ */ new Date(),
-        source: { type: "provider", id },
-        category: `provider.${event.type}`,
-        data: event.data
-      });
-    });
-    entry.started = true;
-    entry.unsubscribe = unsubscribe;
-    this.eventBus.emit({
-      id: randomUUID7(),
-      timestamp: /* @__PURE__ */ new Date(),
-      source: { type: "core", id: "provider-manager" },
-      category: "provider.started",
-      data: { providerId: id }
-    });
-    this.logger.info(`Provider started: ${id}`);
-  }
-  async stopProvider(id) {
-    const entry = this.providers.get(id);
-    if (!entry) {
-      throw new Error(`Provider "${id}" is not registered`);
-    }
-    entry.lifecycle.transition("stopping");
-    if (entry.unsubscribe) {
-      entry.unsubscribe();
-      entry.unsubscribe = void 0;
-    }
-    this.deviceRegistry.unregisterProviderDevices(id);
-    await entry.provider.stop();
-    entry.started = false;
-    entry.lifecycle.transition("stopped");
-    this.eventBus.emit({
-      id: randomUUID7(),
-      timestamp: /* @__PURE__ */ new Date(),
-      source: { type: "core", id: "provider-manager" },
-      category: "provider.stopped",
-      data: { providerId: id }
-    });
-    this.logger.info(`Provider stopped: ${id}`);
-  }
-  async disableProvider(id) {
-    const entry = this.providers.get(id);
-    if (!entry) {
-      throw new Error(`Provider "${id}" is not registered`);
-    }
-    if (entry.lifecycle.state === "running" || entry.started) {
-      await this.stopProvider(id);
-    }
-    entry.lifecycle.transition("disabled");
-    this.logger.info(`Provider disabled: ${id}`);
-  }
-  async enableProvider(id) {
-    const entry = this.providers.get(id);
-    if (!entry) {
-      throw new Error(`Provider "${id}" is not registered`);
-    }
-    if (entry.lifecycle.state !== "disabled") {
-      throw new Error(`Provider "${id}" is not disabled`);
-    }
-    entry.lifecycle.transition("stopped");
-    this.logger.info(`Provider enabled: ${id}`);
-  }
-  async restartProvider(id) {
-    await this.stopProvider(id);
-    await this.startProvider(id);
-  }
-  getProvider(id) {
-    const entry = this.providers.get(id);
-    return entry?.provider ?? null;
-  }
-  getProviderStatus(id) {
-    const entry = this.providers.get(id);
-    return entry?.lifecycle.getStatus() ?? null;
-  }
-  listProviders() {
-    return Array.from(this.providers.values()).map((entry) => ({
-      id: entry.provider.id,
-      type: entry.provider.type,
-      name: entry.provider.name,
-      status: entry.provider.getStatus(),
-      started: entry.started,
-      lifecycle: entry.lifecycle.getStatus()
-    }));
-  }
-  async shutdownAll() {
-    const startedIds = Array.from(this.providers.entries()).filter(([, entry]) => entry.started).map(([id]) => id);
-    for (const id of startedIds) {
-      await this.stopProvider(id);
-    }
-    this.logger.info(`All providers shut down (${startedIds.length} stopped)`);
-  }
-};
 export {
   AddonApiFactory,
   AddonRouteRegistry,
-  AgentClient,
-  AgentRegistry,
-  AgentTaskRunner,
+  AlertCenterAddon,
   ApiKeyManager,
   AuthManager,
   CORE_TABLE_DDL,
-  CapabilityResolver,
-  DecodeTaskHandler,
-  DetectTaskHandler,
-  DeviceRegistry,
+  ConfigStore,
+  ConsoleDestination,
+  ConsoleLoggingAddon,
+  DeviceManagerAddon,
+  DeviceStore,
+  EngineManagerResolver,
   EventBus,
   FeatureManager,
-  FileSystemStorage,
+  FilesystemStorageAddon,
+  FilesystemStorageProvider,
   FsStorageBackend,
-  InferenceConfigResolver,
+  HubForwarderAddon,
+  HubForwarderDestination,
   IntegrationRegistry,
   LifecycleStateMachine,
+  LocalAuthAddon,
   LocalBackupAddon,
   LocalBackupService,
   LogManager,
   LogRingBuffer,
-  ManagedProcess,
   ModelDownloadService,
+  NativeMetricsAddon,
+  NativeMetricsProvider,
   NetworkQualityTracker,
   NotificationService,
   PYTHON_VERSION,
   PipelineRunner,
   PipelineValidator,
-  PlatformScorer,
-  ProcessManager,
-  ProviderManager,
   PythonEnvManager,
-  RecordTaskHandler,
   ReplEngine,
   ScopedLogger,
   ScopedTokenManager,
   SettingsStore,
-  SqliteStorageAddon,
-  SqliteStorageProvider,
+  SqliteSettingsAddon,
+  SqliteSettingsBackend,
   StorageLocationManager,
   StorageManager,
+  SystemConfigAddon,
   SystemEventBus,
-  TaskDispatcher,
   ToastService,
   UserManager,
   WinstonDestination,
   WinstonLoggingAddon,
   addonTableToDdl,
   buildBinaryPath,
+  deleteModelFromDisk,
   downloadBinary,
   downloadFile,
   downloadModel,
   ensureBinary,
   ensureFfmpeg,
+  ensureModel,
   ensurePython,
   ensureTlsCert,
   fetchJson,
   findInPath,
+  formatLogLine,
   getFfmpegDownloadUrl,
+  getModelFilePath,
+  getPidStats,
   getPlatformInfo,
   getPythonDownloadUrl,
+  getSinglePidStats,
   installPythonPackages,
+  installPythonRequirements,
+  isModelDownloaded,
   loadTlsCert
 };
 //# sourceMappingURL=index.mjs.map