@camstack/system 1.2.390 → 1.2.391

package/dist/logging/partitioned-log-buffer.d.ts

@@ -1,169 +1,169 @@
-import { LogEntry, LogFilter, LogLevel } from '@camstack/types';
+import type { LogEntry, LogFilter, LogLevel } from "@camstack/types";
 /**
- * Default ceiling on retained entries across every bucket.
- *
- * This used to be `null` — no aggregate bound at all — and the only thing
- * holding hub-main's log memory was `perAddonCapacity x buckets`, a product
- * that grows with the roster. Measured on the live cluster: 37 forked runners
- * on the hub plus its in-process builtins, and hub-main additionally ingests
- * every line from both agents, so ~60 buckets is the ordinary case and
- * 60 x 5000 = 300k retained entries.
- *
- * A realistic entry (timestamp, level, scope, ~70-char message, three tags, no
- * `meta`) measures **~306 B retained** in V8. So the old unbounded case is
- * ~92MB of a hub process that is being asked to fit inside a cgroup with a
- * neighbour to protect, and 50_000 is **~15MB**.
- *
- * 50_000 across a ~60-bucket roster is ~830 entries per addon on average while
- * still letting a single chatty addon hold its full 5000-entry ring — the
- * partitioning is not weakened, only the total is held.
- */
-export declare const DEFAULT_MAX_TOTAL_LOG_ENTRIES = 50000;
+* Default ceiling on retained entries across every bucket.
+*
+* This used to be `null` — no aggregate bound at all — and the only thing
+* holding hub-main's log memory was `perAddonCapacity x buckets`, a product
+* that grows with the roster. Measured on the live cluster: 37 forked runners
+* on the hub plus its in-process builtins, and hub-main additionally ingests
+* every line from both agents, so ~60 buckets is the ordinary case and
+* 60 x 5000 = 300k retained entries.
+*
+* A realistic entry (timestamp, level, scope, ~70-char message, three tags, no
+* `meta`) measures **~306 B retained** in V8. So the old unbounded case is
+* ~92MB of a hub process that is being asked to fit inside a cgroup with a
+* neighbour to protect, and 50_000 is **~15MB**.
+*
+* 50_000 across a ~60-bucket roster is ~830 entries per addon on average while
+* still letting a single chatty addon hold its full 5000-entry ring — the
+* partitioning is not weakened, only the total is held.
+*/
+export declare const DEFAULT_MAX_TOTAL_LOG_ENTRIES = 5e4;
 /**
- * Default ceiling on the NUMBER of buckets.
- *
- * Buckets were created on first write and never removed, so every addon id
- * that ever logged — a removed addon, a renamed one, a one-off worker id —
- * kept a ring alive for the life of the process. {@link DEFAULT_MAX_TOTAL_LOG_ENTRIES}
- * alone does not fix that: the total sweep may only discard entries at or below
- * `pruneLevel`, so a dead addon's 5000 `info` lines are untouchable by it.
- *
- * 128 is ~2x the ~60-bucket live roster, so no real deployment ever evicts on
- * bucket count alone; it exists to make an unbounded id space impossible.
- */
+* Default ceiling on the NUMBER of buckets.
+*
+* Buckets were created on first write and never removed, so every addon id
+* that ever logged — a removed addon, a renamed one, a one-off worker id —
+* kept a ring alive for the life of the process. {@link DEFAULT_MAX_TOTAL_LOG_ENTRIES}
+* alone does not fix that: the total sweep may only discard entries at or below
+* `pruneLevel`, so a dead addon's 5000 `info` lines are untouchable by it.
+*
+* 128 is ~2x the ~60-bucket live roster, so no real deployment ever evicts on
+* bucket count alone; it exists to make an unbounded id space impossible.
+*/
 export declare const DEFAULT_MAX_LOG_BUCKETS = 128;
 export interface PartitionedLogBufferOptions {
-    /** Hard ring size for EACH addon's bucket. */
-    readonly perAddonCapacity?: number;
-    /**
-     * Soft ceiling on entries across all buckets. `null` means the only bound is
-     * the per-addon rings. Defaults to {@link DEFAULT_MAX_TOTAL_LOG_ENTRIES}.
-     */
-    readonly maxTotalEntries?: number | null;
-    /** Highest severity the total-cap sweep may discard. Default `debug`. */
-    readonly pruneLevel?: LogLevel;
-    /**
-     * Hard ceiling on the number of buckets. `null` means unbounded. Defaults to
-     * {@link DEFAULT_MAX_LOG_BUCKETS}.
-     */
-    readonly maxBuckets?: number | null;
+	/** Hard ring size for EACH addon's bucket. */
+	readonly perAddonCapacity?: number;
+	/**
+	* Soft ceiling on entries across all buckets. `null` means the only bound is
+	* the per-addon rings. Defaults to {@link DEFAULT_MAX_TOTAL_LOG_ENTRIES}.
+	*/
+	readonly maxTotalEntries?: number | null;
+	/** Highest severity the total-cap sweep may discard. Default `debug`. */
+	readonly pruneLevel?: LogLevel;
+	/**
+	* Hard ceiling on the number of buckets. `null` means unbounded. Defaults to
+	* {@link DEFAULT_MAX_LOG_BUCKETS}.
+	*/
+	readonly maxBuckets?: number | null;
 }
 /**
- * A log buffer partitioned into one fixed-capacity {@link LogRingBuffer} per
- * `addonId`. A chatty addon (e.g. detection-pipeline) only ever evicts its OWN
- * bucket, so a quiet addon's sparse lines (e.g. a HomeAssistant `image` entity)
- * survive far longer than they would in a single shared FIFO ring.
- *
- * Drop-in for {@link LogRingBuffer} from {@link LogManager}'s perspective —
- * exposes the same `push` / `getAll` / `query` / `clear` surface.
- *
- * ## Three bounds, doing different jobs
- *
- * **`perAddonCapacity`** is a HARD bound: each bucket is a fixed-size ring, so
- * total memory can never exceed `perAddonCapacity × buckets` whatever else
- * happens. This is the safety net.
- *
- * **`maxTotalEntries`** targets the total across all buckets, and it exists because
- * the hard bound scales with addon count — 60 buckets × 5000 was 300k retained
- * entries on the live hub. When the total is exceeded, the sweep first discards
- * only entries at or below `pruneLevel` (default `debug`), oldest first, from the
- * largest buckets first.
- *
- * It is deliberately soft ON A LIVE BUCKET. Meeting a total cap by discarding
- * `warn` and `error` from an addon that is still logging would trade the entries
- * that explain an incident for entries about frame timings. A cap that can evict
- * a live addon's error is not a feature.
- *
- * Largest-bucket-first because the noisy addon is the one creating the pressure —
- * the same principle that motivated partitioning in the first place.
- *
- * **`maxBuckets`, and bucket eviction, are the hard backstop.** Pruning alone
- * cannot bound this structure: it may only discard at or below `pruneLevel`, so
- * a bucket full of `info` from an addon that no longer exists was immortal, and
- * the roster the product scales with is not fixed. When pruning cannot reach the
- * target — or the bucket count exceeds `maxBuckets` — whole buckets are dropped
- * **least-recently-WRITTEN first**, and never the bucket currently being written
- * to. That is precisely the dead addon's bucket, and it is precisely not the
- * bucket of the addon whose incident is in progress.
- */
+* A log buffer partitioned into one fixed-capacity {@link LogRingBuffer} per
+* `addonId`. A chatty addon (e.g. detection-pipeline) only ever evicts its OWN
+* bucket, so a quiet addon's sparse lines (e.g. a HomeAssistant `image` entity)
+* survive far longer than they would in a single shared FIFO ring.
+*
+* Drop-in for {@link LogRingBuffer} from {@link LogManager}'s perspective —
+* exposes the same `push` / `getAll` / `query` / `clear` surface.
+*
+* ## Three bounds, doing different jobs
+*
+* **`perAddonCapacity`** is a HARD bound: each bucket is a fixed-size ring, so
+* total memory can never exceed `perAddonCapacity × buckets` whatever else
+* happens. This is the safety net.
+*
+* **`maxTotalEntries`** targets the total across all buckets, and it exists because
+* the hard bound scales with addon count — 60 buckets × 5000 was 300k retained
+* entries on the live hub. When the total is exceeded, the sweep first discards
+* only entries at or below `pruneLevel` (default `debug`), oldest first, from the
+* largest buckets first.
+*
+* It is deliberately soft ON A LIVE BUCKET. Meeting a total cap by discarding
+* `warn` and `error` from an addon that is still logging would trade the entries
+* that explain an incident for entries about frame timings. A cap that can evict
+* a live addon's error is not a feature.
+*
+* Largest-bucket-first because the noisy addon is the one creating the pressure —
+* the same principle that motivated partitioning in the first place.
+*
+* **`maxBuckets`, and bucket eviction, are the hard backstop.** Pruning alone
+* cannot bound this structure: it may only discard at or below `pruneLevel`, so
+* a bucket full of `info` from an addon that no longer exists was immortal, and
+* the roster the product scales with is not fixed. When pruning cannot reach the
+* target — or the bucket count exceeds `maxBuckets` — whole buckets are dropped
+* **least-recently-WRITTEN first**, and never the bucket currently being written
+* to. That is precisely the dead addon's bucket, and it is precisely not the
+* bucket of the addon whose incident is in progress.
+*/
 export declare class PartitionedLogBuffer {
-    private readonly buffers;
-    /**
-     * Bucket key → the write ordinal of its last `push`. A monotonic counter, not
-     * a clock: eviction order must follow the order writes actually happened, and
-     * a wall clock that steps backwards would pick the wrong victim.
-     */
-    private readonly lastWriteSeq;
-    private writeSeq;
-    private perAddonCapacity;
-    private maxTotalEntries;
-    private pruneLevel;
-    private maxBuckets;
-    /** Running total, so `push` does not walk every bucket to decide. */
-    private totalEntries;
-    constructor(perAddonCapacity?: number, options?: PartitionedLogBufferOptions);
-    /**
-     * Apply new limits at runtime. Shrinking takes effect as entries are pushed
-     * (each partition trims to the new capacity on its next write) — existing
-     * entries are NOT dropped eagerly: losing history the operator is currently
-     * reading, the instant they lower a number, is a worse surprise than a
-     * momentarily oversized buffer.
-     */
-    reconfigure(options: {
-        readonly perAddonCapacity?: number;
-        readonly maxTotalEntries?: number | null;
-        readonly pruneLevel?: LogLevel;
-        readonly maxBuckets?: number | null;
-    }): void;
-    private bufferFor;
-    push(entry: LogEntry): void;
-    /**
-     * Bring the total down to `PRUNE_TARGET_RATIO × cap`.
-     *
-     * Two passes, in this order and no other: first discard prunable entries,
-     * largest bucket first, which is free of information cost. Only if that
-     * cannot reach the target does the second pass drop WHOLE buckets,
-     * least-recently-written first — the bound has to hold even when every
-     * retained entry is above `pruneLevel`, and a bucket nobody has written to is
-     * the cheapest thing in the structure to lose.
-     */
-    private enforceTotalCap;
-    /**
-     * Drop whole buckets, least-recently-WRITTEN first, until the total is at or
-     * below `target`. Never touches `protectedKey` (the bucket being written to
-     * right now) and always leaves at least one bucket standing.
-     */
-    private evictBucketsUntil;
-    /** Drop exactly `count` buckets, least-recently-written first. */
-    private evictBuckets;
-    /** Bucket keys ordered least-recently-written first, excluding `protectedKey`.
-     *  A bucket with no recorded write sorts first — it can only be a leftover. */
-    private evictionOrder;
-    /** Remove a bucket and everything that indexes it. An empty ring left behind
-     *  is the leak this class shipped with — the map only ever grew. */
-    private dropBucket;
-    /** Entries retained across every bucket. */
-    size(): number;
-    /** Buckets currently retained. Observability for the aggregate bound — an
-     *  addon roster that only ever grows is what this class had to stop doing. */
-    bucketCount(): number;
-    /** Every retained entry across all buckets, newest-first (mirrors
-     *  {@link LogRingBuffer.getAll}). Used to replay history to a destination. */
-    getAll(): LogEntry[];
-    /**
-     * Query across buckets. When the filter pins an `addonId`, only that addon's
-     * bucket is scanned (the common case — the device/addon Logs tab). Otherwise
-     * every bucket is scanned, merged newest-first, then limited — so a
-     * `deviceId`-only filter (a device's own Logs tab) still finds its lines
-     * regardless of which addon emitted them.
-     */
-    query(filter: LogFilter): LogEntry[];
-    clear(filter?: LogFilter): number;
-    /** An emptied bucket is removed rather than left as an empty ring: the map
-     *  used to grow with every addon id that ever logged and never shrink. */
-    private dropIfEmpty;
-    /** The bucket key a filter pins to via `tags.addonId`, or null when the
-     *  filter doesn't constrain the addon (→ scan all buckets). */
-    private pinnedAddonKey;
-    private mergeNewestFirst;
+	private readonly buffers;
+	/**
+	* Bucket key → the write ordinal of its last `push`. A monotonic counter, not
+	* a clock: eviction order must follow the order writes actually happened, and
+	* a wall clock that steps backwards would pick the wrong victim.
+	*/
+	private readonly lastWriteSeq;
+	private writeSeq;
+	private perAddonCapacity;
+	private maxTotalEntries;
+	private pruneLevel;
+	private maxBuckets;
+	/** Running total, so `push` does not walk every bucket to decide. */
+	private totalEntries;
+	constructor(perAddonCapacity?: number, options?: PartitionedLogBufferOptions);
+	/**
+	* Apply new limits at runtime. Shrinking takes effect as entries are pushed
+	* (each partition trims to the new capacity on its next write) — existing
+	* entries are NOT dropped eagerly: losing history the operator is currently
+	* reading, the instant they lower a number, is a worse surprise than a
+	* momentarily oversized buffer.
+	*/
+	reconfigure(options: {
+		readonly perAddonCapacity?: number;
+		readonly maxTotalEntries?: number | null;
+		readonly pruneLevel?: LogLevel;
+		readonly maxBuckets?: number | null;
+	}): void;
+	private bufferFor;
+	push(entry: LogEntry): void;
+	/**
+	* Bring the total down to `PRUNE_TARGET_RATIO × cap`.
+	*
+	* Two passes, in this order and no other: first discard prunable entries,
+	* largest bucket first, which is free of information cost. Only if that
+	* cannot reach the target does the second pass drop WHOLE buckets,
+	* least-recently-written first — the bound has to hold even when every
+	* retained entry is above `pruneLevel`, and a bucket nobody has written to is
+	* the cheapest thing in the structure to lose.
+	*/
+	private enforceTotalCap;
+	/**
+	* Drop whole buckets, least-recently-WRITTEN first, until the total is at or
+	* below `target`. Never touches `protectedKey` (the bucket being written to
+	* right now) and always leaves at least one bucket standing.
+	*/
+	private evictBucketsUntil;
+	/** Drop exactly `count` buckets, least-recently-written first. */
+	private evictBuckets;
+	/** Bucket keys ordered least-recently-written first, excluding `protectedKey`.
+	*  A bucket with no recorded write sorts first — it can only be a leftover. */
+	private evictionOrder;
+	/** Remove a bucket and everything that indexes it. An empty ring left behind
+	*  is the leak this class shipped with — the map only ever grew. */
+	private dropBucket;
+	/** Entries retained across every bucket. */
+	size(): number;
+	/** Buckets currently retained. Observability for the aggregate bound — an
+	*  addon roster that only ever grows is what this class had to stop doing. */
+	bucketCount(): number;
+	/** Every retained entry across all buckets, newest-first (mirrors
+	*  {@link LogRingBuffer.getAll}). Used to replay history to a destination. */
+	getAll(): LogEntry[];
+	/**
+	* Query across buckets. When the filter pins an `addonId`, only that addon's
+	* bucket is scanned (the common case — the device/addon Logs tab). Otherwise
+	* every bucket is scanned, merged newest-first, then limited — so a
+	* `deviceId`-only filter (a device's own Logs tab) still finds its lines
+	* regardless of which addon emitted them.
+	*/
+	query(filter: LogFilter): LogEntry[];
+	clear(filter?: LogFilter): number;
+	/** An emptied bucket is removed rather than left as an empty ring: the map
+	*  used to grow with every addon id that ever logged and never shrink. */
+	private dropIfEmpty;
+	/** The bucket key a filter pins to via `tags.addonId`, or null when the
+	*  filter doesn't constrain the addon (→ scan all buckets). */
+	private pinnedAddonKey;
+	private mergeNewestFirst;
 }

