@camstack/core 0.1.1 → 0.1.3

package/dist/index.d.mts

@@ -1,7 +1,71 @@
-import { ModelDownloadOptions, ModelDownloadResult, IPythonEnvironment, PythonProbeResult, PythonEnvReady, AddonDeclaration, ICamstackAddon, AddonContext, PipelineConfig, FrameInput, PipelineResult, AudioChunkInput, PipelineNode, IScopedLogger, CapabilityDeclaration, CapabilityConsumerRegistration, CapabilityMode, CapabilityInfo, LoggerFactory, AgentRegistrationInfo, AgentToHubMessage, HubToAgentMessage, AgentRuntimeStatus, ITaskHandler, TaskContext, IFileStorage as IFileStorage$1, IStorageProvider as IStorageProvider$1, StorageLocationName as StorageLocationName$1, IStorageLocation as IStorageLocation$1, IConfigurable, AddonManifest, CapabilityProviderMap, ConfigUISchema, ILogDestination as ILogDestination$1, LogEntry as LogEntry$1, LogFilter as LogFilter$1, IEventBus, SystemEvent, EventFilter, TokenScope, ScopedToken, INotificationOutput, Notification, Toast, IAddonRouteProvider, IAddonHttpRoute } from '@camstack/types';
-export { EventFilter, EventSource, IScopedLogger, SystemEvent } from '@camstack/types';
+import { IScopedLogger, ModelDownloadOptions, ModelDownloadResult, IAddonModelManager, ModelCatalogEntry, ModelFormat, IPythonEnvironment, PythonProbeResult, PythonEnvReady, PipelineConfig, ValidationResult, FrameInput, PipelineResult, AudioChunkInput, PipelineNode, ElementState as ElementState$1, LoggerFactory, ProcessConfig, ManagedProcessStatus, INetworkQualityTracker, ClientNetworkStats, DeviceNetworkStats, ReplResult, AgentInfo, AgentEntry, AgentStatus, AgentTask, TaskDispatchOptions, AgentTaskResult, LogEntry, LogFilter, AgentRegistrationInfo, AgentToHubMessage, HubToAgentMessage, AgentRuntimeStatus, ITaskHandler, TaskContext, IEventBus, FeatureManifest, FeatureFlag, SystemEvent, EventFilter, IStorageProvider as IStorageProvider$1, ISettingsBackend, TokenScope, ScopedToken, TokenPayload, UserRole, UserRecord, INotificationOutput, Notification, Toast, IAddonRouteProvider, IAddonHttpRoute, PlatformCapabilities, HardwareInfo, PlatformScore, ModelRequirement, ResolvedInferenceConfig, ProviderListItem } from '@camstack/types';
+export { AgentEntry, AgentInfo, AgentResources, AgentStatus, AgentTask, AgentTaskResult, BackupManifest, ClientNetworkStats, DeviceNetworkStats, EventFilter, EventSource, FeatureFlag, FeatureManifest, INetworkQualityTracker, IScopedLogger, LogEntry, LogFilter, LogLevel, ManagedProcessStatus, ProcessConfig, ProcessStats, ProviderListItem, ReplResult, StreamNetworkStats, SystemEvent, TaskDispatchOptions, TokenPayload, UserRecord, UserRole, ValidationIssue, ValidationResult } from '@camstack/types';
 import { ChildProcess } from 'node:child_process';
