@camstack/core 0.1.15 → 0.1.17

package/dist/index.d.mts

@@ -1,1696 +0,0 @@
-import { FilesystemStorageProvider } from '@camstack/types/node';
-export { FilesystemStorageProvider, PYTHON_VERSION, PlatformInfo, buildBinaryPath, downloadBinary, ensureBinary, ensureFfmpeg, ensurePython, findInPath, getFfmpegDownloadUrl, getPlatformInfo, getPythonDownloadUrl, installPythonPackages, installPythonRequirements } from '@camstack/types/node';
-import * as _camstack_types from '@camstack/types';
-import { ModelCatalogEntry, ModelFormat, ModelDownloadOptions, ModelDownloadResult, IAddonModelManager, IPythonEnvironment, PythonProbeResult, PythonEnvReady, PipelineConfig, ValidationResult, IAddonResolver, FrameInput, PipelineResult, IEngineManager, IAddonCaller, INetworkQualityTracker, ClientNetworkStats, DeviceNetworkStats, ReplResult, BaseAddon, ProviderRegistration, ISettingsBackend, SettingsGetInput, SettingsSetInput, SettingsQueryInput, SettingsRecord, SettingsInsertInput, SettingsUpdateInput, SettingsDeleteInput, SettingsCountInput, SettingsIsEmptyInput, CollectionColumn, CollectionIndex, TableSchema, TableQueryOptions, ILogDestination as ILogDestination$1, LogEntry, LogFilter, IScopedLogger, IClusterBroker, IEventBus, BackupManifest, Alert, SystemResourceSnapshot, DiskSpaceInfo, MetricsGpuInfo, PidResourceStats, MemoryInfo, ConfigUISchemaWithValues, DeviceBindingEntry, FeatureManifest, FeatureFlag, SystemEvent, EventFilter, LogTags, LogExtras, IStorageProvider as IStorageProvider$1, SettingsStoreClient, TokenScope, ScopedToken, TokenPayload, UserRole, ApiKeyRecord, UserRecord, ICapabilityRegistry, INotificationOutput, Notification, Toast, IAddonRouteProvider, IAddonHttpRoute, IIntegrationRegistry, CreateIntegrationInput, Integration, CreateDeviceInput, PersistedDevice } from '@camstack/types';
-export { ApiKeyRecord, BackupManifest, ClientNetworkStats, DeviceNetworkStats, EventFilter, EventSource, FeatureFlag, FeatureManifest, INetworkQualityTracker, IScopedLogger, LogEntry, LogFilter, LogLevel, ReplResult, StreamNetworkStats, SystemEvent, TokenPayload, UserRecord, UserRole, ValidationIssue, ValidationResult } from '@camstack/types';
-import { ChildProcess } from 'node:child_process';
-import Database from 'better-sqlite3';
-
-type EventCallback<T = unknown> = (data: T) => void;
-declare class EventBus {
-    private listeners;
-    on<T = unknown>(event: string, callback: EventCallback<T>): () => void;
-    emit<T = unknown>(event: string, data: T): void;
-    once<T = unknown>(event: string, callback: EventCallback<T>): () => void;
-    removeAllListeners(event?: string): void;
-    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>;
-/** Progress callback: (downloadedBytes, totalBytes | undefined) */
-type DownloadProgressCallback = (downloaded: number, total: number | undefined) => void;
-/**
- * Resolve a `ModelCatalogEntry` against `modelsDir`: download model file
- * (or directory bundle) + extra files (labels JSON, charset dict, …),
- * skip if already on disk. Returns the local model path.
- */
-declare function ensureModel(modelsDir: string, entry: ModelCatalogEntry, format: ModelFormat, onProgress?: DownloadProgressCallback): Promise<string>;
-/** Compute the on-disk path for a given model + format, even when not yet downloaded. */
-declare function getModelFilePath(modelsDir: string, entry: ModelCatalogEntry, format: ModelFormat): string | null;
-/** True iff the model file (or `Manifest.json` for directory bundles) exists and is non-empty. */
-declare function isModelDownloaded(modelsDir: string, entry: ModelCatalogEntry, format: ModelFormat): boolean;
-/** Remove the on-disk model file/directory. Returns true if something was deleted. */
-declare function deleteModelFromDisk(modelsDir: string, entry: ModelCatalogEntry, format: ModelFormat): boolean;
-
-/**
- * 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;
-    /** 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 venvPath;
-    private cachedProbe;
-    constructor(dataDir: string);
-    probe(): Promise<PythonProbeResult>;
-    ensure(options: {
-        packages: readonly string[];
-    }): Promise<PythonEnvReady>;
-    spawn(script: string, args: readonly string[]): ChildProcess;
-}
-
-/**
- * Check if a pipeline step is available in the system.
- * Implementations should check the capability registry for `pipeline-step:{stepId}`.
- */
-type StepExistsFn = (stepId: string) => boolean;
-declare class PipelineValidator {
-    private readonly stepExists;
-    constructor(stepExists: StepExistsFn);
-    validate(config: PipelineConfig): ValidationResult;
-    private validateNode;
-}
-
-declare class PipelineRunner {
-    private readonly addonResolver;
-    constructor(addonResolver: IAddonResolver);
-    run(frame: FrameInput, config: PipelineConfig): Promise<PipelineResult>;
-    private executeNode;
-    private executeChildren;
-}
-
-/**
- * Adapter that wraps an IEngineManager + addonConfigs as an IAddonResolver.
- *
- * Used for backwards compatibility — the in-process AddonEngineManager
- * still uses the old getOrCreateEngine(addonId, globalConfig, override) API.
- * This adapter bridges it to the new resolve(addonId, config) interface.
- */
-declare class EngineManagerResolver implements IAddonResolver {
-    private readonly engineManager;
-    private readonly addonConfigs;
-    constructor(engineManager: IEngineManager, addonConfigs: Map<string, Record<string, unknown>>);
-    resolve(addonId: string, config: Record<string, unknown>): Promise<IAddonCaller>;
-    shutdownAll(): Promise<void>;
-}
-
-interface PidStats {
-    cpu: number;
-    memory: number;
-}
-/**
- * Get CPU% and memory RSS for one or more PIDs.
- * Returns a map of pid → stats. Missing/dead PIDs are silently omitted.
- */
-declare function getPidStats(pids: number | readonly number[]): Promise<ReadonlyMap<number, PidStats>>;
-/** Get CPU% and memory RSS for a single PID. Returns null if dead. */
-declare function getSinglePidStats(pid: number): Promise<PidStats | null>;
-
-declare class NetworkQualityTracker implements INetworkQualityTracker {
-    private readonly devices;
-    private static readonly MAX_SAMPLES;
-    reportStreamStats(deviceId: number, streamId: string, bitrateKbps: number, packetLoss?: number): void;
-    reportClientStats(deviceId: number, stats: Omit<ClientNetworkStats, 'lastUpdated'>): void;
-    getDeviceStats(deviceId: number): DeviceNetworkStats | null;
-    getAllStats(): readonly DeviceNetworkStats[];
-    private getOrCreateDevice;
-}
-
-interface ReplScope {
-    readonly type: 'system' | 'provider' | 'device' | 'addon';
-    readonly providerId?: string;
-    readonly deviceId?: number;
-    readonly addonId?: string;
-}
-interface ReplSessionContext {
-    readonly scope: ReplScope;
-    /** Pre-populated variables available in the REPL session */
-    readonly variables: Record<string, unknown>;
-}
-
-interface IReplEngine {
-    execute(code: string, context: ReplSessionContext): Promise<ReplResult>;
-    getCompletions(partial: string, context: ReplSessionContext): Promise<string[]>;
-}
-/**
- * Context provider that the server kernel implements.
- * The REPL engine calls this to build the sandbox for each scope type.
- *
- * Methods may return a Promise so the kernel can warm up async
- * resources (e.g. `SystemManager.init()`) before exposing them — the
- * engine awaits each before evaluating user code.
- */
-interface IReplContextProvider {
-    getSystemSandbox(): Record<string, unknown> | Promise<Record<string, unknown>>;
-    getDeviceSandbox(deviceId: number): Record<string, unknown> | Promise<Record<string, unknown>>;
-    getProviderSandbox(providerId: string): Record<string, unknown> | Promise<Record<string, unknown>>;
-    getAddonSandbox(addonId: string): Record<string, unknown> | Promise<Record<string, unknown>>;
-}
-
-declare class ReplEngine implements IReplEngine {
-    private readonly contextProvider;
-    constructor(contextProvider: IReplContextProvider);
-    execute(code: string, context: ReplSessionContext): Promise<ReplResult>;
-    getCompletions(partial: string, context: ReplSessionContext): Promise<string[]>;
-    private buildSandbox;
-}
-
-interface FilesystemStorageConfig {
-    readonly rootPath: string;
-}
-/**
- * Filesystem Storage addon — provides local disk storage for all location types.
- * Capability: 'storage' (collection)
- */
-declare class FilesystemStorageAddon extends BaseAddon<FilesystemStorageConfig> {
-    private provider;
-    constructor();
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    protected onShutdown(): Promise<void>;
-    getProvider(): FilesystemStorageProvider | null;
-}
-
-/**
- * SQLite implementation of ISettingsBackend.
- *
- * Every collection is structured: declared at boot (canonical KV
- * collections) or via `declareCollection` (typed schemas like
- * `pipeline-analytics:tracks`). The legacy auto-create-on-first-access
- * path was removed — see commit history for the migration. Operations
- * on undeclared collections throw at runtime so callers fail fast.
- *
- * WAL mode for concurrent reads.
- */
-declare class SqliteSettingsBackend implements ISettingsBackend {
-    private readonly dbPath;
-    private db;
-    private readonly structuredTables;
-    /** Map from scoped collection name → set of column names (non-id) that
-     *  the structured schema owns. Routes set/get/insert/update/query to
-     *  typed columns. Every collection MUST be declared here before use. */
-    private readonly declaredCollections;
-    private readonly runtimeDefaults;
-    /**
-     * Canonical key/value collections — declared with a `(id TEXT PK,
-     * data TEXT NOT NULL)` schema at boot so existing JSON-blob rows
-     * keep working through the structured path. Generates SQL identical
-     * to the previous legacy path; only the routing is unified.
-     */
-    private static readonly CANONICAL_KV_COLLECTIONS;
-    constructor(dbPath: string, runtimeDefaults?: Record<string, unknown>);
-    initialize(): Promise<void>;
-    private requireDeclared;
-    shutdown(): Promise<void>;
-    get({ namespace, collection, key }: SettingsGetInput): Promise<unknown>;
-    set({ namespace, collection, key, value }: SettingsSetInput): Promise<void>;
-    query<T extends object = Record<string, unknown>>({ namespace, collection, filter }: SettingsQueryInput): Promise<readonly SettingsRecord<T>[]>;
-    insert<T extends object = Record<string, unknown>>({ namespace, collection, record }: SettingsInsertInput<T>): Promise<void>;
-    update({ namespace, collection, id, data }: SettingsUpdateInput): Promise<void>;
-    delete({ namespace, collection, key }: SettingsDeleteInput): Promise<void>;
-    count({ namespace, collection, filter }: SettingsCountInput): Promise<number>;
-    isEmpty({ namespace, collection }: SettingsIsEmptyInput): Promise<boolean>;
-    private queryDeclared;
-    /** Get a system setting by dot-notation key */
-    getSystem(key: string): unknown;
-    /** Set a system setting */
-    setSystem(key: string, value: unknown): void;
-    /** Get all system settings as flat key-value */
-    getAllSystem(): Record<string, unknown>;
-    /** Get all settings for an addon */
-    getAllAddon(addonId: string): Record<string, unknown>;
-    /** Bulk-set all settings for an addon */
-    setAllAddon(addonId: string, config: Record<string, unknown>): void;
-    /** Get all settings for a provider */
-    getAllProvider(providerId: string): Record<string, unknown>;
-    /** Set a provider setting */
-    setProvider(providerId: string, key: string, value: unknown): void;
-    /** Get all settings for a device */
-    getAllDevice(deviceId: string): Record<string, unknown>;
-    /** Set a device setting */
-    setDevice(deviceId: string, key: string, value: unknown): void;
-    getAddonDevice(addonId: string, deviceId: string): Record<string, unknown>;
-    setAddonDevice(addonId: string, deviceId: string, values: Record<string, unknown>): void;
-    clearAddonDevice(addonId: string, deviceId: string): void;
-    /** Seed system-settings with runtime defaults (first boot) */
-    private seedDefaults;
-    /**
-     * Expose the raw better-sqlite3 Database instance for components that
-     * need direct SQL access (e.g. DeviceStore, ConfigStore).
-     * Returns null if the backend has not been initialized yet.
-     */
-    getDatabase(): Database.Database | null;
-    private getDb;
-    private getAllScoped;
-    private setScopedKey;
-    private scopedName;
-    declareCollection(input: {
-        namespace?: string;
-        collection: string;
-        columns: readonly CollectionColumn[];
-        indexes?: readonly CollectionIndex[];
-    }): Promise<void>;
-    /** Serialise per-column values for SQL binding: objects → JSON, booleans → 0/1. */
-    private serializeColumnValue;
-    ensureTable(table: string, schema: TableSchema): Promise<void>;
-    tableInsert(table: string, row: Record<string, unknown>): Promise<void>;
-    tableUpdate(table: string, filter: Record<string, unknown>, updates: Record<string, unknown>): Promise<number>;
-    tableDelete(table: string, filter: Record<string, unknown>): Promise<number>;
-    tableQuery(table: string, options?: TableQueryOptions): Promise<readonly Record<string, unknown>[]>;
-    tableGet(table: string, filter: Record<string, unknown>): Promise<Record<string, unknown> | null>;
-    tableCount(table: string, filter?: Record<string, unknown>): Promise<number>;
-    private buildWhere;
-}
-
-/**
- * SQLite Settings addon — provides persistent settings storage.
- * Capability: 'settings-store' (singleton)
- */
-declare class SqliteSettingsAddon extends BaseAddon {
-    private backend;
-    constructor();
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    protected onShutdown(): Promise<void>;
-    getBackend(): SqliteSettingsBackend | null;
-}
-
-/**
- * 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>;
-    getAddonDevice(addonId: string, deviceId: string): Record<string, unknown>;
-    /**
-     * Bulk-replace all per-device overrides for (addonId, deviceId) in a
-     * single transaction. Empty input clears the override set — caller
-     * should use `clearAddonDevice` for explicit resets.
-     */
-    setAddonDevice(addonId: string, deviceId: string, values: Record<string, unknown>): void;
-    clearAddonDevice(addonId: string, deviceId: string): void;
-    /** 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[];
-
-interface DeviceRow {
-    readonly stableId: string;
-    readonly type: string;
-    readonly name: string;
-    readonly parentStableId: string | null;
-    readonly enabled: boolean;
-}
-interface InsertInput {
-    readonly stableId: string;
-    readonly type: string;
-    readonly name: string;
-    readonly parentStableId: string | null;
-}
-declare class DeviceStore {
-    private readonly db;
-    constructor(db: Database.Database);
-    insert(addonId: string, device: InsertInput): void;
-    listByAddon(addonId: string): readonly DeviceRow[];
-    listChildren(addonId: string, parentStableId: string): readonly DeviceRow[];
-    remove(addonId: string, stableId: string): void;
-}
-
-declare class ConfigStore {
-    private readonly db;
-    constructor(db: Database.Database);
-    save(addonId: string, stableId: string | null, data: Record<string, unknown>): void;
-    load(addonId: string, stableId: string | null): Record<string, unknown>;
-    remove(addonId: string, stableId: string | null): void;
-}
-
-interface WinstonConfig$1 {
-    readonly level: string;
-    readonly retentionDays: number;
-    /** Resolved absolute path to the logs directory (replaces the old dataPath field). */
-    readonly logsDir: string;
-}
-/**
- * Rotated-file log destination. Console output goes through the shared
- * `formatLogLine` so every console sink (Winston, ConsoleDestination,
- * HubForwarderDestination) emits identical lines. File output keeps a
- * structured JSON shape so log tooling can query tags/meta.
- */
-declare class WinstonDestination implements ILogDestination$1 {
-    private logger;
-    initialize(config?: WinstonConfig$1): Promise<void>;
-    write(entry: LogEntry): void;
-    query(_filter: LogFilter): Promise<readonly LogEntry[]>;
-    shutdown(): Promise<void>;
-}
-
-interface WinstonConfig {
-    readonly level: string;
-    readonly retentionDays: number;
-}
-/**
- * Winston logging addon — rotated log files + console output.
- * Settings appear under Cluster → NodeDetail → Settings.
- */
-declare class WinstonLoggingAddon extends BaseAddon<WinstonConfig> {
-    private destination;
-    constructor();
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    protected onShutdown(): Promise<void>;
-    getDestination(): WinstonDestination;
-    protected globalSettingsSchema(): _camstack_types.ConfigUISchema;
-}
-
-/**
- * Zero-dependency log destination that writes every entry to stdout /
- * stderr via the shared `formatLogLine` formatter. Same surface as
- * `WinstonDestination` (full `ILogDestination` contract) but without
- * the rotating-file transport — ideal fallback when the Winston addon
- * is disabled or unavailable (e.g. bare-bones agents, tests).
- */
-
-interface ConsoleConfig$1 {
-    /** Minimum log level to emit. Entries below this level are dropped. */
-    readonly level?: 'debug' | 'info' | 'warn' | 'error';
-}
-declare class ConsoleDestination implements ILogDestination$1 {
-    private minLevel;
-    initialize(config?: ConsoleConfig$1): Promise<void>;
-    write(entry: LogEntry): void;
-    query(_filter: LogFilter): Promise<readonly LogEntry[]>;
-    shutdown(): Promise<void>;
-}
-
-interface ConsoleConfig {
-    readonly level: 'debug' | 'info' | 'warn' | 'error';
-}
-/**
- * Console logging addon — zero-dependency stdout/stderr sink that
- * produces the same canonical line format as the Winston built-in.
- * Registers as a `log-destination` capability provider so the shared
- * LogManager fans every entry to both sinks when both are active.
- *
- * Settings live under Cluster → NodeDetail → Settings alongside the
- * Winston addon. Disable one without disabling the other — the
- * LogManager keeps working as long as at least one destination is
- * registered.
- */
-declare class ConsoleLoggingAddon extends BaseAddon<ConsoleConfig> {
-    private destination;
-    constructor();
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    protected onShutdown(): Promise<void>;
-    getDestination(): ConsoleDestination;
-    protected globalSettingsSchema(): _camstack_types.ConfigUISchema;
-}
-
-/**
- * Log destination for agent mode.
- *
- * - Writes to console ONLY when hub is not yet reachable (cold-start
- *   fallback). Forked-worker agents share stdout with their parent
- *   hub, so logging to local console AND forwarding to hub's
- *   `log-receiver` would print the entry twice on the hub terminal.
- *   Once the hub is discovered, local console output stops and the
- *   hub's own ConsoleDestination owns the render.
- * - When a Moleculer broker is connected and the hub node is reachable,
- *   forwards every log entry to the hub via `log-receiver.ingest`.
- * - Entries written before the hub is reachable are buffered internally
- *   (ring-buffered to `DEFAULT_OUTBOUND_BUFFER_SIZE`) and flushed on connect,
- *   so boot-time logs still reach the hub without any external replay trigger.
- */
-declare class HubForwarderDestination implements ILogDestination$1 {
-    private broker;
-    private hubConnected;
-    private readonly outboundBuffer;
-    private statusLogger;
-    initialize(): Promise<void>;
-    /**
-     * Provide a logger for the destination's own status messages
-     * (discovery, disconnect, reconnect). Routed through the agent's
-     * LogManager but never through this same destination — the owning
-     * addon must hand in a logger that does NOT route back here, or
-     * status writes will recurse.
-     */
-    setStatusLogger(logger: IScopedLogger): void;
-    private status;
-    /**
-     * Attach the Moleculer broker so hub forwarding can start.
-     * Called by the owning addon from `onInitialize(ctx)` with
-     * `ctx.kernel.cluster?.broker`.
-     */
-    connectBroker(broker: IClusterBroker): void;
-    write(entry: LogEntry): void;
-    query(_filter: LogFilter): Promise<readonly LogEntry[]>;
-    shutdown(): Promise<void>;
-    private bufferOutbound;
-    private flushOutbound;
-    private forward;
-}
-
-/**
- * Agent-only addon that provides the `log-destination` capability.
- * Writes all logs to the console and forwards to the hub via Moleculer when
- * reachable. The broker is read from `ctx.kernel.cluster?.broker`; outbound
- * log replay on hub-connect is handled internally by the destination.
- */
-declare class HubForwarderAddon extends BaseAddon {
-    private destination;
-    constructor();
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    getDestination(): HubForwarderDestination | null;
-    protected onShutdown(): Promise<void>;
-}
-
-interface BackupConfig {
-    readonly backupDir: string;
-    readonly retentionCount: number;
-}
-declare class LocalBackupService {
-    private readonly config;
-    private readonly logger;
-    private readonly eventBus;
-    private manifests;
-    constructor(config: BackupConfig, logger: IScopedLogger, eventBus: IEventBus);
-    /** 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;
-}
-
-interface LocalBackupAddonConfig {
-    readonly retentionCount: number;
-}
-/**
- * Local backup addon — snapshot-based backup/restore of camstack data.
- * Settings appear under Cluster → NodeDetail → Settings.
- */
-declare class LocalBackupAddon extends BaseAddon<LocalBackupAddonConfig> {
-    private service;
-    constructor();
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    protected onShutdown(): Promise<void>;
-    getService(): LocalBackupService;
-    protected globalSettingsSchema(): _camstack_types.ConfigUISchema;
-}
-
-interface NativeMetricsConfig {
-    readonly samplingIntervalMs: number;
-}
-/**
- * Native metrics — CPU, memory, disk usage sampling.
- * Settings appear under Cluster → NodeDetail → Settings.
- */
-declare class NativeMetricsAddon extends BaseAddon<NativeMetricsConfig> {
-    private provider;
-    private startedAtMs;
-    private snapshotTimer;
-    /**
-     * Snapshot-equality cache for the resources + processes emit.
-     * Stores the coarsened JSON and timestamp; a tick where the
-     * coarsened payload matches the cache (and the heartbeat hasn't
-     * elapsed) is skipped.
-     */
-    private lastResourcesEmit;
-    private lastProcessesEmit;
-    constructor();
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    protected onShutdown(): Promise<void>;
-    /**
-     * Emit one `metrics.node-resources-snapshot` + one
-     * `metrics.node-processes-snapshot` for this node. UI consumers
-     * subscribe and read state directly from the payload.
-     */
-    private emitMetricsSnapshots;
-    protected onConfigChanged(): Promise<void>;
-    private listWorkerInstances;
-    private listAddonInstances;
-    private getAddonStats;
-    /**
-     * Walk the OS process table and classify each camstack-shaped process.
-     *
-     * Classification (ancestry-driven, NOT pattern-driven):
-     *  - root    — the current node's own pid (`process.pid`).
-     *  - managed — pid is registered in the kernel's `$process.list`
-     *              (forked addon worker spawned by this hub).
-     *  - system  — ancestry walk crosses a SUPERVISOR_BOUNDARY_RE match
-     *              (tsx-watch launcher, agent CLI, concurrently, vite,
-     *              npm exec wrapper). The process belongs to the dev
-     *              tree even if not in `$process.list`. NEVER killable.
-     *  - ghost   — ancestry walk reaches `ppid=1` without crossing any
-     *              supervisor boundary AND the parent isn't visible in
-     *              `ps`. A truly orphaned camstack-shaped process. The
-     *              ONLY classification that's eligible for kill.
-     *
-     * Old pattern-only ghost detection produced false positives: every
-     * monorepo-path process matched CAMSTACK_CMD_RE, ancestry walk
-     * stopping at ppid=hub returned false-positive ghosts whenever a
-     * concurrently sibling sat above hub. Ancestry-driven classification
-     * fixes that.
-     */
-    private listNodeProcesses;
-    /**
-     * Send SIGTERM / SIGKILL to a pid. Refuses pids that don't appear in
-     * `listNodeProcesses()` to prevent arbitrary system kills — a dedicated
-     * admin-path for resurrected zombies, not a generic shell replacement.
-     *
-     * `root`-classified pids (the running launcher / agent CLI / hub itself)
-     * are also refused: killing them tears down the whole node and the
-     * operator's intent is almost always to nuke a leaked child, not the
-     * supervisor that keeps the rest alive. Process restart goes through
-     * the dedicated `$process.restart` action, not this kill API.
-     */
-    private killProcess;
-    /** Raw `ps` scan returning every pid + command + resource stats. */
-    private runPs;
-    protected globalSettingsSchema(): _camstack_types.ConfigUISchema;
-}
-
-interface AlertCenterConfig {
-    readonly maxAlerts: number;
-    readonly retentionDays: number;
-}
-/**
- * Alert Center addon — core builtin that persists alerts in a
- * structured SQLite table and serves them to the admin UI.
- *
- * Registers as an `alerts` collection provider and subscribes to
- * important EventBus categories to create/update alerts automatically.
- */
-declare class AlertCenterAddon extends BaseAddon<AlertCenterConfig> {
-    private unsubscribers;
-    constructor();
-    /**
-     * Per `(category, source.id)` counter used to rate-limit chatty
-     * events. Entries are pruned lazily when they age out of
-     * `RATE_LIMIT_WINDOW_MS`; see `shouldSuppressByRate()` below.
-     */
-    private readonly rateLimitCounters;
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    protected onShutdown(): Promise<void>;
-    protected globalSettingsSchema(): _camstack_types.ConfigUISchema;
-    listAlerts(filter?: {
-        unreadOnly?: boolean;
-        limit?: number;
-    }): Promise<readonly Alert[]>;
-    getUnreadCount(): Promise<number>;
-    markRead(alertId: string): Promise<void>;
-    markAllRead(): Promise<void>;
-    dismiss(alertId: string): Promise<void>;
-    private handleEvent;
-    private handleModelDownload;
-    /**
-     * `[ALERT-CENTER-EVENTS]` — rate limit a `(category, source.id)`
-     * tuple. Returns `true` when the caller should DROP this event
-     * without persisting an alert, and `false` when the alert should
-     * proceed normally.
-     *
-     * Heuristic: the first `RATE_LIMIT_MAX_PER_SOURCE` events within a
-     * `RATE_LIMIT_WINDOW_MS` window go through. Once the threshold is
-     * crossed, subsequent events are suppressed until the window rolls
-     * over. When the threshold is first crossed, the suppression is
-     * logged once so operators know why they're not seeing the follow-
-     * up alerts; after the window rolls over the next event is
-     * un-suppressed and starts a new window.
-     */
-    private shouldSuppressByRate;
-    private buildMessage;
-    private emitAlert;
-    private updateAlert;
-    /**
-     * Read-merge-write: SettingsBackend.update() replaces the entire `data` blob,
-     * so we must read the existing record, merge the patch, and write back.
-     */
-    private mergeUpdate;
-    private persistAlert;
-    private emitAlertCreatedEvent;
-    private emitAlertUpdatedEvent;
-    private enforceMaxAlerts;
-    private enforceRetention;
-}
-
-interface SamplingDiagnostics {
-    warn(message: string, meta?: Record<string, unknown>): void;
-}
-declare class NativeMetricsProvider {
-    readonly id = "native";
-    private cachedSnapshot;
-    private samplingTimer;
-    private macMemTimer;
-    private prevCpu;
-    private diagnostics;
-    private consecutiveSampleErrors;
-    constructor();
-    /**
-     * Optional diagnostics sink for sampling errors. The first failure and
-     * every Nth failure thereafter are reported so a permanently-broken
-     * collector doesn't spam logs but is still observable.
-     */
-    setDiagnostics(diag: SamplingDiagnostics): void;
-    startSampling(intervalMs: number): void;
-    private reportSampleError;
-    stopSampling(): void;
-    collectSnapshot(): Promise<SystemResourceSnapshot>;
-    getCached(): Promise<SystemResourceSnapshot | null>;
-    getCurrent(): Promise<{
-        cpuPercent: number;
-        memoryPercent: number;
-        memoryUsedMB: number;
-        memoryTotalMB: number;
-        diskPercent?: number;
-        temperature?: number;
-        gpuPercent?: number;
-        gpuMemoryPercent?: number;
-    }>;
-    getDiskSpace(input: {
-        dirPath: string;
-    }): Promise<DiskSpaceInfo>;
-    getGpuInfo(): Promise<MetricsGpuInfo | null>;
-    getCpuTemperature(): Promise<number | null>;
-    getProcessStats(input: {
-        pids: number[];
-    }): Promise<PidResourceStats[]>;
-    private sampleCpu;
-    /** Cached macOS memory (set by sampleMacMemory timer). */
-    _cachedMacMem: MemoryInfo | null;
-    private getMemoryInfo;
-}
-
-declare class SystemConfigAddon extends BaseAddon {
-    readonly id = "system-config";
-    constructor();
-    protected onInitialize(): Promise<void>;
-    private buildGlobalSchema;
-    getGlobalSettings(): Promise<ConfigUISchemaWithValues>;
-    updateGlobalSettings(patch: Record<string, unknown>): Promise<void>;
-}
-
-/**
- * Local Auth Addon — owns user accounts, API keys, scoped tokens,
- * and local password authentication.
- *
- * Capabilities registered:
- *   - `auth-provider` (collection) — local password authentication
- *   - `user-management` (singleton) — user CRUD, API keys, scoped tokens
- *
- * Extension: an OIDC addon can register another `auth-provider` entry.
- * The server's login flow iterates the `auth-provider` collection.
- */
-
-interface LocalAuthConfig {
-    jwtSecret?: string;
-    adminUsername?: string;
-    adminPassword?: string;
-}
-declare class LocalAuthAddon extends BaseAddon<LocalAuthConfig> {
-    private authManager;
-    private userManager;
-    private apiKeyManager;
-    private scopedTokenManager;
-    constructor();
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    protected onShutdown(): Promise<void>;
-}
-
-/**
- * Wire shape matching `z.infer<typeof SettingsSchemaWithValuesSchema>` —
- * duplicated as a plain interface because importing the Zod schema across
- * package boundaries confuses `tsc` when the types package pins a
- * different `zod` minor than the core package. Keeping the shape local
- * keeps the addon decoupled from the schema's internal type encoding.
- */
-interface ContributionShape {
-    tabs?: Array<{
-        id: string;
-        label: string;
-        icon: string;
-        order?: number;
-    }>;
-    sections: Array<{
-        id: string;
-        title: string;
-        description?: string;
-        style?: 'card' | 'accordion';
-        defaultCollapsed?: boolean;
-        columns?: 1 | 2 | 3 | 4;
-        tab?: string;
-        /** Where the section renders. Default 'settings' (Config tab); 'top-tab' hoists into the device-detail tab bar via DeviceDetail discovery. */
-        location?: 'settings' | 'top-tab';
-        order?: number;
-        fields: unknown[];
-    }>;
-}
-
-declare class DeviceManagerAddon extends BaseAddon {
-    constructor();
-    /** Shorthand for the kernel-injected capability registry. */
-    private get capabilityRegistry();
-    /**
-     * Parent-chain event propagator. Started in `onInitialize` once the
-     * hub's `deviceRegistry` is available; listens to every device-sourced
-     * event and re-emits a copy on each ancestor scope with `via[]`
-     * populated. Stopped in `onShutdown`.
-     */
-    private propagator;
-    /**
-     * Hub-side mirror of every device's cap-keyed runtime state.
-     * Populated whenever any caller writes via `deviceState.setCapSlice`
-     * (the canonical cross-layer write entrypoint) and on first load
-     * via `loadRuntimeState`. Cross-process consumers reach the mirror
-     * through the `deviceState` cap router; per-cap event subscribers
-     * (e.g. `battery.onStatusChanged`) get the same data via
-     * cap-specific events still emitted by the owning device.
-     *
-     * Key: deviceId. Value: per-cap slice map. Empty by default —
-     * slices show up as `setCapSlice` calls trickle in.
-     */
-    private readonly stateMirror;
-    /**
-     * Per-device disk-write debouncer for runtime-state. `setCapSlice`
-     * updates the in-memory mirror synchronously and emits the change
-     * event immediately, but the disk write is coalesced — frequent
-     * back-to-back writes (motion phase transitions, battery pushes,
-     * etc.) collapse to one `writeDeviceRuntimeState` per
-     * `RUNTIME_STATE_DEBOUNCE_MS` window. `flushRuntimeStateWrites`
-     * awaits any in-flight write + scheduled flush so shutdown is
-     * lossless.
-     */
-    private readonly runtimeStateDebounce;
-    private static readonly RUNTIME_STATE_DEBOUNCE_MS;
-    /**
-     * Cross-process native-provider cache: deviceId (numeric) → capName → { addonId, nodeId }.
-     * Kept in sync with `device.bindings-changed` events emitted by forked
-     * workers. Union'd into `getBindings` so hub-side consumers see every
-     * native cap regardless of which process owns the IDevice. No persistence
-     * — entries re-register when the worker restarts. Purged on
-     * `$node.disconnected` to avoid stale routing after a worker crash.
-     */
-    private remoteNativeCaps;
-    /** Wait for a device-provider by addonId, returning null on timeout. */
-    private waitDeviceProvider;
-    /** Require a device-provider by addonId — throws if not found. */
-    private requireDeviceProvider;
-    private readBindingsStore;
-    private writeBindingsStore;
-    private resolveWrapperNodeId;
-    /**
-     * Active discovery of native caps registered on a worker node.
-     * Called from the `$node.connected` handler to recover from lost
-     * `DeviceBindingsChanged` broadcasts after worker restart.
-     *
-     * Iterates the broker's service registry, picks
-     * `<addonId>.native-provider.<capName>` services owned by the
-     * connected node, calls each service's `$listDeviceIds` action to
-     * fetch the deviceIds the worker has registered that cap on, then
-     * writes entries into `remoteNativeCaps`.
-     *
-     * Best-effort: per-service failures are logged and swallowed so a
-     * single bad service doesn't abort the whole rebuild.
-     */
-    private discoverWorkerNativeCaps;
-    getBindings(input: {
-        deviceId: number;
-    }): Promise<{
-        deviceId: number;
-        entries: DeviceBindingEntry[];
-    }>;
-    /**
-     * Whole-fleet binding dump. Iterates every device known to the
-     * deviceRegistry and reuses the per-device `getBindings` resolver
-     * for each — same routing rules, single round-trip. Used by
-     * `SystemManager.init()` for warm-boot.
-     *
-     * Bindings change rarely (wrapper toggle, device add/remove) so
-     * clients invalidate via the existing
-     * `capability.binding-changed` event rather than re-fetching this
-     * payload periodically.
-     */
-    getAllBindings(): Promise<Array<{
-        deviceId: number;
-        entries: DeviceBindingEntry[];
-    }>>;
-    /**
-     * Resolve a numeric deviceId to a stableId via persisted meta.
-     * Used only by the device-identity section of the device-details
-     * aggregator (see `buildBaseDeviceSection`) to surface the stableId as
-     * a readonly display field. All runtime/registry lookups are keyed by
-     * numeric deviceId; this helper is display-only.
-     */
-    private lookupPersistedStableId;
-    getDeviceAggregate(deviceId: number, kind: 'settings' | 'live'): Promise<ContributionShape | null>;
-    /**
-     * Build the device-manager's own contribution to the aggregator — the
-     * device identity (id, stableId, addonId, type, online) + the
-     * driver-specific config exposed by the device class via
-     * `zodEntriesToConfigUI`.
-     *
-     * Two paths, deliberately symmetric with `getSettingsSchema`:
-     *
-     *  - Hub-local: device's IDevice instance lives in this process'
-     *    DeviceRegistry, we read config + schema directly by reference.
-     *  - Cross-process: device lives in a forked worker (RtspCamera on
-     *    provider-rtsp, ONVIF on provider-onvif, …). We ask the worker's
-     *    `device-ops.getSettingsSchema` native provider for a wire-
-     *    serializable ConfigUISchema and merge it in under the same
-     *    "Driver Config" section, so the UI sees the same shape regardless
-     *    of where the IDevice physically runs.
-     *
-     *  Returns `null` only when the device genuinely doesn't exist anywhere
-     *  (no hub-local, no persisted ownership, no device-ops native). The
-     *  aggregator falls back to contributor sections only in that case.
-     */
-    private buildBaseDeviceSection;
-    /**
-     * Lookup the native owner for `device-ops` on `deviceId` — the native-cap
-     * registry (hub-local and remote) is keyed by numeric id.
-     */
-    private resolveNativeDeviceOwner;
-    /**
-     * Aggregate `status` across every registered cap for a device.
-     *
-     * Walks the supplied cap list (or `CAP_NAMES_WITH_STATUS` when
-     * omitted), looks up a native provider per cap via the capability
-     * registry, calls `provider.getStatus({ deviceId })`, and validates
-     * the return against the cap's own `status.schema`. Validation
-     * failures log a warning and yield `null` for that cap so the
-     * overall aggregate stays usable — a single misbehaving provider
-     * must not blank out a device's entire status view.
-     *
-     * Returned shape is `Record<capName, unknown | null>`; the client-
-     * side hook tightens this to `CapStatusTypeMap` via the generated
-     * `cap-status-types.ts`.
-     */
-    private getDeviceStatusAggregate;
-    /**
-     * Return the driver-specific device-settings contribution. Hub-local
-     * devices call `getSettingsUISchema()` directly; forked-worker devices
-     * go through the `device-ops.getSettingsSchema` cap method on the
-     * numeric-id-keyed native registry.
-     */
-    private resolveDriverConfigSchema;
-    updateDeviceField(input: {
-        deviceId: number;
-        writerCapName: string;
-        writerAddonId: string;
-        key: string;
-        value: unknown;
-    }): Promise<{
-        success: true;
-    }>;
-    /**
-     * Batched counterpart of `updateDeviceField`. Groups changes by
-     * `(writerCapName, writerAddonId)` so each contributor receives a
-     * single `applyDeviceSettingsPatch` with all of its updates merged —
-     * avoids N round-trips for simultaneous edits in the same save.
-     *
-     * Per-provider failures are captured in the `failures[]` output so the
-     * admin UI can highlight which sections didn't persist; a failure on
-     * one provider does NOT abort the others.
-     */
-    updateDeviceFieldsBatch(input: {
-        deviceId: number;
-        changes: ReadonlyArray<{
-            writerCapName: string;
-            writerAddonId: string;
-            key: string;
-            value: unknown;
-        }>;
-    }): Promise<{
-        success: true;
-        failures: {
-            writerCapName: string;
-            writerAddonId: string;
-            error: string;
-        }[];
-    }>;
-    /** Apply a single grouped patch to the appropriate provider. Mirrors
-     * `updateDeviceField` routing (special-case device-manager, else
-     * registry lookup). Used by `updateDeviceFieldsBatch`. */
-    private applyGroupPatch;
-    listWrappersForCap(input: {
-        capName: string;
-    }): Promise<string[]>;
-    listBindableCapsForDeviceType(input: {
-        deviceType: string;
-    }): Promise<Array<{
-        capName: string;
-        wrappers: string[];
-    }>>;
-    setWrapperActive(input: {
-        deviceId: number;
-        capName: string;
-        wrapperAddonId: string;
-        active: boolean;
-    }): Promise<void>;
-    protected onInitialize(): Promise<ProviderRegistration[] | void>;
-    /**
-     * Single-cap mirror update — diff against the current mirror,
-     * persist the new slice in-memory, emit `DeviceStateChanged` for
-     * this cap. No-op on identical writes (both same shape and same
-     * values). Called by `setCapSlice` provider.
-     */
-    private applySingleCapUpdate;
-    /**
-     * Debounced disk writer. Coalesces frequent writes (motion phase
-     * transitions, battery pushes) into one `writeDeviceRuntimeState`
-     * per `RUNTIME_STATE_DEBOUNCE_MS` window. Reads the per-device
-     * blob from the live mirror at flush time so the disk picture is
-     * always the latest state — no risk of writing a stale snapshot.
-     */
-    private scheduleRuntimeStateDiskWrite;
-    /**
-     * One-shot mirror seed used by `loadRuntimeState` at boot so the
-     * hub knows about every persisted slice without waiting for the
-     * first `setCapSlice` call. No events emitted — this is
-     * initial-state population, not a transition.
-     */
-    private seedMirror;
-    private snapshotForDevice;
-    private emitStateChanged;
-    protected onShutdown(): Promise<void>;
-}
-
-type ElementState = 'stopped' | 'starting' | 'running' | 'stopping' | 'error' | 'disabled';
-interface ElementStatus {
-    state: ElementState;
-    error?: string;
-    startedAt?: number;
-    stoppedAt?: number;
-    restartCount: number;
-    uptime: number;
-}
-declare class LifecycleStateMachine {
-    private readonly elementId;
-    private readonly elementType;
-    private readonly eventBus;
-    private readonly logger;
-    private _state;
-    private _error?;
-    private _startedAt?;
-    private _stoppedAt?;
-    private _restartCount;
-    private _hasStartedOnce;
-    constructor(elementId: string, elementType: 'provider' | 'device' | 'addon' | 'process', eventBus: IEventBus, logger: IScopedLogger);
-    get state(): ElementState;
-    getStatus(): ElementStatus;
-    transition(to: ElementState, error?: string): boolean;
-    incrementRestartCount(): void;
-    private isValidTransition;
-}
-
-type FeatureConfigReader = {
-    readonly features: FeatureManifest;
-};
-declare class FeatureManager {
-    private readonly configReader;
-    constructor(configReader: FeatureConfigReader);
-    isEnabled(flag: FeatureFlag): boolean;
-    getManifest(): FeatureManifest;
-}
-
-declare class SystemEventBus implements IEventBus {
-    private readonly ringBuffer;
-    private readonly subscribers;
-    constructor(bufferSize?: number);
-    emit(event: SystemEvent): void;
-    /**
-     * Subscribe to events matching a filter.
-     * When called with a typed category filter, the handler receives typed event data.
-     */
-    subscribe(filter: EventFilter, handler: (event: SystemEvent) => void): () => void;
-    getRecent(filter?: EventFilter, limit?: number): readonly SystemEvent[];
-}
-
-declare class LogRingBuffer {
-    private readonly capacity;
-    private readonly buffer;
-    private head;
-    private count;
-    constructor(capacity?: number);
-    push(entry: LogEntry): void;
-    getAll(): LogEntry[];
-    query(filter: LogFilter): LogEntry[];
-    /**
-     * 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?: LogFilter): number;
-}
-
-declare class ScopedLogger implements IScopedLogger {
-    private readonly scope;
-    private readonly writeFn;
-    private readonly tags?;
-    constructor(scope: string | undefined, writeFn: (entry: LogEntry) => void, tags?: LogTags | undefined);
-    debug(message: string, extras?: LogExtras): void;
-    info(message: string, extras?: LogExtras): void;
-    warn(message: string, extras?: LogExtras): void;
-    error(message: string, extras?: LogExtras): void;
-    child(childScope: string): IScopedLogger;
-    withTags(tags: LogTags): IScopedLogger;
-    private write;
-    private mergeTags;
-}
-
-interface ILogDestination {
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    write(entry: LogEntry): void;
-    query?(filter: LogFilter): Promise<readonly LogEntry[]>;
-}
-declare class LogManager {
-    private readonly ringBuffer;
-    private readonly destinations;
-    private readonly subscribers;
-    private deviceNameLookup;
-    constructor(bufferSize?: number);
-    /**
-     * 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: ((deviceId: number) => string | null) | null): void;
-    createLogger(scope?: string): IScopedLogger;
-    private enrichDeviceName;
-    /** Subscribe to live logs matching a filter. Returns an unsubscribe function. */
-    subscribe(filter: Partial<LogFilter>, callback: (entry: LogEntry) => void): () => void;
-    private matchesFilter;
-    /**
-     * 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: ILogDestination, opts?: {
-        replay?: boolean;
-    }): void;
-    removeDestination(dest: ILogDestination): void;
-    query(filter: LogFilter): LogEntry[];
-    /**
-     * 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?: LogFilter): number;
-}
-
-/**
- * Canonical single-line formatter for every `LogEntry` that reaches a
- * console transport — hub-side `WinstonDestination` +
- * `ConsoleDestination`, agent-side `HubForwarderDestination`. One
- * definition so the three paths can't drift.
- *
- * Layout mirrors NestJS `ConsoleLogger` output:
- *
- *   [Nest] 54994  - 04/20/2026, 12:45:53 AM     LOG [InstanceLoader] TrpcModule dependencies initialized +0ms
- *
- * Mapping for camstack — cluster-aware:
- *   - `[Nest]` (brand bracket)   → `[<agent>/<addonId>]` so operators see
- *                                   at a glance which node emitted the line
- *                                   (matches the cluster topology)
- *   - `54994` (pid)              → `process.pid`
- *   - `<timestamp>`              → `M/D/YYYY, H:MM:SS AM`
- *   - `LOG` / `WARN` / `ERROR`   → `entry.level` upper-cased, colour per level
- *   - `[InstanceLoader]` (ctx)   → `[<device>]` — shown only when a device
- *                                   tag is present; omitted otherwise
- *   - `<message>`                → `entry.message`
- *   - trailing `+Nms`            → we don't compute timing yet; omitted
- *
- * Rendered examples:
- *   [hub/winston-logging]        71184  - 04/20/2026, 12:45:53 AM     INFO  Winston logging initialized
- *   [hub/provider-rtsp]          71184  - 04/20/2026, 12:46:01 AM     WARN  [salone] probe failed {err="timeout"}
- *   [dev-agent-0/detection]      12345  - 04/20/2026, 12:47:15 AM     ERROR [cortile] no detector {codec=av1}
- */
-
-/** Options for `formatLogLine`. */
-interface FormatLogLineOptions {
-    /**
-     * Emit ANSI colour codes. When omitted, falls back to the shell-env
-     * heuristic (`NO_COLOR`/`FORCE_COLOR`/`isTTY`). Destinations that
-     * always target a console (ConsoleDestination, HubForwarderDestination)
-     * pass `true`; file sinks (Winston JSON) pass `false` so logs on disk
-     * stay plain text regardless of the shell env.
-     *
-     * `NO_COLOR=1` in the environment still wins — consumer opt-in beats
-     * producer opt-in, matching the https://no-color.org/ convention.
-     */
-    readonly colorize?: boolean;
-}
-/**
- * Render a `LogEntry` as one complete console line — no trailing newline.
- * Caller appends `\n` (file sinks) or relies on `console.log` (stdout sink).
- *
- * PID column prefers `entry.tags.pid` when set (so forked-worker entries
- * carry the worker's OS pid even when the hub renders them), falling back
- * to the renderer's own `process.pid`.
- *
- * Colours (when enabled) follow the NestJS convention: the level token
- * AND the message body share the level colour (green/yellow/red/gray for
- * info/warn/error/debug). Brand, device context, scope and meta keep
- * their fixed hues so the structural fields stay visually distinct from
- * the message content.
- */
-declare function formatLogLine(entry: LogEntry, options?: FormatLogLineOptions): string;
-
-interface IStorageBackend {
-    /** Backend type identifier */
-    readonly type: string;
-    /** Base path of this backend */
-    readonly basePath: string;
-    /** Resolve a subpath to an absolute path */
-    resolve(subpath: string): string;
-    /**
-     * Check whether the backend is usable: either the base directory
-     * already exists and is writable, OR we can create it on first
-     * write (i.e. the nearest existing ancestor is writable).
-     */
-    isAvailable(): boolean;
-    /** No-op for lazy backends. Kept for API compatibility. */
-    initialize(): Promise<void>;
-}
-/**
- * Filesystem storage backend — lazy by design.
- *
- * `initialize()` does NOT create the base directory eagerly. Instead,
- * consumers that write via `FilesystemStorageProvider` (and other write
- * helpers in storage-manager.ts) run `fs.mkdir(dirname(filePath), { recursive: true })`
- * right before every `writeFile`, so the directory tree appears on demand.
- *
- * The previous behaviour eagerly mkdir'd every location declared in
- * `StorageLocationManager.initializeDefaults()` — six directories (`db`,
- * `media`, `recordings`, `models`, `cache`, `logs`) got created at boot
- * even if the installation had no cameras, no recording addon, no
- * analytics addon, etc. That meant every fresh install looked like it
- * was producing data when it had nothing to write. Laziness fixes that:
- * a directory only exists once an addon decides to put a file there.
- */
-declare class FsStorageBackend implements IStorageBackend {
-    readonly type = "local";
-    readonly basePath: string;
-    constructor(basePath: string);
-    resolve(subpath: string): string;
-    isAvailable(): boolean;
-    initialize(): Promise<void>;
-}
-
-type StorageLocationName = 'data' | 'media' | 'recordings' | 'models' | 'cache' | 'logs';
-declare class StorageLocationManager {
-    private readonly backends;
-    private readonly dataPath;
-    constructor(dataPath: string);
-    /** Initialize all locations with default paths */
-    initializeDefaults(): Promise<void>;
-    /** Override a specific location's backend path */
-    setLocationPath(name: StorageLocationName, basePath: string): Promise<void>;
-    /** Get the backend for a location */
-    getBackend(name: StorageLocationName): IStorageBackend;
-    /** Resolve a path within a location */
-    resolve(location: StorageLocationName, subpath: string): string;
-    /** Check if all locations are available */
-    getStatus(): Array<{
-        name: StorageLocationName;
-        available: boolean;
-        path: string;
-    }>;
-    /** All location names */
-    getLocationNames(): StorageLocationName[];
-}
-
-interface IStorageProvider {
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    getLocation(name: StorageLocationName): IStorageLocation;
-    export?(locationName: StorageLocationName): Promise<Buffer>;
-    import?(locationName: StorageLocationName, data: Buffer): Promise<void>;
-}
-interface QueryFilter {
-    where?: Record<string, unknown>;
-    whereIn?: Record<string, unknown[]>;
-    whereBetween?: Record<string, [unknown, unknown]>;
-    orderBy?: {
-        field: string;
-        direction: 'asc' | 'desc';
-    };
-    limit?: number;
-    offset?: number;
-}
-interface StorageRecord {
-    collection: string;
-    id: string;
-    data: Record<string, unknown>;
-}
-interface IStructuredStorage {
-    query(collection: string, filter?: QueryFilter): Promise<readonly StorageRecord[]>;
-    insert(record: StorageRecord): Promise<StorageRecord>;
-    update(collection: string, id: string, data: Record<string, unknown>): Promise<StorageRecord>;
-    delete(collection: string, id: string): Promise<void>;
-    count(collection: string, filter?: QueryFilter): Promise<number>;
-}
-interface IFileStorage {
-    readFile(path: string): Promise<Buffer>;
-    writeFile(path: string, data: Buffer): Promise<void>;
-    deleteFile(path: string): Promise<void>;
-    listFiles(prefix?: string): Promise<readonly string[]>;
-    getFileUrl(path: string): Promise<string>;
-    exists(path: string): Promise<boolean>;
-}
-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 legacyProvider;
-    private locationManager;
-    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;
-    getSettingsBackend(): ISettingsBackend;
-    getProvider(): IStorageProvider;
-    setLocationManager(manager: StorageLocationManager): void;
-    getLocationManager(): StorageLocationManager;
-    initializeLocations(dataPath: string): Promise<void>;
-    getLocationPath(name: StorageLocationName): string;
-    /**
-     * 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;
-}
-
-/**
- * Manages scoped API tokens with restricted addon/route/capability access.
- */
-declare class ScopedTokenManager {
-    private readonly store;
-    constructor(store: SettingsStoreClient);
-    create(userId: string, name: string, scopes: TokenScope[], expiresAt?: number): Promise<{
-        token: string;
-        record: ScopedToken;
-    }>;
-    validate(rawToken: string): Promise<ScopedToken | null>;
-    matchesScope(token: ScopedToken, addonId?: string, routePath?: string, capability?: string): boolean;
-    revoke(tokenId: string): Promise<void>;
-    listForUser(userId: string): Promise<ScopedToken[]>;
-    updateLastUsed(tokenId: string): Promise<void>;
-}
-
-type AuthConfigReader = {
-    get<T>(path: string): T;
-    update(section: string, data: Record<string, unknown>): void;
-};
-declare class AuthManager {
-    private readonly config;
-    private readonly jwtSecret;
-    private scopedTokenManager;
-    private readonly logger;
-    constructor(config: AuthConfigReader, logger?: IScopedLogger);
-    signToken(payload: Omit<TokenPayload, 'iat' | 'exp'>): string;
-    verifyToken(token: string): TokenPayload;
-    hashPassword(password: string): Promise<string>;
-    comparePassword(password: string, hash: string): Promise<boolean>;
-    generateApiKey(): {
-        token: string;
-        hash: string;
-        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.
-     */
-    setScopedTokenManager(manager: ScopedTokenManager): void;
-    /**
-     * Validate a scoped token string.
-     * Returns the token record if valid, null otherwise.
-     */
-    validateScopedToken(rawToken: string): Promise<ScopedToken | null>;
-    /**
-     * Check whether a scoped token grants access to a given addon/route/capability.
-     */
-    matchesScopedTokenScope(token: ScopedToken, addonId?: string, routePath?: string, capability?: string): boolean;
-}
-
-interface CreateApiKeyInput {
-    label: string;
-    role: UserRole;
-    allowedProviders?: string[] | '*';
-    allowedDevices?: Record<string, string[] | '*'>;
-}
-interface ApiKeyStorageAccess {
-    getStore(): SettingsStoreClient;
-}
-declare class ApiKeyManager {
-    private readonly storageAccess;
-    private readonly auth;
-    constructor(storageAccess: ApiKeyStorageAccess, auth: AuthManager);
-    private get store();
-    create(input: CreateApiKeyInput): Promise<{
-        record: ApiKeyRecord;
-        token: string;
-    }>;
-    validateToken(token: string): Promise<ApiKeyRecord | null>;
-    listAll(): Promise<Omit<ApiKeyRecord, 'tokenHash'>[]>;
-    revoke(id: string): Promise<void>;
-    findById(id: string): Promise<ApiKeyRecord | null>;
-}
-
-interface CreateUserInput {
-    username: string;
-    password: string;
-    role: UserRole;
-    allowedProviders?: string[] | '*';
-    allowedDevices?: Record<string, string[] | '*'>;
-}
-type UpdatableUserFields = Partial<Pick<UserRecord, 'role' | 'allowedProviders' | 'allowedDevices'>>;
-interface UserStorageAccess {
-    getStore(): SettingsStoreClient;
-}
-interface UserConfigReader {
-    get<T>(path: string): T;
-}
-declare class UserManager {
-    private readonly storageAccess;
-    private readonly auth;
-    private readonly config;
-    constructor(storageAccess: UserStorageAccess, auth: AuthManager, config: UserConfigReader);
-    private get store();
-    create(input: CreateUserInput): Promise<UserRecord>;
-    findByUsername(username: string): Promise<UserRecord | null>;
-    findById(id: string): Promise<UserRecord | null>;
-    validateCredentials(username: string, password: string): Promise<UserRecord | null>;
-    listAll(): Promise<Omit<UserRecord, 'passwordHash'>[]>;
-    update(id: string, data: UpdatableUserFields): Promise<void>;
-    delete(id: string): Promise<void>;
-    resetPassword(id: string, newPassword: string): Promise<void>;
-    ensureAdminExists(): Promise<void>;
-}
-
-/**
- * Central notification service that routes notifications to configured outputs.
- * Framework-agnostic — dependencies injected via constructor.
- *
- * Outputs are resolved from the ICapabilityRegistry's 'notification-output'
- * collection on each call (proxy pattern). Falls back to a local map
- * when no registry is provided (backward compat).
- */
-declare class NotificationService {
-    private readonly logger;
-    private readonly localOutputs;
-    private readonly routing;
-    private readonly rateLimits;
-    private readonly lastSent;
-    private registry;
-    constructor(logger: IScopedLogger);
-    /** Set the registry for live output lookup. Called once during boot. */
-    setRegistry(registry: ICapabilityRegistry): void;
-    /** Resolve all outputs — prefers registry, falls back to local map */
-    private get outputs();
-    /** Register an output in the local fallback map (used when no registry is set). */
-    registerLocalOutput(output: INotificationOutput): void;
-    /** Remove an output from the local fallback map. */
-    unregisterLocalOutput(id: string): void;
-    setRouting(category: string, outputIds: string[]): void;
-    setRateLimit(category: string, minIntervalMs: number): void;
-    notify(notification: Notification): Promise<void>;
-    getOutputs(): ReadonlyArray<{
-        id: string;
-        name: string;
-        icon: string;
-    }>;
-    getRouting(): ReadonlyMap<string, string[]>;
-    getOutput(id: string): INotificationOutput | undefined;
-}
-
-type Unsubscribe = () => void;
-/**
- * Service for broadcasting toast notifications to connected UI clients.
- * Framework-agnostic — integrates with tRPC subscriptions via subscribe().
- */
-declare class ToastService {
-    private readonly listeners;
-    /**
-     * Subscribe to toast events for a specific user.
-     * Returns an unsubscribe function.
-     */
-    subscribe(connectionId: string, userId: string, callback: (toast: Toast) => void): Unsubscribe;
-    /**
-     * Broadcast a toast to all connected clients.
-     */
-    broadcast(toast: Toast): void;
-    /**
-     * Send a toast to a specific user's connections only.
-     */
-    sendToUser(userId: string, toast: Toast): void;
-}
-
-interface RouteMatch {
-    readonly route: IAddonHttpRoute;
-    readonly addonId: string;
-    readonly params: Record<string, string>;
-}
-/**
- * Registry for dynamic HTTP routes registered by addons.
- * Framework-agnostic — the server HTTP layer queries this registry to dispatch requests.
- */
-declare class AddonRouteRegistry {
-    private readonly routes;
-    /**
-     * Register all routes from an addon's route provider.
-     */
-    registerRoutes(addonId: string, provider: IAddonRouteProvider): void;
-    /**
-     * Unregister all routes for an addon.
-     */
-    unregisterRoutes(addonId: string): void;
-    /**
-     * Match an incoming request method + path to a registered route.
-     * Supports simple path parameters (e.g., /items/:id).
-     */
-    matchRoute(method: string, path: string): RouteMatch | null;
-    /**
-     * List all registered routes across all addons.
-     */
-    listRoutes(): ReadonlyArray<{
-        addonId: string;
-        method: string;
-        path: string;
-        access: string;
-        description?: 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.
- *
- * In-process only: `createDirectCaller()` uses tRPC's `createCallerFactory`
- * to call procedures directly (zero network overhead) and wraps the raw
- * caller in a proxy so it matches `CreateTRPCClient<AppRouter>` shape —
- * addons use `context.api.namespace.method.query(input)` identically to
- * the cross-process path.
- *
- * Cross-process calls (forked workers, remote agents) ride the Moleculer
- * broker via `brokerTransportLink` in the kernel — not this factory.
- */
-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;
-        };
-    };
-}
-declare class AddonApiFactory {
-    /**
-     * Create a direct caller -- calls tRPC procedures directly in-process.
-     * Zero network overhead. Used for in-process addons and dev mode.
-     *
-     * Returns `AddonApi` — the same tRPC client surface that broker-routed
-     * callers get. Callers treat it uniformly as `context.api` regardless
-     * of the underlying transport.
-     */
-    createDirectCaller(options: DirectCallerOptions): Promise<_camstack_types.AddonApi>;
-}
-
-declare class IntegrationRegistry implements IIntegrationRegistry {
-    private readonly backend;
-    constructor(backend: ISettingsBackend);
-    initialize(): Promise<void>;
-    createIntegration(input: CreateIntegrationInput): Promise<Integration>;
-    getIntegration(id: string): Promise<Integration | null>;
-    getIntegrationByAddonId(addonId: string): Promise<Integration | null>;
-    listIntegrations(): Promise<readonly Integration[]>;
-    updateIntegration(id: string, updates: Partial<Pick<Integration, 'name' | 'enabled' | 'info'>>): Promise<Integration | null>;
-    deleteIntegration(id: string): Promise<boolean>;
-    getIntegrationSettings(integrationId: string): Promise<Record<string, unknown>>;
-    setIntegrationSetting(integrationId: string, key: string, value: unknown): Promise<void>;
-    setIntegrationSettings(integrationId: string, settings: Record<string, unknown>): Promise<void>;
-    createDevice(input: CreateDeviceInput): Promise<PersistedDevice>;
-    getDevice(id: string): Promise<PersistedDevice | null>;
-    getDeviceByStableId(stableId: string): Promise<PersistedDevice | null>;
-    listDevices(integrationId?: string): Promise<readonly PersistedDevice[]>;
-    listCameras(): Promise<readonly PersistedDevice[]>;
-    updateDevice(id: string, updates: Partial<Pick<PersistedDevice, 'name' | 'enabled' | 'info'>>): Promise<PersistedDevice | null>;
-    deleteDevice(id: string): Promise<boolean>;
-    getDeviceSettings(deviceId: string): Promise<Record<string, unknown>>;
-    setDeviceSetting(deviceId: string, key: string, value: unknown): Promise<void>;
-    setDeviceSettings(deviceId: string, settings: Record<string, unknown>): Promise<void>;
-    private mapIntegration;
-    private mapDevice;
-}
-
-export { AddonApiFactory, AddonRouteRegistry, type AddonTableSchema, AlertCenterAddon, ApiKeyManager, type ApiKeyStorageAccess, type AuthConfigReader, AuthManager, type BackupConfig, CORE_TABLE_DDL, type CertOptions, ConfigStore, ConsoleDestination, ConsoleLoggingAddon, DeviceManagerAddon, type DeviceRow, DeviceStore, type DirectCallerOptions, type DownloadProgressCallback, type ElementState, type ElementStatus, EngineManagerResolver, type EnsureTlsResult, EventBus, type FeatureConfigReader, FeatureManager, FilesystemStorageAddon, FsStorageBackend, HubForwarderAddon, HubForwarderDestination, type IStorageProvider as ICoreStorageProvider, type IFileStorage, type ILogDestination, type IReplContextProvider, type IReplEngine, type IStorageBackend, type IStorageLocation, type IStructuredStorage, IntegrationRegistry, LifecycleStateMachine, LocalAuthAddon, LocalBackupAddon, LocalBackupService, LogManager, LogRingBuffer, ModelDownloadService, NativeMetricsAddon, NativeMetricsProvider, NetworkQualityTracker, NotificationService, type PidStats, PipelineRunner, PipelineValidator, PythonEnvManager, type QueryFilter, ReplEngine, type ReplScope, type ReplSessionContext, ScopedLogger, ScopedTokenManager, SettingsStore, SqliteSettingsAddon, SqliteSettingsBackend, StorageLocationManager, type StorageLocationName, StorageManager, type StorageRecord, SystemConfigAddon, SystemEventBus, type TlsCertPair, ToastService, type Unsubscribe, type UserConfigReader, UserManager, type UserStorageAccess, WinstonDestination, WinstonLoggingAddon, addonTableToDdl, deleteModelFromDisk, downloadFile, downloadModel, ensureModel, ensureTlsCert, fetchJson, formatLogLine, getModelFilePath, getPidStats, getSinglePidStats, isModelDownloaded, loadTlsCert };