package/dist/logging/scoped-logger.d.ts

@@ -1,17 +1,17 @@
-import { IScopedLogger, LogExtras, LogTags } from '@camstack/types';
-import { LogEntry } from './log-ring-buffer.js';
+import type { IScopedLogger, LogExtras, LogTags } from "@camstack/types";
+import type { LogEntry } from "./log-ring-buffer.js";
 export type { IScopedLogger };
 export 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;
+	private readonly scope;
+	private readonly writeFn;
+	private readonly tags?;
+	constructor(scope: string | undefined, writeFn: (entry: LogEntry) => void, tags?: LogTags);
+	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;
 }

package/dist/network/network-quality.d.ts

@@ -1,11 +1,11 @@
-import { StreamNetworkStats, ClientNetworkStats, DeviceNetworkStats, INetworkQualityTracker } from '@camstack/types';
+import type { StreamNetworkStats, ClientNetworkStats, DeviceNetworkStats, INetworkQualityTracker } from "@camstack/types";
 export type { StreamNetworkStats, ClientNetworkStats, DeviceNetworkStats, INetworkQualityTracker };
 export 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;
+	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;
 }

package/dist/notification/notification-service.d.ts

@@ -1,43 +1,43 @@
-import { INotificationOutputProvider, RoutedNotification, ICapabilityRegistry } from '@camstack/types';
-import { IScopedLogger } from '../logging/scoped-logger.js';
+import type { INotificationOutputProvider, RoutedNotification, ICapabilityRegistry } from "@camstack/types";
+import type { IScopedLogger } from "../logging/scoped-logger.js";
 /**
- * A routing destination: one target (`targetId`) owned by one provider
- * (`addonId`). The notifiers addon and the HA addon each register a
- * `notification-output` collection provider; the service resolves the
- * provider by `addonId` and dispatches to the specific target.
- */
+* A routing destination: one target (`targetId`) owned by one provider
+* (`addonId`). The notifiers addon and the HA addon each register a
+* `notification-output` collection provider; the service resolves the
+* provider by `addonId` and dispatches to the specific target.
+*/
 export interface NotificationTargetRef {
-    readonly addonId: string;
-    readonly targetId: string;
+	readonly addonId: string;
+	readonly targetId: string;
 }
 /**
- * Central notification service that routes canonical notifications to
- * configured `(addonId, targetId)` targets. Framework-agnostic —
- * dependencies injected via constructor.
- *
- * Providers are resolved from the ICapabilityRegistry by `addonId` on each
- * call (proxy pattern). Falls back to a local map when no registry is
- * provided (tests / backward compat).
- */
+* Central notification service that routes canonical notifications to
+* configured `(addonId, targetId)` targets. Framework-agnostic —
+* dependencies injected via constructor.
+*
+* Providers are resolved from the ICapabilityRegistry by `addonId` on each
+* call (proxy pattern). Falls back to a local map when no registry is
+* provided (tests / backward compat).
+*/
 export declare class NotificationService {
-    private readonly logger;
-    private readonly localProviders;
-    private readonly routing;
-    private readonly rateLimits;
-    private readonly lastSent;
-    private registry;
-    constructor(logger: IScopedLogger);
-    /** Set the registry for live provider lookup. Called once during boot. */
-    setRegistry(registry: ICapabilityRegistry): void;
-    /** Resolve the collection provider for an addon — registry first, then local map. */
-    private resolveProvider;
-    /** Register a provider in the local fallback map (used when no registry is set). */
-    registerLocalProvider(addonId: string, provider: INotificationOutputProvider): void;
-    /** Remove a provider from the local fallback map. */
-    unregisterLocalProvider(addonId: string): void;
-    /** Route a category to a set of `(addonId, targetId)` targets. */
-    setRouting(category: string, targets: readonly NotificationTargetRef[]): void;
-    setRateLimit(category: string, minIntervalMs: number): void;
-    notify(notification: RoutedNotification): Promise<void>;
-    getRouting(): ReadonlyMap<string, NotificationTargetRef[]>;
+	private readonly logger;
+	private readonly localProviders;
+	private readonly routing;
+	private readonly rateLimits;
+	private readonly lastSent;
+	private registry;
+	constructor(logger: IScopedLogger);
+	/** Set the registry for live provider lookup. Called once during boot. */
+	setRegistry(registry: ICapabilityRegistry): void;
+	/** Resolve the collection provider for an addon — registry first, then local map. */
+	private resolveProvider;
+	/** Register a provider in the local fallback map (used when no registry is set). */
+	registerLocalProvider(addonId: string, provider: INotificationOutputProvider): void;
+	/** Remove a provider from the local fallback map. */
+	unregisterLocalProvider(addonId: string): void;
+	/** Route a category to a set of `(addonId, targetId)` targets. */
+	setRouting(category: string, targets: readonly NotificationTargetRef[]): void;
+	setRateLimit(category: string, minIntervalMs: number): void;
+	notify(notification: RoutedNotification): Promise<void>;
+	getRouting(): ReadonlyMap<string, NotificationTargetRef[]>;
 }