-import { z } from 'zod';
+import { AddonLoader, AddonEngineManager, CapabilityRegistry } from '@camstack/kernel';
+export { A as AddonTableSchema, C as CORE_TABLE_DDL, F as FileSystemStorage, S as SettingsStore, a as SqliteStorageAddon, b as SqliteStorageProvider, c as addonTableToDdl } from './sql-schema-CKz78rId.mjs';
+export { WinstonDestination, WinstonLoggingAddon } from './builtins/winston-logging/index.mjs';
+export { BackupConfig, LocalBackupAddon, LocalBackupService } from './builtins/local-backup/index.mjs';
+
+interface PlatformInfo {
+    readonly platform: NodeJS.Platform;
+    readonly arch: NodeJS.Architecture;
+}
+declare function getPlatformInfo(): PlatformInfo;
+declare function buildBinaryPath(dataDir: string, name: string, platform?: string): string;
+/** Check if a binary exists in PATH */
+declare function findInPath(name: string): string | null;
+interface DownloadOptions {
+    readonly name: string;
+    readonly url: string;
+    readonly targetDir: string;
+    readonly targetName: string;
+    readonly logger: IScopedLogger;
+    readonly isArchive?: boolean;
+    readonly archiveFormat?: 'zip' | 'tar.gz' | 'tar.xz';
+    /** Relative path within archive to the binary (e.g., 'ffmpeg-6.1/bin/ffmpeg') */
+    readonly archiveInnerPath?: string;
+}
+/**
+ * Download a binary to the target directory.
+ * Handles archives (zip, tar.gz, tar.xz) and raw binaries.
+ */
+declare function downloadBinary(opts: DownloadOptions): Promise<string>;
+/**
+ * Ensure a binary is available. Checks:
+ * 1. Target path (already downloaded)
+ * 2. System PATH
+ * 3. Download from URL
+ */
+declare function ensureBinary(opts: {
+    readonly name: string;
+    readonly targetDir: string;
+    readonly downloadUrl: string;
+    readonly logger: IScopedLogger;
+    readonly isArchive?: boolean;
+    readonly archiveFormat?: 'zip' | 'tar.gz' | 'tar.xz';
+    readonly archiveInnerPath?: string;
+}): Promise<string>;
+
+declare function getFfmpegDownloadUrl(platform: string, arch: string): string;
+/**
+ * Ensure ffmpeg binary is available.
+ * Checks: deps dir → system PATH → download.
+ */
+declare function ensureFfmpeg(dataDir: string, logger: IScopedLogger): Promise<string>;
+
+declare const PYTHON_VERSION = "3.12.12";
+declare function getPythonDownloadUrl(platform: string, arch: string): string;
+/**
+ * Ensure a portable Python is available.
+ * Checks: embedded python → system PATH → download portable.
+ *
+ * Returns the path to the python3 binary.
+ */
+declare function ensurePython(dataDir: string, logger: IScopedLogger): Promise<string | null>;
+/**
+ * Install Python packages into the portable Python environment.
+ */
+declare function installPythonPackages(pythonPath: string, packages: readonly string[], logger: IScopedLogger): Promise<void>;
 
 type EventCallback<T = unknown> = (data: T) => void;
 declare class EventBus {
@@ -13,8 +77,69 @@ declare class EventBus {
     listenerCount(event: string): number;
 }
 
+/**
+ * Download a single file from a URL to a destination path.
+ * Uses native fetch() (Node 22+) which handles redirects natively.
+ * Streams to disk with optional progress callback.
+ * Returns the destination path. Skips download if file already exists.
+ */
+declare function downloadFile(url: string, destPath: string, onProgress?: (downloaded: number, total: number) => void): Promise<string>;
+/**
+ * Fetch JSON from a URL using native fetch().
+ */
+declare function fetchJson(url: string): Promise<unknown>;
+/**
+ * Download a model with fallback URLs and optional SHA256 verification.
+ * Legacy API preserved for backward compatibility -- delegates to downloadFile().
+ */
 declare function downloadModel(options: ModelDownloadOptions): Promise<ModelDownloadResult>;
 
+/**
+ * Unified model download service.
+ *
+ * Handles downloading model files and extra files (labels, dicts) from a
+ * catalog of ModelCatalogEntry items. Supports single-file models and
+ * directory bundles (e.g., .mlpackage for CoreML).
+ *
+ * Addons use this via `context.models.ensure(modelId, format)`.
+ */
+declare class ModelDownloadService implements IAddonModelManager {
+    private readonly modelsDir;
+    private readonly onProgress?;
+    private readonly catalog;
+    constructor(modelsDir: string, catalog: readonly ModelCatalogEntry[], onProgress?: ((modelId: string, downloaded: number, total: number) => void) | undefined);
+    /**
+     * Ensure a model (and its extra files) is downloaded.
+     * Returns the local filesystem path to the model file/directory.
+     */
+    ensure(modelId: string, format?: ModelFormat): Promise<string>;
+    /**
+     * Ensure extra files for a model are downloaded.
+     * Returns the local paths of all extra files.
+     */
+    ensureExtraFiles(modelId: string): Promise<readonly string[]>;
+    /** Absolute path to the shared models directory. */
+    getModelsDir(): string;
+    /** Check if a model file is already present on disk. */
+    isDownloaded(modelId: string, format?: ModelFormat): boolean;
+    /**
+     * Legacy API: download a model by ID (delegates to ensure with default format).
+     * Required by IAddonModelManager interface.
+     */
+    downloadModel(id: string): Promise<string>;
+    /** Get the catalog entry for a model by ID. */
+    getEntry(modelId: string): ModelCatalogEntry | undefined;
+    private pickDefaultFormat;
+    private modelFilePath;
+    /**
+     * Download a directory bundle (e.g., .mlpackage) from HuggingFace.
+     * ATOMIC: downloads to temp dir, renames only on complete success.
+     */
+    private downloadDirectory;
+    /** Recursively list all files in a HuggingFace directory via API. */
+    private listHfFiles;
+}
+
 declare class PythonEnvManager implements IPythonEnvironment {
     private readonly dataDir;
     private venvPath;
@@ -27,113 +152,6 @@ declare class PythonEnvManager implements IPythonEnvironment {
     spawn(script: string, args: readonly string[]): ChildProcess;
 }
 
-interface AddonInstallerConfig {
-    /** Directory where addons are installed (e.g., ~/.camstack/addons or {dataDir}/addons) */
-    readonly addonsDir: string;
-    /** Builtin packages to auto-install on first boot */
-    readonly builtinPackages: readonly string[];
-    /** npm registry URL (default: https://registry.npmjs.org) */
-    readonly registry?: string;
-}
-interface InstalledPackage {
-    readonly name: string;
-    readonly version: string;
-    readonly path: string;
-}
-declare class AddonInstaller {
-    private readonly config;
-    constructor(config: AddonInstallerConfig);
-    /** Initialize addon directory — create if not exists, install builtins if needed */
-    initialize(): Promise<void>;
-    /** Ensure addon directory exists with a package.json */
-    private ensureAddonDirectory;
-    /** Install builtin packages if not already present */
-    private installBuiltins;
-    /**
-     * Ensure a set of packages are installed — installs any that are missing.
-     * This is the public entry-point used during boot to guarantee required
-     * addon packages are present before the loader tries to resolve them.
-     */
-    ensureInstalled(packages: string[]): Promise<void>;
-    /** Check if a package is installed */
-    isInstalled(packageName: string): boolean;
-    /** Get installed package info */
-    getInstalledPackage(packageName: string): InstalledPackage | null;
-    /** List all installed addon packages (those with camstack.addons in package.json) */
-    listInstalled(): InstalledPackage[];
-    /** Install one or more packages from npm */
-    installPackages(packages: readonly string[]): Promise<void>;
-    /** Uninstall a package */
-    uninstallPackage(packageName: string): Promise<void>;
-    /** Update a package to latest version */
-    updatePackage(packageName: string): Promise<void>;
-    /** Install an addon from a local .tgz file */
-    installFromTgz(tgzPath: string): Promise<void>;
-    /** Update all packages */
-    updateAll(): Promise<void>;
-    /** Get the node_modules path for require/import resolution */
-    getNodeModulesPath(): string;
-}
-/** Default builtin packages that are auto-installed on first boot */
-declare const BUILTIN_PACKAGES: readonly string[];
-
-interface RegisteredAddon {
-    readonly declaration: AddonDeclaration;
-    readonly packageName: string;
-    readonly addonClass: new () => ICamstackAddon;
-}
-declare class AddonLoader {
-    private addons;
-    /** Load all addons from an npm package */
-    loadPackage(packageName: string): Promise<void>;
-    /** Load addon from a direct path (for development/testing) */
-    loadFromPath(addonId: string, modulePath: string, packageName: string, declaration?: Partial<AddonDeclaration>): Promise<void>;
-    /** Get a registered addon by ID */
-    getAddon(addonId: string): RegisteredAddon | undefined;
-    /** List all registered addons */
-    listAddons(): RegisteredAddon[];
-    /** Check if an addon is registered */
-    hasAddon(addonId: string): boolean;
-    /** Create a new instance of an addon (not yet initialized) */
-    createInstance(addonId: string): ICamstackAddon;
-    /** Load all installed addon packages from the addon directory */
-    loadAllInstalled(installer: AddonInstaller): Promise<void>;
-    /** Load addon package from a specific filesystem path */
-    loadPackageFromPath(packageName: string, packagePath: string): Promise<void>;
-}
-
-declare class AddonEngineManager {
-    private readonly loader;
-    private readonly baseContext;
-    private engines;
-    constructor(loader: AddonLoader, baseContext: Partial<Omit<AddonContext, 'addonConfig'>>);
-    /**
-     * Get or create an addon engine for the given effective config.
-     * Cameras with the same addonId + effective config share the same engine.
-     */
-    getOrCreateEngine(addonId: string, globalConfig: Record<string, unknown>, cameraOverride?: Record<string, unknown>): Promise<ICamstackAddon>;
-    /** Get all active engines */
-    getActiveEngines(): Map<string, ICamstackAddon>;
-    /** Shutdown a specific engine by its config key */
-    shutdownEngine(configKey: string): Promise<void>;
-    /** Shutdown all engines */
-    shutdownAll(): Promise<void>;
-    /** Compute a deterministic config key (visible for tests) */
-    computeConfigKey(addonId: string, effectiveConfig: Record<string, unknown>): string;
-    private hashConfig;
-}
-
-interface ValidationIssue {
-    readonly step?: string;
-    readonly addon?: string;
-    readonly message: string;
-    readonly severity: 'error' | 'warning';
-}
-interface ValidationResult {
-    readonly valid: boolean;
-    readonly errors: readonly ValidationIssue[];
-    readonly warnings: readonly ValidationIssue[];
-}
 declare class PipelineValidator {
     private readonly loader;
     constructor(loader: AddonLoader);
@@ -155,169 +173,7 @@ declare class PipelineRunner {
     private executeChildren;
 }
 
-/**
- * Central registry for all capability providers and consumers.
- * Lives in @camstack/core. Mode-aware: singleton (one active) or collection (all active).
- *
- * Uses injected LoggingService, NEVER NestJS static Logger.
- */
-declare class CapabilityRegistry {
-    private readonly logger;
-    private readonly configReader;
-    private readonly capabilities;
-    /** Per-device singleton overrides: deviceId → (capability → addonId) */
-    private readonly deviceOverrides;
-    /** Per-device collection filters: deviceId → (capability → addonIds[]) */
-    private readonly deviceCollectionFilters;
-    constructor(logger: IScopedLogger, configReader: (capability: string) => string | undefined);
-    /**
-     * Declare a capability (typically called when addon manifests are loaded).
-     * Must be called before registerProvider/registerConsumer for that capability.
-     */
-    declareCapability(declaration: CapabilityDeclaration): void;
-    /**
-     * Register a capability provider (called by addon loader when addon is enabled).
-     * For singleton: auto-activates if user-preferred or first registered.
-     * For collection: adds to active set and notifies consumers.
-     */
-    registerProvider(capability: string, addonId: string, provider: unknown): void;
-    /**
-     * Unregister a provider (called when addon is disabled/uninstalled).
-     */
-    unregisterProvider(capability: string, addonId: string): void;
-    /**
-     * Register a consumer that wants to be notified when providers change.
-     * If a provider is already active, the consumer is immediately notified.
-     * Returns a disposer function for cleanup.
-     */
-    registerConsumer<T = unknown>(registration: CapabilityConsumerRegistration<T>): () => void;
-    /**
-     * Get the active singleton provider for a capability.
-     * Returns null if none set.
-     */
-    getSingleton<T = unknown>(capability: string): T | null;
-    /**
-     * Get all active collection providers for a capability.
-     */
-    getCollection<T = unknown>(capability: string): readonly T[];
-    /**
-     * Set which addon should be the active singleton for a capability.
-     * Call with `immediate: true` to also swap the runtime provider now
-     * (consumers' onSet will be awaited).
-     */
-    setActiveSingleton(capability: string, addonId: string, immediate?: boolean): Promise<void>;
-    /**
-     * Get the mode declared for a capability.
-     */
-    getMode(capability: string): CapabilityMode | undefined;
-    /**
-     * List all registered capabilities with their providers.
-     */
-    listCapabilities(): CapabilityInfo[];
-    /**
-     * Check if all dependencies for a capability are satisfied (have active providers).
-     */
-    areDependenciesMet(declaration: CapabilityDeclaration): boolean;
-    /**
-     * Get the dependency-ordered list of capability names for boot sequencing.
-     * Returns capabilities sorted topologically by dependsOn.
-     * Throws if a cycle is detected.
-     */
-    getBootOrder(): string[];
-    /**
-     * Set a per-device singleton override. When resolveForDevice is called for
-     * this device + capability, the specified addon's provider is returned
-     * instead of the global singleton.
-     */
-    setDeviceOverride(deviceId: string, capability: string, addonId: string): void;
-    /**
-     * Clear a per-device singleton override, reverting to the global singleton.
-     */
-    clearDeviceOverride(deviceId: string, capability: string): void;
-    /**
-     * Get all per-device singleton overrides for a device.
-     * Returns a Map of capability name to addon ID.
-     */
-    getDeviceOverrides(deviceId: string): Map<string, string>;
-    /**
-     * Resolve a singleton provider for a specific device.
-     * 1. Check device override — return that addon's provider
-     * 2. Fallback to global singleton
-     */
-    resolveForDevice<T = unknown>(capability: string, deviceId: string): T | null;
-    /**
-     * Set a per-device collection filter. When resolveCollectionForDevice is called
-     * for this device + capability, only providers from the specified addon IDs
-     * are returned instead of the full collection.
-     */
-    setDeviceCollectionFilter(deviceId: string, capability: string, addonIds: string[]): void;
-    /**
-     * Clear a per-device collection filter, reverting to the full collection.
-     */
-    clearDeviceCollectionFilter(deviceId: string, capability: string): void;
-    /**
-     * Resolve collection providers for a specific device.
-     * If a filter exists for the device + capability, only those addon's providers are returned.
-     * If no filter exists, the full collection is returned.
-     */
-    resolveCollectionForDevice<T = unknown>(capability: string, deviceId: string): readonly T[];
-    /**
-     * Get a specific addon's provider by addon ID, regardless of whether it's the active singleton.
-     * Useful for per-device overrides that need to look up any registered provider.
-     */
-    getProviderByAddonId<T = unknown>(capability: string, addonId: string): T | null;
-    private activateSingleton;
-    private activateSingletonAsync;
-}
-
-interface InfraCapability {
-    /** Capability name */
-    readonly name: string;
-    /** If true, boot aborts when this capability's addon fails to initialize */
-    readonly required: boolean;
-}
-/**
- * Infrastructure capabilities that must boot before all other addons.
- * Enabled in Phase 1 of the boot sequence. Order matters: storage before logging.
- */
-declare const INFRA_CAPABILITIES: readonly InfraCapability[];
-/** Check if a capability name is an infrastructure capability */
-declare function isInfraCapability(name: string): boolean;
-
-type ProcessState = 'stopped' | 'starting' | 'running' | 'stopping' | 'error';
-interface ProcessConfig {
-    readonly id: string;
-    readonly label: string;
-    readonly command?: string;
-    readonly modulePath?: string;
-    readonly args?: string[];
-    readonly env?: Record<string, string>;
-    readonly autoRestart: boolean;
-    readonly maxRestarts?: number;
-    readonly healthCheck?: {
-        readonly intervalMs: number;
-        readonly timeoutMs: number;
-        readonly failureThreshold: number;
-    };
-}
-interface ProcessStats {
-    readonly pid: number;
-    readonly cpu: number;
-    readonly memory: number;
-    readonly uptime: number;
-    readonly restartCount: number;
-}
-interface ManagedProcessStatus {
-    readonly id: string;
-    readonly label: string;
-    readonly state: ProcessState;
-    readonly pid?: number;
-    readonly stats?: ProcessStats;
-    readonly lastCrashAt?: number;
-    readonly lastCrashError?: string;
-    readonly restartCount: number;
-    readonly nextRestartAt?: number;
-}
+type ProcessState = ElementState$1;
 
 /** Event emitter for process lifecycle events */
 type ProcessEventEmitter = {
@@ -363,30 +219,6 @@ declare class ProcessManager {
     shutdownAll(): Promise<void>;
 }
 
-interface StreamNetworkStats {
-    readonly nominalBitrateKbps: number;
-    readonly observedBitrateKbps: number;
-    readonly peakBitrateKbps: number;
-    readonly packetLossPercent: number;
-    readonly lastUpdated: number;
-}
-interface ClientNetworkStats {
-    readonly rttMs: number;
-    readonly jitterMs: number;
-    readonly estimatedBandwidthKbps: number;
-    readonly lastUpdated: number;
-}
-interface DeviceNetworkStats {
-    readonly deviceId: string;
-    readonly streams: Readonly<Record<string, StreamNetworkStats>>;
-    readonly client?: ClientNetworkStats;
-}
-interface INetworkQualityTracker {
-    reportStreamStats(deviceId: string, streamId: string, bitrateKbps: number, packetLoss?: number): void;
-    reportClientStats(deviceId: string, stats: Omit<ClientNetworkStats, 'lastUpdated'>): void;
-    getDeviceStats(deviceId: string): DeviceNetworkStats | null;
-    getAllStats(): readonly DeviceNetworkStats[];
-}
 declare class NetworkQualityTracker implements INetworkQualityTracker {
     private readonly devices;
     private static readonly MAX_SAMPLES;
@@ -408,11 +240,7 @@ interface ReplSessionContext {
     /** Pre-populated variables available in the REPL session */
     readonly variables: Record<string, unknown>;
 }
-interface ReplResult {
-    readonly output: string;
-    readonly type: 'value' | 'error' | 'void';
-    readonly duration: number;
-}
+
 interface IReplEngine {
     execute(code: string, context: ReplSessionContext): Promise<ReplResult>;
     getCompletions(partial: string, context: ReplSessionContext): Promise<string[]>;
@@ -436,62 +264,6 @@ declare class ReplEngine implements IReplEngine {
     private buildSandbox;
 }
 
-interface AgentInfo {
-    readonly id: string;
-    readonly name: string;
-    readonly capabilities: readonly string[];
-    readonly host: string;
-    readonly port: number;
-    readonly resources?: AgentResources;
-}
-interface AgentResources {
-    readonly cpuCores?: number;
-    readonly memoryMB?: number;
-    readonly gpuAvailable?: boolean;
-    readonly gpuModel?: string;
-}
-interface AgentStatus {
-    readonly id: string;
-    readonly name: string;
-    readonly state: 'online' | 'offline' | 'degraded';
-    readonly capabilities: readonly string[];
-    readonly lastHeartbeat: number;
-    readonly connectedSince?: number;
-    readonly resources?: AgentResources;
-    readonly activeTaskCount: number;
-    readonly completedTaskCount: number;
-    readonly failedTaskCount: number;
-}
-interface AgentTask {
-    readonly id: string;
-    readonly capability: string;
-    readonly input: Record<string, unknown>;
-    readonly timeout: number;
-    readonly priority: 'low' | 'normal' | 'high';
-    readonly label?: string;
-}
-interface AgentTaskResult {
-    readonly taskId: string;
-    readonly agentId: string;
-    readonly status: 'success' | 'error' | 'timeout';
-    readonly output?: Record<string, unknown>;
-    readonly error?: string;
-    readonly durationMs: number;
-}
-interface TaskDispatchOptions {
-    readonly preferredAgent?: string;
-    readonly capability: string;
-    readonly remoteOnly?: boolean;
-}
-interface AgentEntry {
-    readonly info: AgentInfo;
-    state: 'online' | 'offline' | 'degraded';
-    connectedSince: number;
-    lastHeartbeat: number;
-    activeTaskCount: number;
-    completedTaskCount: number;
-    failedTaskCount: number;
-}
 /** Event emitter for agent lifecycle and task events */
 type AgentEventEmitter = {
     emitAgentRegistered(agentId: string, capabilities: readonly string[]): void;
@@ -543,21 +315,6 @@ declare class TaskDispatcher {
     private sendToAgent;
 }
 
-type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-interface LogEntry {
-    timestamp: Date;
-    level: LogLevel;
-    scope: string[];
-    message: string;
-    meta?: Record<string, unknown>;
-}
-interface LogFilter {
-    scope?: string[];
-    level?: LogLevel;
-    since?: Date;
-    until?: Date;
-    limit?: number;
-}
 declare class LogRingBuffer {
     private readonly capacity;
     private readonly buffer;
@@ -706,128 +463,6 @@ declare class RecordTaskHandler implements ITaskHandler {
     cancel(): Promise<void>;
 }
 
-declare class FileSystemStorage implements IFileStorage$1 {
-    private readonly basePath;
-    constructor(basePath: string);
-    readFile(filePath: string): Promise<Buffer>;
-    writeFile(filePath: string, data: Buffer): Promise<void>;
-    deleteFile(filePath: string): Promise<void>;
-    listFiles(prefix?: string): Promise<readonly string[]>;
-    getFileUrl(_path: string): Promise<string>;
-    exists(filePath: string): Promise<boolean>;
-}
-declare class SqliteStorageProvider implements IStorageProvider$1 {
-    private mainDb;
-    private sharedStructured;
-    private readonly locations;
-    initialize(): Promise<void>;
-    /**
-     * Configure all storage locations.
-     * ONE single SQLite database (camstack.db) is used for ALL structured storage.
-     * File-based locations use the filesystem at their configured path.
-     */
-    configure(config: {
-        locations: Record<string, string>;
-    }): Promise<void>;
-    getLocation(name: StorageLocationName$1): IStorageLocation$1;
-    shutdown(): Promise<void>;
-    export(_locationName: StorageLocationName$1): Promise<Buffer>;
-    import(_locationName: StorageLocationName$1, _data: Buffer): Promise<void>;
-}
-
-declare class SqliteStorageAddon implements ICamstackAddon, IConfigurable {
-    readonly manifest: AddonManifest;
-    private provider;
-    initialize(context: AddonContext): Promise<void>;
-    shutdown(): Promise<void>;
-    getProvider(): SqliteStorageProvider;
-    getCapabilityProvider<K extends keyof CapabilityProviderMap>(name: K): CapabilityProviderMap[K] | null;
-    getConfigSchema(): ConfigUISchema;
-    getConfig(): Record<string, unknown>;
-    onConfigChange(_config: Record<string, unknown>): Promise<void>;
-}
-
-interface WinstonConfig {
-    readonly level: string;
-    readonly retentionDays: number;
-    /** Resolved absolute path to the logs directory (replaces the old dataPath field). */
-    readonly logsDir: string;
-}
-declare class WinstonDestination implements ILogDestination$1 {
-    private logger;
-    initialize(config?: WinstonConfig): Promise<void>;
-    write(entry: LogEntry$1): void;
-    query(_filter: LogFilter$1): Promise<readonly LogEntry$1[]>;
-    shutdown(): Promise<void>;
-}
-
-declare class WinstonLoggingAddon implements ICamstackAddon, IConfigurable {
-    readonly manifest: AddonManifest;
-    private destination;
-    private currentConfig;
-    initialize(context: AddonContext): Promise<void>;
-    shutdown(): Promise<void>;
-    getDestination(): WinstonDestination;
-    getCapabilityProvider<K extends keyof CapabilityProviderMap>(name: K): CapabilityProviderMap[K] | null;
-    getConfigSchema(): ConfigUISchema;
-    getConfig(): Record<string, unknown>;
-    onConfigChange(config: Record<string, unknown>): Promise<void>;
-}
-
-interface BackupManifest {
-    readonly id: string;
-    readonly timestamp: number;
-    readonly label?: string;
-    readonly locations: readonly string[];
-    readonly sizeMB: number;
-    readonly path: string;
-}
-interface BackupConfig {
-    readonly backupDir: string;
-    readonly retentionCount: number;
-}
-declare class LocalBackupService {
-    private readonly config;
-    private readonly logger;
-    private readonly eventBus;
-    private readonly storage;
-    private manifests;
-    constructor(config: BackupConfig, logger: IScopedLogger, eventBus: IEventBus, storage: IStorageLocation$1);
-    /** Create a backup of specified locations */
-    backup(options?: {
-        locations?: string[];
-        label?: string;
-    }): Promise<BackupManifest>;
-    /** Restore from a backup */
-    restore(backupId: string): Promise<void>;
-    /** List all backups sorted by timestamp descending */
-    list(): readonly BackupManifest[];
-    /** Delete a specific backup */
-    delete(backupId: string): Promise<void>;
-    private pruneOldBackups;
-}
-
-declare class LocalBackupAddon implements ICamstackAddon, IConfigurable {
-    readonly manifest: AddonManifest;
-    private service;
-    private currentConfig;
-    initialize(context: AddonContext): Promise<void>;
-    shutdown(): Promise<void>;
-    getService(): LocalBackupService;
-    getCapabilityProvider<K extends keyof CapabilityProviderMap>(name: K): CapabilityProviderMap[K] | null;
-    getConfigSchema(): ConfigUISchema;
-    getConfig(): Record<string, unknown>;
-    onConfigChange(config: Record<string, unknown>): Promise<void>;
-}
-
-declare class AdminUIAddon implements ICamstackAddon {
-    readonly id = "admin-ui";
-    readonly manifest: AddonManifest;
-    initialize(_ctx: AddonContext): Promise<void>;
-    shutdown(): Promise<void>;
-    getCapabilityProvider<K extends keyof CapabilityProviderMap>(name: K): CapabilityProviderMap[K] | null;
-}
-
 type ElementState = 'stopped' | 'starting' | 'running' | 'stopping' | 'error' | 'disabled';
 interface ElementStatus {
     state: ElementState;
@@ -856,18 +491,6 @@ declare class LifecycleStateMachine {
     private isValidTransition;
 }
 
-interface FeatureManifest {
-    streaming: boolean;
-    notifications: boolean;
-    objectDetection: boolean;
-    remoteAccess: boolean;
-    agentCluster: boolean;
-    smartHome: boolean;
-    recordings: boolean;
-    backup: boolean;
-    repl: boolean;
-}
-type FeatureFlag = keyof FeatureManifest;
 type FeatureConfigReader = {
     readonly features: FeatureManifest;
 };
@@ -878,240 +501,6 @@ declare class FeatureManager {
     getManifest(): FeatureManifest;
 }
 
-/** Bootstrap config -- loaded from config.yaml ONLY at startup.
- *  All other settings live in SQL (system_settings table). */
-declare const bootstrapSchema: z.ZodObject<{
-    /** Server mode: 'hub' (full server) or 'agent' (worker node) */
-    mode: z.ZodDefault<z.ZodEnum<["hub", "agent"]>>;
-    server: z.ZodDefault<z.ZodObject<{
-        port: z.ZodDefault<z.ZodNumber>;
-        host: z.ZodDefault<z.ZodString>;
-        dataPath: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        port: number;
-        host: string;
-        dataPath: string;
-    }, {
-        port?: number | undefined;
-        host?: string | undefined;
-        dataPath?: string | undefined;
-    }>>;
-    auth: z.ZodDefault<z.ZodObject<{
-        jwtSecret: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-        adminUsername: z.ZodDefault<z.ZodString>;
-        adminPassword: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        jwtSecret: string | null;
-        adminUsername: string;
-        adminPassword: string;
-    }, {
-        jwtSecret?: string | null | undefined;
-        adminUsername?: string | undefined;
-        adminPassword?: string | undefined;
-    }>>;
-    /** Hub connection config — only used when mode='agent' */
-    hub: z.ZodDefault<z.ZodObject<{
-        url: z.ZodDefault<z.ZodString>;
-        token: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        url: string;
-        token: string;
-    }, {
-        url?: string | undefined;
-        token?: string | undefined;
-    }>>;
-    /** Agent-specific config — only used when mode='agent' */
-    agent: z.ZodDefault<z.ZodObject<{
-        name: z.ZodDefault<z.ZodString>;
-        /** Port for the agent status page (minimal HTML) */
-        statusPort: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        statusPort: number;
-    }, {
-        name?: string | undefined;
-        statusPort?: number | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    agent: {
-        name: string;
-        statusPort: number;
-    };
-    auth: {
-        jwtSecret: string | null;
-        adminUsername: string;
-        adminPassword: string;
-    };
-    mode: "agent" | "hub";
-    hub: {
-        url: string;
-        token: string;
-    };
-    server: {
-        port: number;
-        host: string;
-        dataPath: string;
-    };
-}, {
-    agent?: {
-        name?: string | undefined;
-        statusPort?: number | undefined;
-    } | undefined;
-    auth?: {
-        jwtSecret?: string | null | undefined;
-        adminUsername?: string | undefined;
-        adminPassword?: string | undefined;
-    } | undefined;
-    mode?: "agent" | "hub" | undefined;
-    hub?: {
-        url?: string | undefined;
-        token?: string | undefined;
-    } | undefined;
-    server?: {
-        port?: number | undefined;
-        host?: string | undefined;
-        dataPath?: string | undefined;
-    } | undefined;
-}>;
-type BootstrapConfig = z.infer<typeof bootstrapSchema>;
-/**
- * Runtime defaults -- used by ConfigManager.get() for backward compatibility
- * until Plan B wires all runtime settings to the system_settings SQL table.
- */
-declare const RUNTIME_DEFAULTS: Record<string, unknown>;
-type ServerMode = 'hub' | 'agent';
-type AppConfig = BootstrapConfig & {
-    features: {
-        streaming: boolean;
-        notifications: boolean;
-        objectDetection: boolean;
-        remoteAccess: boolean;
-        agentCluster: boolean;
-        smartHome: boolean;
-        recordings: boolean;
-        backup: boolean;
-        repl: boolean;
-    };
-    storage: {
-        provider: string;
-        locations: Record<string, string>;
-    };
-    logging: {
-        level: string;
-        retentionDays: number;
-    };
-    eventBus: {
-        ringBufferSize: number;
-    };
-    addons: {
-        enabled: string[];
-    };
-    retention: {
-        detectionEventsDays: number;
-        audioLevelsDays: number;
-    };
-    providers: Array<{
-        id: string;
-        type: string;
-        name: string;
-        url?: string;
-        username?: string;
-        password?: string;
-        mqtt?: {
-            brokerUrl: string;
-            username?: string;
-            password?: string;
-            topicPrefix: string;
-        };
-    }>;
-};
-
-interface ISettingsStore {
-    getSystem(key: string): unknown;
-    setSystem(key: string, value: unknown): void;
-    getAllSystem(): Record<string, unknown>;
-    getAllAddon(addonId: string): Record<string, unknown>;
-    setAllAddon(addonId: string, config: Record<string, unknown>): void;
-    getAllProvider(providerId: string): Record<string, unknown>;
-    setProvider(providerId: string, key: string, value: unknown): void;
-    getAllDevice(deviceId: string): Record<string, unknown>;
-    setDevice(deviceId: string, key: string, value: unknown): void;
-}
-declare class ConfigManager {
-    private readonly configPath;
-    private bootstrapConfig;
-    private settingsStore;
-    constructor(configPath: string);
-    /** Called by main.ts after the SQLite DB is ready (Phase 2). */
-    setSettingsStore(store: ISettingsStore): void;
-    /**
-     * Get a config value by dot-notation path.
-     * Priority: bootstrap config -> SQL system_settings -> RUNTIME_DEFAULTS fallback.
-     */
-    get<T>(path: string): T;
-    /**
-     * Write a value to SQL system_settings.
-     * Throws if the settings store is not yet wired.
-     */
-    set(key: string, value: unknown): void;
-    /**
-     * Bulk-read all system_settings keys that belong to a logical section.
-     * A "section" is the first segment of a dot-notation key (e.g. 'features', 'logging').
-     */
-    getSection(section: string): Record<string, unknown>;
-    /**
-     * Bulk-write a section of runtime settings to SQL system_settings.
-     * Each entry in `data` is stored as `section.key`.
-     */
-    setSection(section: string, data: Record<string, unknown>): void;
-    /** Read all config for an addon from addon_settings. */
-    getAddonConfig(addonId: string): Record<string, unknown>;
-    /** Write (bulk-replace) config for an addon to addon_settings. */
-    setAddonConfig(addonId: string, config: Record<string, unknown>): void;
-    /** Read all config for a provider from provider_settings. */
-    getProviderConfig(providerId: string): Record<string, unknown>;
-    /** Write (upsert) a single key for a provider to provider_settings. */
-    setProviderConfig(providerId: string, key: string, value: unknown): void;
-    /** Read all config for a device from device_settings. */
-    getDeviceConfig(deviceId: string): Record<string, unknown>;
-    /** Write (upsert) a single key for a device to device_settings. */
-    setDeviceConfig(deviceId: string, key: string, value: unknown): void;
-    /** Get a value from the parsed bootstrap config */
-    getBootstrap<T>(path: string): T;
-    /** Features accessor -- reads from SQL when available, falls back to RUNTIME_DEFAULTS */
-    get features(): FeatureManifest;
-    /**
-     * Returns a merged view of bootstrap config + runtime defaults for backward compat.
-     */
-    get raw(): AppConfig;
-    /**
-     * Atomically update one top-level section of config.yaml and sync in-memory.
-     * Only bootstrap sections (server, auth) are persisted. Runtime settings should
-     * go to SQL (Plan B).
-     */
-    update(section: string, data: Record<string, unknown>): void;
-    /**
-     * Deep-set a value in a nested plain object using a dot-notation path.
-     * Returns a new object (immutable).
-     */
-    private setNested;
-    /**
-     * Apply env var overrides onto the raw YAML object.
-     * Only bootstrap-level env vars are applied.
-     */
-    private applyEnvOverrides;
-    private loadYaml;
-    private warnDefaultCredentials;
-    private getFromBootstrap;
-    private getFromRuntimeDefaults;
-    /**
-     * Perform a prefix-based nested lookup against SQL system_settings.
-     * e.g. path='features' matches keys 'features.streaming', 'features.notifications', etc.
-     * Returns an object keyed by the sub-key, or undefined if nothing is found.
-     */
-    private getNestedFromSystemSettings;
-}
-
 declare class SystemEventBus implements IEventBus {
     private readonly ringBuffer;
     private readonly subscribers;
@@ -1185,8 +574,8 @@ interface IStorageProvider {
     initialize(): Promise<void>;
     shutdown(): Promise<void>;
     getLocation(name: StorageLocationName): IStorageLocation;
-    export(locationName: StorageLocationName): Promise<Buffer>;
-    import(locationName: StorageLocationName, data: Buffer): Promise<void>;
+    export?(locationName: StorageLocationName): Promise<Buffer>;
+    import?(locationName: StorageLocationName, data: Buffer): Promise<void>;
 }
 interface QueryFilter {
     where?: Record<string, unknown>;
@@ -1223,94 +612,38 @@ interface IStorageLocation {
     structured?: IStructuredStorage;
     files?: IFileStorage;
 }
+/**
+ * StorageManager — bridge between legacy code (getLocation/getLocationPath)
+ * and the new capability-based storage system.
+ *
+ * Legacy consumers call getLocation('addon', namespace) to get structured + file storage.
+ * This manager builds the response from:
+ *   - SettingsBackend (for structured queries) — provided by sqlite-settings addon
+ *   - LocationManager (for file paths) — set during Phase 2 boot
+ */
 declare class StorageManager {
-    private provider;
+    private legacyProvider;
     private locationManager;
-    setProvider(provider: IStorageProvider): void;
+    private newStorageProvider;
+    private settingsBackend;
+    /** @deprecated Set by legacy capability consumer — use setNewStorageProvider instead */
+    setProvider(provider: IStorageProvider | IStorageProvider$1): void;
+    setNewStorageProvider(provider: IStorageProvider$1): void;
+    setSettingsBackend(backend: ISettingsBackend): void;
     getProvider(): IStorageProvider;
-    /**
-     * Set the StorageLocationManager (called from main.ts during Phase 2 boot,
-     * before NestJS lifecycle hooks run).
-     */
     setLocationManager(manager: StorageLocationManager): void;
-    /**
-     * Get the StorageLocationManager (for file path resolution).
-     * Available after Phase 2 boot (main.ts calls setLocationManager).
-     */
     getLocationManager(): StorageLocationManager;
-    /**
-     * Initialize the StorageLocationManager with a dataPath and set it on this service.
-     * Called during 3-phase boot from main.ts (Phase 2).
-     */
     initializeLocations(dataPath: string): Promise<void>;
-    /**
-     * Return the base filesystem path for a named storage location.
-     * Convenience wrapper around locationManager.getBackend(name).basePath.
-     * Available after Phase 2 boot (main.ts calls setLocationManager).
-     */
     getLocationPath(name: StorageLocationName): string;
     /**
-     * Get a storage location, optionally namespaced.
-     * Without namespace: returns the raw location (e.g., 'config' -> config DB)
-     * With namespace: returns a scoped view where all collections/paths are prefixed
-     *   e.g., getLocation('addon', 'providers/frigate-1') -> collections prefixed with 'providers/frigate-1/'
+     * Get a storage location with optional namespace scoping.
+     * Builds IStorageLocation from settingsBackend (structured) + locationManager (files).
      */
     getLocation(name: StorageLocationName | string, namespace?: string): IStorageLocation;
+    private createLegacyShim;
     private createNamespacedLocation;
 }
 
-/**
- * Thin wrapper over better-sqlite3 that manages the four settings tables:
- * system_settings, addon_settings, provider_settings, device_settings.
- *
- * All values are stored as JSON text and deserialized on read.
- */
-declare class SettingsStore {
-    private readonly db;
-    constructor(dbPath: string);
-    getSystem(key: string): unknown;
-    setSystem(key: string, value: unknown): void;
-    getAllSystem(): Record<string, unknown>;
-    getAddon(addonId: string, key: string): unknown;
-    setAddon(addonId: string, key: string, value: unknown): void;
-    getAllAddon(addonId: string): Record<string, unknown>;
-    /** Bulk-replace all keys for an addon (within a transaction). */
-    setAllAddon(addonId: string, config: Record<string, unknown>): void;
-    getProvider(providerId: string, key: string): unknown;
-    setProvider(providerId: string, key: string, value: unknown): void;
-    getAllProvider(providerId: string): Record<string, unknown>;
-    getDevice(deviceId: string, key: string): unknown;
-    setDevice(deviceId: string, key: string, value: unknown): void;
-    getAllDevice(deviceId: string): Record<string, unknown>;
-    /** Close the SQLite connection (call on shutdown). */
-    close(): void;
-    /** Check if system_settings is empty (used for first-boot seeding). */
-    isSystemSettingsEmpty(): boolean;
-    /** Seed system_settings with RUNTIME_DEFAULTS (only on first boot). */
-    seedDefaults(): void;
-    private initTables;
-}
-
-/** Core table DDL statements -- executed on first boot */
-declare const CORE_TABLE_DDL: readonly string[];
-/** Addon table schema declaration */
-interface AddonTableSchema {
-    readonly name: string;
-    readonly columns: ReadonlyArray<{
-        readonly name: string;
-        readonly type: 'TEXT' | 'INTEGER' | 'REAL' | 'JSON';
-        readonly primaryKey?: boolean;
-        readonly notNull?: boolean;
-    }>;
-    readonly indexes?: ReadonlyArray<{
-        readonly name: string;
-        readonly columns: readonly string[];
-        readonly unique?: boolean;
-    }>;
-}
-/** Generate CREATE TABLE DDL from addon schema */
-declare function addonTableToDdl(schema: AddonTableSchema): string[];
-
 /**
  * Manages scoped API tokens with restricted addon/route/capability access.
  * Framework-agnostic — dependencies injected via constructor.
@@ -1348,18 +681,6 @@ declare class ScopedTokenManager {
     updateLastUsed(tokenId: string): Promise<void>;
 }
 
-type UserRole = 'super_admin' | 'admin' | 'viewer';
-interface TokenPayload {
-    type?: 'api_key';
-    keyId?: string;
-    userId?: string;
-    username?: string;
-    role: UserRole;
-    allowedProviders: string[] | '*';
-    allowedDevices: Record<string, string[] | '*'>;
-    iat?: number;
-    exp?: number;
-}
 type AuthConfigReader = {
     get<T>(path: string): T;
     update(section: string, data: Record<string, unknown>): void;
@@ -1379,6 +700,15 @@ declare class AuthManager {
         prefix: string;
     };
     validateApiKey(token: string, storedHash: string): boolean;
+    /**
+     * Create a service token for agent/worker authentication.
+     * Used when forking workers or when agents register.
+     */
+    createServiceToken(opts: {
+        readonly agentId: string;
+        readonly role?: string;
+        readonly expiresIn?: string;
+    }): string;
     /**
      * Set the scoped token manager for the auth chain.
      */
@@ -1429,16 +759,6 @@ declare class ApiKeyManager {
     findById(id: string): Promise<ApiKeyRecord | null>;
 }
 
-interface UserRecord {
-    id: string;
-    username: string;
-    passwordHash: string;
-    role: UserRole;
-    allowedProviders: string[] | '*';
-    allowedDevices: Record<string, string[] | '*'>;
-    createdAt: number;
-    updatedAt: number;
-}
 interface CreateUserInput {
     username: string;
     password: string;
@@ -1612,6 +932,125 @@ declare class CapabilityResolver {
     getEffectiveCapabilities(device: IResolvableDevice): string[];
 }
 
+interface TlsCertPair {
+    readonly cert: Buffer;
+    readonly key: Buffer;
+}
+interface EnsureTlsResult {
+    readonly certPath: string;
+    readonly keyPath: string;
+    readonly generated: boolean;
+}
+interface CertOptions {
+    /** Common Name for the cert (default: 'camstack.local') */
+    readonly commonName?: string;
+    /** Validity in days (default: 825 — max for browsers) */
+    readonly validDays?: number;
+    /** Additional SANs (DNS names or IPs) */
+    readonly extraSans?: readonly string[];
+}
+/**
+ * Ensure a self-signed TLS certificate exists in the given directory.
+ * Generates one if missing. Returns paths to cert and key files.
+ */
+declare function ensureTlsCert(dataDir: string, options?: CertOptions): Promise<EnsureTlsResult>;
+/**
+ * Load TLS cert+key from files. Returns Buffers suitable for Node.js TLS options.
+ */
+declare function loadTlsCert(certPath: string, keyPath: string): TlsCertPair;
+
+/**
+ * Factory for creating tRPC clients for addons.
+ *
+ * Two modes:
+ * - Direct caller (in-process): zero overhead, uses createCallerFactory
+ * - WSS client (worker/agent): real WebSocket connection to the server
+ */
+interface DirectCallerOptions {
+    /** The tRPC router instance (from buildAppRouter) */
+    readonly router: unknown;
+    /** Context for the caller (user identity, etc.) */
+    readonly context: {
+        readonly user: {
+            readonly id: string;
+            readonly username: string;
+            readonly role: string;
+        };
+    };
+}
+interface WssClientOptions {
+    /** WebSocket URL (e.g., wss://localhost:4443/trpc) */
+    readonly url: string;
+    /** Auth token for the connection */
+    readonly token: string;
+}
+declare class AddonApiFactory {
+    /**
+     * Build a WSS URL from host and port.
+     */
+    buildWssUrl(host: string, port: number): string;
+    /**
+     * 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
+     */
+    createDirectCaller(options: DirectCallerOptions): unknown;
+    /**
+     * 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
+     */
+    createWssClient(options: WssClientOptions): Promise<{
+        readonly client: unknown;
+        readonly close: () => void;
+    }>;
+}
+
+declare class PlatformScorer {
+    private cached;
+    /** Probe hardware + runtimes and score all backend combos. Cached after first call. */
+    probe(): Promise<PlatformCapabilities>;
+    probeHardware(): Promise<HardwareInfo>;
+    private probeNodeBackends;
+    private probePythonBackends;
+    private scoreBackends;
+}
+
+declare class InferenceConfigResolver {
+    private readonly scores;
+    private readonly hardware;
+    constructor(scores: readonly PlatformScore[], hardware: HardwareInfo);
+    /**
+     * 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)
+     */
+    private getWeights;
+    /**
+     * 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: readonly ModelRequirement[]): ResolvedInferenceConfig;
+}
+
 /** Minimal device registry interface for provider management */
 type ProviderDeviceRegistry = {
     registerProviderDevices(providerId: string, devices: readonly IRegistrableDevice[]): void;
@@ -1644,14 +1083,7 @@ interface IManagedProvider {
     getDevices(): readonly IRegistrableDevice[];
     subscribeLiveEvents(callback: (event: LiveEvent) => void): () => void;
 }
-interface ProviderListItem {
-    id: string;
-    type: string;
-    name: string;
-    status: ProviderStatus;
-    started: boolean;
-    lifecycle: ElementStatus;
-}
+
 declare class ProviderManager<P extends IManagedProvider = IManagedProvider> {
     private readonly deviceRegistry;
     private readonly eventBus;
@@ -1671,4 +1103,4 @@ declare class ProviderManager<P extends IManagedProvider = IManagedProvider> {
     shutdownAll(): Promise<void>;
 }
 
-export { AddonEngineManager, AddonInstaller, type AddonInstallerConfig, AddonLoader, AddonRouteRegistry, type AddonTableSchema, AdminUIAddon, AgentClient, type AgentClientConfig, type AgentEntry, type AgentEventEmitter, type AgentInfo, AgentRegistry, type AgentResources, type AgentStatus, type AgentTask, type AgentTaskResult, AgentTaskRunner, ApiKeyManager, type ApiKeyRecord, type ApiKeyStorageAccess, type AppConfig, type AuthConfigReader, AuthManager, BUILTIN_PACKAGES, type BackupConfig, type BackupManifest, type BinaryHandler, type BootstrapConfig, CORE_TABLE_DDL, type CapabilityBinding, CapabilityRegistry, CapabilityResolver, type ClientNetworkStats, ConfigManager, type ConnectionHandler, DecodeTaskHandler, DetectTaskHandler, type DeviceNetworkStats, DeviceRegistry, type ElementState, type ElementStatus, EventBus, type FeatureConfigReader, type FeatureFlag, FeatureManager, type FeatureManifest, FileSystemStorage, FsStorageBackend, type IAddonRegistryAccess, type IStorageProvider as ICoreStorageProvider, type IDeviceCapability, type IFileStorage, type ILogDestination, type IManagedProvider, INFRA_CAPABILITIES, type INetworkQualityTracker, type IRegisteredDevice, type IReplContextProvider, type IReplEngine, type IResolvableDevice, type ISettingsStore, type IStorageBackend, type IStorageLocation, type IStructuredStorage, type InfraCapability, type InstalledPackage, LifecycleStateMachine, LocalBackupAddon, LocalBackupService, type LogEntry, type LogFilter, type LogLevel, LogManager, LogRingBuffer, ManagedProcess, type ManagedProcessStatus, type MessageHandler, NetworkQualityTracker, NotificationService, PipelineRunner, PipelineValidator, type ProcessConfig, type ProcessEventEmitter, type ProcessLoggerFactory, ProcessManager, type ProcessState, type ProcessStats, type ProviderDeviceRegistry, type ProviderListItem, ProviderManager, PythonEnvManager, type QueryFilter, RUNTIME_DEFAULTS, RecordTaskHandler, type RegisteredAddon, ReplEngine, type ReplResult, type ReplScope, type ReplSessionContext, ScopedLogger, ScopedTokenManager, type ServerMode, SettingsStore, SqliteStorageAddon, SqliteStorageProvider, StorageLocationManager, type StorageLocationName, StorageManager, type StorageRecord, type StreamNetworkStats, SystemEventBus, type TaskDispatchOptions, TaskDispatcher, ToastService, type TokenPayload, type Unsubscribe, type UserConfigReader, UserManager, type UserRecord, type UserRole, type UserStorageAccess, type ValidationIssue, type ValidationResult, WinstonDestination, WinstonLoggingAddon, addonTableToDdl, bootstrapSchema, downloadModel, isInfraCapability };
+export { AddonApiFactory, AddonRouteRegistry, AgentClient, type AgentClientConfig, type AgentEventEmitter, AgentRegistry, AgentTaskRunner, ApiKeyManager, type ApiKeyRecord, type ApiKeyStorageAccess, type AuthConfigReader, AuthManager, type BinaryHandler, type CapabilityBinding, CapabilityResolver, type CertOptions, type ConnectionHandler, DecodeTaskHandler, DetectTaskHandler, DeviceRegistry, type DirectCallerOptions, type ElementState, type ElementStatus, type EnsureTlsResult, EventBus, type FeatureConfigReader, FeatureManager, FsStorageBackend, type IAddonRegistryAccess, type IStorageProvider as ICoreStorageProvider, type IDeviceCapability, type IFileStorage, type ILogDestination, type IManagedProvider, type IRegisteredDevice, type IReplContextProvider, type IReplEngine, type IResolvableDevice, type IStorageBackend, type IStorageLocation, type IStructuredStorage, InferenceConfigResolver, LifecycleStateMachine, LogManager, LogRingBuffer, ManagedProcess, type MessageHandler, ModelDownloadService, NetworkQualityTracker, NotificationService, PYTHON_VERSION, PipelineRunner, PipelineValidator, PlatformScorer, type ProcessEventEmitter, type ProcessLoggerFactory, ProcessManager, type ProcessState, type ProviderDeviceRegistry, ProviderManager, PythonEnvManager, type QueryFilter, RecordTaskHandler, ReplEngine, type ReplScope, type ReplSessionContext, ScopedLogger, ScopedTokenManager, StorageLocationManager, type StorageLocationName, StorageManager, type StorageRecord, SystemEventBus, TaskDispatcher, type TlsCertPair, ToastService, type Unsubscribe, type UserConfigReader, UserManager, type UserStorageAccess, type WssClientOptions, buildBinaryPath, downloadBinary, downloadFile, downloadModel, ensureBinary, ensureFfmpeg, ensurePython, ensureTlsCert, fetchJson, findInPath, getFfmpegDownloadUrl, getPlatformInfo, getPythonDownloadUrl, installPythonPackages, loadTlsCert };