@camstack/core 0.1.0

package/dist/index.js

@@ -0,0 +1,666 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AddonEngineManager: () => AddonEngineManager,
+  AddonInstaller: () => AddonInstaller,
+  AddonLoader: () => AddonLoader,
+  BUILTIN_PACKAGES: () => BUILTIN_PACKAGES,
+  EventBus: () => EventBus,
+  PipelineRunner: () => PipelineRunner,
+  PipelineValidator: () => PipelineValidator,
+  PythonEnvManager: () => PythonEnvManager,
+  downloadModel: () => downloadModel
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/events/event-bus.ts
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, callback) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    const set = this.listeners.get(event);
+    set.add(callback);
+    return () => set.delete(callback);
+  }
+  emit(event, data) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const cb of set) {
+      try {
+        cb(data);
+      } catch {
+      }
+    }
+  }
+  once(event, callback) {
+    const unsub = this.on(event, (data) => {
+      unsub();
+      callback(data);
+    });
+    return unsub;
+  }
+  removeAllListeners(event) {
+    if (event) this.listeners.delete(event);
+    else this.listeners.clear();
+  }
+  listenerCount(event) {
+    return this.listeners.get(event)?.size ?? 0;
+  }
+};
+
+// src/download/model-downloader.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var https = __toESM(require("https"));
+var http = __toESM(require("http"));
+var import_node_crypto = require("crypto");
+async function downloadModel(options) {
+  const { url, fallbackUrls = [], destDir, filename, expectedSha256, onProgress } = options;
+  const fname = filename ?? url.split("/").pop() ?? "model.bin";
+  const destPath = path.join(destDir, fname);
+  if (fs.existsSync(destPath)) {
+    return { filePath: destPath, downloadedBytes: 0, fromCache: true };
+  }
+  fs.mkdirSync(destDir, { recursive: true });
+  const urls = [url, ...fallbackUrls];
+  let lastError = null;
+  for (const tryUrl of urls) {
+    try {
+      const bytes = await downloadFile(tryUrl, destPath, onProgress);
+      if (expectedSha256) {
+        const hash = await computeSha256(destPath);
+        if (hash !== expectedSha256) {
+          fs.unlinkSync(destPath);
+          throw new Error(`SHA256 mismatch: expected ${expectedSha256}, got ${hash}`);
+        }
+      }
+      return { filePath: destPath, downloadedBytes: bytes, fromCache: false };
+    } catch (e) {
+      lastError = e;
+      if (fs.existsSync(destPath)) fs.unlinkSync(destPath);
+    }
+  }
+  throw lastError ?? new Error(`Failed to download model from ${url}`);
+}
+async function downloadFile(url, destPath, onProgress) {
+  return new Promise((resolve, reject) => {
+    const mod = url.startsWith("https") ? https : http;
+    const request = (targetUrl, redirectCount = 0) => {
+      if (redirectCount > 5) return reject(new Error("Too many redirects"));
+      mod.get(targetUrl, (res) => {
+        if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          return request(res.headers.location, redirectCount + 1);
+        }
+        if (res.statusCode !== 200) {
+          return reject(new Error(`HTTP ${res.statusCode} downloading ${targetUrl}`));
+        }
+        const total = parseInt(res.headers["content-length"] ?? "0", 10);
+        let downloaded = 0;
+        const fileStream = fs.createWriteStream(destPath);
+        res.on("data", (chunk) => {
+          downloaded += chunk.length;
+          onProgress?.(downloaded, total);
+        });
+        res.pipe(fileStream);
+        fileStream.on("finish", () => resolve(downloaded));
+        fileStream.on("error", reject);
+        res.on("error", reject);
+      }).on("error", reject);
+    };
+    request(url);
+  });
+}
+async function computeSha256(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = (0, import_node_crypto.createHash)("sha256");
+    const stream = fs.createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+
+// src/python/python-env-manager.ts
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var PythonEnvManager = class {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+    this.venvPath = path2.join(dataDir, ".venv");
+  }
+  venvPath;
+  cachedProbe = null;
+  async probe() {
+    if (this.cachedProbe) return this.cachedProbe;
+    for (const cmd of ["python3", "python"]) {
+      try {
+        const { stdout } = await execFileAsync(cmd, ["--version"]);
+        const version = stdout.trim().replace("Python ", "");
+        const major = parseInt(version.split(".")[0] ?? "0", 10);
+        const minor = parseInt(version.split(".")[1] ?? "0", 10);
+        if (major < 3 || major === 3 && minor < 10) continue;
+        const { stdout: pathOut } = await execFileAsync(cmd, ["-c", "import sys; print(sys.executable)"]);
+        this.cachedProbe = {
+          available: true,
+          version,
+          path: pathOut.trim()
+        };
+        return this.cachedProbe;
+      } catch {
+        continue;
+      }
+    }
+    this.cachedProbe = { available: false };
+    return this.cachedProbe;
+  }
+  async ensure(options) {
+    const probe = await this.probe();
+    if (!probe.available || !probe.path) {
+      throw new Error("Python 3.10+ is required but not found on this system");
+    }
+    if (!fs2.existsSync(path2.join(this.venvPath, "bin", "python"))) {
+      await execFileAsync(probe.path, ["-m", "venv", this.venvPath]);
+    }
+    const venvPython = path2.join(this.venvPath, "bin", "python");
+    if (options.packages.length > 0) {
+      await execFileAsync(venvPython, ["-m", "pip", "install", "-q", ...options.packages]);
+    }
+    return {
+      pythonPath: venvPython,
+      venvPath: this.venvPath,
+      spawn: (script, args) => {
+        return (0, import_node_child_process.spawn)(venvPython, [script, ...args]);
+      }
+    };
+  }
+  spawn(script, args) {
+    const venvPython = path2.join(this.venvPath, "bin", "python");
+    if (!fs2.existsSync(venvPython)) {
+      throw new Error("Python venv not initialized. Call ensure() first.");
+    }
+    return (0, import_node_child_process.spawn)(venvPython, [script, ...args]);
+  }
+};
+
+// src/addon/addon-loader.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var AddonLoader = class {
+  addons = /* @__PURE__ */ new Map();
+  /** Load all addons from an npm package */
+  async loadPackage(packageName) {
+    const pkgJsonPath = require.resolve(`${packageName}/package.json`);
+    const pkgJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+    const manifest = pkgJson["camstack"];
+    if (!manifest?.addons?.length) {
+      throw new Error(`Package ${packageName} has no camstack.addons manifest`);
+    }
+    for (const declaration of manifest.addons) {
+      const entryPath = require.resolve(`${packageName}/${declaration.entry.replace("./dist/", "").replace(/\.js$/, "")}`);
+      const mod = await import(entryPath);
+      const AddonClass = mod["default"] ?? mod[Object.keys(mod)[0]];
+      if (!AddonClass) {
+        throw new Error(`Addon ${declaration.id} from ${packageName} has no default export`);
+      }
+      this.addons.set(declaration.id, {
+        declaration,
+        packageName,
+        addonClass: AddonClass
+      });
+    }
+  }
+  /** Load addon from a direct path (for development/testing) */
+  async loadFromPath(addonId, modulePath, packageName) {
+    const mod = await import(modulePath);
+    const AddonClass = mod["default"] ?? mod[Object.keys(mod)[0]];
+    if (!AddonClass) {
+      throw new Error(`Module ${modulePath} has no default export`);
+    }
+    this.addons.set(addonId, {
+      declaration: { id: addonId, entry: modulePath, slot: "detector" },
+      packageName,
+      addonClass: AddonClass
+    });
+  }
+  /** Get a registered addon by ID */
+  getAddon(addonId) {
+    return this.addons.get(addonId);
+  }
+  /** List all registered addons */
+  listAddons() {
+    return [...this.addons.values()];
+  }
+  /** Check if an addon is registered */
+  hasAddon(addonId) {
+    return this.addons.has(addonId);
+  }
+  /** Create a new instance of an addon (not yet initialized) */
+  createInstance(addonId) {
+    const registered = this.addons.get(addonId);
+    if (!registered) {
+      throw new Error(`Addon "${addonId}" is not registered`);
+    }
+    return new registered.addonClass();
+  }
+  /** Load all installed addon packages from the addon directory */
+  async loadAllInstalled(installer) {
+    const installed = installer.listInstalled();
+    for (const pkg of installed) {
+      try {
+        await this.loadPackageFromPath(pkg.name, pkg.path);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`Failed to load addon package ${pkg.name}: ${message}`);
+      }
+    }
+  }
+  /** Load addon package from a specific filesystem path */
+  async loadPackageFromPath(packageName, packagePath) {
+    const pkgJsonPath = path3.join(packagePath, "package.json");
+    const pkgJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+    const manifest = pkgJson["camstack"];
+    if (!manifest?.addons?.length) {
+      throw new Error(`Package ${packageName} at ${packagePath} has no camstack.addons manifest`);
+    }
+    for (const declaration of manifest.addons) {
+      const entryPath = path3.join(packagePath, declaration.entry);
+      const mod = await import(entryPath);
+      const AddonClass = mod["default"] ?? mod[Object.keys(mod)[0]];
+      if (!AddonClass) {
+        throw new Error(`Addon ${declaration.id} from ${packageName} has no default export`);
+      }
+      this.addons.set(declaration.id, {
+        declaration,
+        packageName,
+        addonClass: AddonClass
+      });
+    }
+  }
+};
+
+// src/addon/addon-engine-manager.ts
+var import_node_crypto2 = require("crypto");
+var AddonEngineManager = class {
+  constructor(loader, baseContext) {
+    this.loader = loader;
+    this.baseContext = baseContext;
+  }
+  engines = /* @__PURE__ */ new Map();
+  /**
+   * Get or create an addon engine for the given effective config.
+   * Cameras with the same addonId + effective config share the same engine.
+   */
+  async getOrCreateEngine(addonId, globalConfig, cameraOverride) {
+    const effectiveConfig = { ...globalConfig, ...cameraOverride };
+    const configKey = `${addonId}:${this.hashConfig(effectiveConfig)}`;
+    const existing = this.engines.get(configKey);
+    if (existing) return existing;
+    const addon = this.loader.createInstance(addonId);
+    await addon.initialize({ ...this.baseContext, addonConfig: effectiveConfig });
+    this.engines.set(configKey, addon);
+    return addon;
+  }
+  /** Get all active engines */
+  getActiveEngines() {
+    return new Map(this.engines);
+  }
+  /** Shutdown a specific engine by its config key */
+  async shutdownEngine(configKey) {
+    const engine = this.engines.get(configKey);
+    if (engine) {
+      await engine.shutdown();
+      this.engines.delete(configKey);
+    }
+  }
+  /** Shutdown all engines */
+  async shutdownAll() {
+    for (const [, engine] of this.engines) {
+      await engine.shutdown();
+    }
+    this.engines.clear();
+  }
+  /** Compute a deterministic config key (visible for tests) */
+  computeConfigKey(addonId, effectiveConfig) {
+    return `${addonId}:${this.hashConfig(effectiveConfig)}`;
+  }
+  hashConfig(config) {
+    const sorted = JSON.stringify(config, Object.keys(config).sort());
+    return (0, import_node_crypto2.createHash)("md5").update(sorted).digest("hex").slice(0, 12);
+  }
+};
+
+// src/addon/addon-installer.ts
+var import_node_child_process2 = require("child_process");
+var import_node_util2 = require("util");
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var AddonInstaller = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /** Initialize addon directory — create if not exists, install builtins if needed */
+  async initialize() {
+    await this.ensureAddonDirectory();
+    await this.installBuiltins();
+  }
+  /** Ensure addon directory exists with a package.json */
+  async ensureAddonDirectory() {
+    const { addonsDir } = this.config;
+    fs4.mkdirSync(addonsDir, { recursive: true });
+    const pkgJsonPath = path4.join(addonsDir, "package.json");
+    if (!fs4.existsSync(pkgJsonPath)) {
+      const pkgJson = {
+        name: "camstack-addons",
+        version: "1.0.0",
+        private: true,
+        description: "CamStack addon packages \u2014 managed automatically",
+        dependencies: {}
+      };
+      fs4.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+    }
+  }
+  /** Install builtin packages if not already present */
+  async installBuiltins() {
+    const missing = this.config.builtinPackages.filter((pkg) => !this.isInstalled(pkg));
+    if (missing.length === 0) return;
+    await this.installPackages(missing);
+  }
+  /** Check if a package is installed */
+  isInstalled(packageName) {
+    const pkgPath = path4.join(this.config.addonsDir, "node_modules", packageName, "package.json");
+    return fs4.existsSync(pkgPath);
+  }
+  /** Get installed package info */
+  getInstalledPackage(packageName) {
+    const pkgPath = path4.join(this.config.addonsDir, "node_modules", packageName, "package.json");
+    if (!fs4.existsSync(pkgPath)) return null;
+    const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+    return {
+      name: pkg.name,
+      version: pkg.version,
+      path: path4.dirname(pkgPath)
+    };
+  }
+  /** List all installed addon packages (those with camstack.addons in package.json) */
+  listInstalled() {
+    const nodeModulesDir = path4.join(this.config.addonsDir, "node_modules");
+    if (!fs4.existsSync(nodeModulesDir)) return [];
+    const packages = [];
+    const scopeDirs = fs4.readdirSync(nodeModulesDir).filter((d) => d.startsWith("@"));
+    for (const scope of scopeDirs) {
+      const scopePath = path4.join(nodeModulesDir, scope);
+      if (!fs4.statSync(scopePath).isDirectory()) continue;
+      for (const pkg of fs4.readdirSync(scopePath)) {
+        const pkgJsonPath = path4.join(scopePath, pkg, "package.json");
+        if (!fs4.existsSync(pkgJsonPath)) continue;
+        const pkgJson = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
+        if (pkgJson.camstack?.addons) {
+          packages.push({ name: pkgJson.name, version: pkgJson.version, path: path4.join(scopePath, pkg) });
+        }
+      }
+    }
+    for (const dir of fs4.readdirSync(nodeModulesDir)) {
+      if (dir.startsWith("@") || dir.startsWith(".")) continue;
+      const pkgJsonPath = path4.join(nodeModulesDir, dir, "package.json");
+      if (!fs4.existsSync(pkgJsonPath)) continue;
+      const pkgJson = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
+      if (pkgJson.camstack?.addons) {
+        packages.push({ name: pkgJson.name, version: pkgJson.version, path: path4.join(nodeModulesDir, dir) });
+      }
+    }
+    return packages;
+  }
+  /** Install one or more packages from npm */
+  async installPackages(packages) {
+    if (packages.length === 0) return;
+    const args = ["install", "--save", ...packages];
+    if (this.config.registry) {
+      args.push("--registry", this.config.registry);
+    }
+    await execFileAsync2("npm", args, {
+      cwd: this.config.addonsDir,
+      timeout: 12e4
+      // 2 min timeout
+    });
+    const pkgJsonPath = path4.join(this.config.addonsDir, "package.json");
+    const pkgJson = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
+    fs4.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+  }
+  /** Uninstall a package */
+  async uninstallPackage(packageName) {
+    if (this.config.builtinPackages.includes(packageName)) {
+      throw new Error(`Cannot uninstall builtin package: ${packageName}`);
+    }
+    await execFileAsync2("npm", ["uninstall", packageName], {
+      cwd: this.config.addonsDir,
+      timeout: 6e4
+    });
+  }
+  /** Update a package to latest version */
+  async updatePackage(packageName) {
+    await execFileAsync2("npm", ["update", packageName], {
+      cwd: this.config.addonsDir,
+      timeout: 12e4
+    });
+  }
+  /** Update all packages */
+  async updateAll() {
+    await execFileAsync2("npm", ["update"], {
+      cwd: this.config.addonsDir,
+      timeout: 3e5
+    });
+  }
+  /** Get the node_modules path for require/import resolution */
+  getNodeModulesPath() {
+    return path4.join(this.config.addonsDir, "node_modules");
+  }
+};
+var BUILTIN_PACKAGES = [
+  "@camstack/vision",
+  "@camstack/pipeline-analysis",
+  "@camstack/benchmark"
+];
+
+// src/pipeline/pipeline-validator.ts
+var PipelineValidator = class {
+  constructor(loader) {
+    this.loader = loader;
+  }
+  validate(config) {
+    const errors = [];
+    const warnings = [];
+    for (const node of config.video) {
+      this.validateNode(node, errors, warnings, []);
+    }
+    if (config.audio) {
+      this.validateNode(config.audio, errors, warnings, []);
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  validateNode(node, errors, warnings, ancestors) {
+    if (!this.loader.hasAddon(node.addon)) {
+      errors.push({
+        step: node.step,
+        addon: node.addon,
+        message: `Addon "${node.addon}" is not registered`,
+        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]);
+      }
+    }
+  }
+};
+
+// src/pipeline/pipeline-runner.ts
+var import_node_crypto3 = require("crypto");
+var PipelineRunner = class {
+  constructor(engineManager, addonConfigs) {
+    this.engineManager = engineManager;
+    this.addonConfigs = addonConfigs;
+  }
+  async run(frame, config) {
+    const startTime = performance.now();
+    const results = [];
+    const timings = {};
+    for (const rootNode of config.video) {
+      await this.executeNode(rootNode, frame, null, results, timings);
+    }
+    if (config.audio) {
+      await this.executeNode(config.audio, frame, null, results, timings);
+    }
+    return {
+      results,
+      totalMs: performance.now() - startTime,
+      timings,
+      frameTimestamp: frame.timestamp
+    };
+  }
+  async executeNode(node, frame, parentDetection, results, timings) {
+    const resultId = (0, import_node_crypto3.randomUUID)();
+    const stepStart = performance.now();
+    try {
+      const globalConfig = this.addonConfigs.get(node.addon) ?? {};
+      const engine = await this.engineManager.getOrCreateEngine(
+        node.addon,
+        globalConfig,
+        node.configOverride
+      );
+      let output;
+      if (parentDetection) {
+        const cropInput = {
+          frame,
+          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`);
+        }
+      } 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`);
+        }
+      }
+      const stepMs = performance.now() - stepStart;
+      const slot = "detections" in output ? "detector" : "crops" in output ? "cropper" : "classifier";
+      const stepResult = {
+        addon: node.addon,
+        slot,
+        output,
+        parentResultId: parentDetection?.resultId,
+        resultId,
+        inferenceMs: output.inferenceMs,
+        preprocessMs: 0,
+        totalMs: stepMs
+      };
+      results.push(stepResult);
+      timings[node.step] = stepMs;
+      if (node.children?.length) {
+        const detections = "detections" in output ? output.detections : "crops" in output ? output.crops : [];
+        await this.executeChildren(node.children, frame, detections, resultId, results, timings);
+      }
+    } catch (error) {
+      const stepMs = performance.now() - stepStart;
+      const message = error instanceof Error ? error.message : String(error);
+      results.push({
+        addon: node.addon,
+        slot: "detector",
+        output: { detections: [], inferenceMs: 0, modelId: "" },
+        parentResultId: parentDetection?.resultId,
+        resultId,
+        inferenceMs: 0,
+        preprocessMs: 0,
+        totalMs: stepMs,
+        error: {
+          code: "ADDON_ERROR",
+          message,
+          childrenSkipped: true
+        }
+      });
+    }
+  }
+  async executeChildren(children, frame, parentDetections, parentResultId, results, timings) {
+    const promises = [];
+    for (const detection of parentDetections) {
+      for (const child of children) {
+        promises.push(
+          this.executeNode(child, frame, { det: detection, resultId: parentResultId }, results, timings)
+        );
+      }
+    }
+    await Promise.allSettled(promises);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddonEngineManager,
+  AddonInstaller,
+  AddonLoader,
+  BUILTIN_PACKAGES,
+  EventBus,
+  PipelineRunner,
+  PipelineValidator,
+  PythonEnvManager,
+  downloadModel
+});
+//# sourceMappingURL=index.js.map