package/dist/notification/toast-service.d.ts

@@ -1,22 +1,22 @@
-import { Toast } from '@camstack/types';
+import type { Toast } from "@camstack/types";
 export type Unsubscribe = () => void;
 /**
- * Service for broadcasting toast notifications to connected UI clients.
- * Framework-agnostic — integrates with tRPC subscriptions via subscribe().
- */
+* Service for broadcasting toast notifications to connected UI clients.
+* Framework-agnostic — integrates with tRPC subscriptions via subscribe().
+*/
 export 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;
+	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;
 }

package/dist/pipeline/engine-manager-resolver.d.ts

@@ -1,15 +1,15 @@
-import { IAddonResolver, IAddonCaller, IEngineManager } from '@camstack/types';
+import type { IAddonResolver, IAddonCaller, IEngineManager } from "@camstack/types";
 /**
- * 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.
- */
+* 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.
+*/
 export 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>;
+	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>;
 }

package/dist/pipeline/pipeline-runner.d.ts

@@ -1,8 +1,8 @@
-import { FrameInput, PipelineConfig, PipelineResult, IAddonResolver } from '@camstack/types';
+import type { FrameInput, PipelineConfig, PipelineResult, IAddonResolver } from "@camstack/types";
 export declare class PipelineRunner {
-    private readonly addonResolver;
-    constructor(addonResolver: IAddonResolver);
-    run(frame: FrameInput, config: PipelineConfig): Promise<PipelineResult>;
-    private executeNode;
-    private executeChildren;
+	private readonly addonResolver;
+	constructor(addonResolver: IAddonResolver);
+	run(frame: FrameInput, config: PipelineConfig): Promise<PipelineResult>;
+	private executeNode;
+	private executeChildren;
 }

package/dist/pipeline/pipeline-validator.d.ts

@@ -1,13 +1,13 @@
-import { PipelineConfig, ValidationIssue, ValidationResult } from '@camstack/types';
+import type { PipelineConfig, ValidationIssue, ValidationResult } from "@camstack/types";
 export type { ValidationIssue, ValidationResult };
 /**
- * Check if a pipeline step is available in the system.
- * Implementations should check the capability registry for `pipeline-step:{stepId}`.
- */
+* Check if a pipeline step is available in the system.
+* Implementations should check the capability registry for `pipeline-step:{stepId}`.
+*/
 export type StepExistsFn = (stepId: string) => boolean;
 export declare class PipelineValidator {
-    private readonly stepExists;
-    constructor(stepExists: StepExistsFn);
-    validate(config: PipelineConfig): ValidationResult;
-    private validateNode;
+	private readonly stepExists;
+	constructor(stepExists: StepExistsFn);
+	validate(config: PipelineConfig): ValidationResult;
+	private validateNode;
 }