@camstack/types 0.1.14 → 0.1.16

package/dist/readiness/readiness-registry.d.ts

@@ -0,0 +1,183 @@
+/**
+ * ReadinessRegistry — kernel-side tracker for capability readiness
+ * transitions. Spec: `docs/superpowers/specs/2026-04-19-system-readiness-design.md`.
+ *
+ * Each process owns one registry. The registry:
+ *  - Listens to `system.ready-state` events on the event bus.
+ *  - Maintains a `Map<key, ReadinessRecord>` snapshot of the most
+ *    recently observed state + generation + derived epoch.
+ *  - Exposes `emitReady` / `emitStarting` / `emitDown` helpers for
+ *    local producers (which stamp the process-wide `generation`).
+ *  - Exposes `awaitReady(capName, scope, {timeoutMs, signal})` and
+ *    `onReadyState(capName, scope, handler)` for consumers.
+ *
+ * Epoch derivation:
+ *  - First `ready` observed for a `(capName, scope)` → epoch = 1.
+ *  - `ready` received with a generation different from the last
+ *    `currentGeneration` → epoch++.
+ *  - Same-generation repeated `ready` events → epoch unchanged
+ *    (idempotent keepalive; e.g. re-emit on `$node.connected`).
+ *
+ * Not persisted. Rebuilt from the event stream + optional boot-time
+ * snapshot rehydration by the caller.
+ */
+import type { IEventBus, ReadinessScope, ReadinessState } from '../interfaces/event-bus.js';
+import type { IScopedLogger } from '../interfaces/logging.js';
+import type { IReadinessRegistry, IReadinessHandler, IAwaitReadyOptions, IReadinessTransition } from '../interfaces/readiness.js';
+/**
+ * Concrete types live here; `interfaces/readiness.ts` declares the
+ * matching narrow interfaces (`IReadinessTransition`,
+ * `IReadinessHandler`, `IAwaitReadyOptions`) used by `AddonContext`
+ * and other consumer-facing types.
+ */
+export type ReadinessTransition = IReadinessTransition;
+export type ReadinessHandler = IReadinessHandler;
+export type AwaitReadyOptions = IAwaitReadyOptions;
+export declare class ReadinessTimeoutError extends Error {
+    readonly capName: string;
+    readonly scope: ReadinessScope;
+    readonly waitedMs: number;
+    constructor(capName: string, scope: ReadinessScope, waitedMs: number);
+}
+interface ReadinessRecord {
+    capName: string;
+    scope: ReadinessScope;
+    state: ReadinessState;
+    generation: string;
+    epoch: number;
+    lastChange: number;
+    /**
+     * Node that emitted the latest transition for this record. Needed for
+     * `agent.offline` demux of `device`-scoped caps (scope itself carries
+     * no node info). For `node`-scoped caps this matches `scope.nodeId`.
+     */
+    sourceNodeId: string;
+}
+/**
+ * Build a canonical string key for a `(capName, scope)` pair. Used as
+ * the snapshot map key and for log/debug output.
+ */
+export declare function readinessKey(capName: string, scope: ReadinessScope): string;
+declare function scopeKey(scope: ReadinessScope): string;
+export interface ReadinessRegistryOptions {
+    readonly eventBus: IEventBus;
+    readonly sourceNodeId: string;
+    /**
+     * Per-process generation id — stamped on every emit made via this
+     * registry's `emitReady`/`emitStarting`/`emitDown` helpers. Caller
+     * owns the value so it can survive across subsystem re-bindings
+     * within the same process. Default: a random 12-char id.
+     */
+    readonly generation?: string;
+    readonly logger?: IScopedLogger;
+    /**
+     * Clock source. Injectable for tests.
+     */
+    readonly now?: () => number;
+}
+export declare class ReadinessRegistry implements IReadinessRegistry {
+    private readonly bus;
+    private readonly sourceNodeId;
+    private readonly logger;
+    private readonly now;
+    private readonly generation;
+    private readonly snapshot;
+    private readonly subscriptions;
+    private readonly unsubscribeBus;
+    private readonly unsubscribeAgentOffline;
+    constructor(options: ReadinessRegistryOptions);
+    /** Release the event-bus subscription. Idempotent. */
+    close(): void;
+    /** Current snapshot for a `(capName, scope)` pair, or `null` if never seen. */
+    get(capName: string, scope: ReadinessScope): ReadinessRecord | null;
+    /**
+     * Serializable snapshot for cross-process transport. Returns an array
+     * of `ReadinessRecord` plain objects — safe for MsgPack / JSON
+     * transport. Used by the hub's `$readiness.getSnapshot` Moleculer
+     * action; consumers hydrate their local registry from the result.
+     */
+    getSnapshotForTransport(): readonly ReadinessRecord[];
+    /**
+     * Hydrate the snapshot from an authoritative source. Entries already
+     * present locally are skipped — live deltas (received via the event
+     * bus subscription) always take precedence over the snapshot. For
+     * each newly hydrated entry, a one-shot transition is dispatched to
+     * matching subscriptions so pending `awaitReady` callers unblock
+     * without having to wait for a fresh event.
+     *
+     * Local `epoch` is reset to 1 per entry — consumer-side epoch is
+     * derived from observed generation transitions, so this mirrors the
+     * value that would have been assigned had the consumer observed the
+     * first `ready` event directly.
+     */
+    hydrate(records: readonly ReadinessRecord[]): void;
+    /** Shallow copy of the full snapshot — mainly for diagnostics/tests. */
+    getAll(): ReadonlyMap<string, ReadinessRecord>;
+    /**
+     * Emit a `ready` transition for a locally-owned capability. The
+     * payload carries this registry's `generation` so remote registries
+     * can derive their own `epoch`.
+     */
+    emitReady(capName: string, scope: ReadinessScope): void;
+    emitStarting(capName: string, scope: ReadinessScope): void;
+    emitDown(capName: string, scope: ReadinessScope): void;
+    /**
+     * One-shot: resolve once the cap is `ready`. Reads the snapshot
+     * first — if already ready, resolves synchronously on the next tick.
+     *
+     * Default behaviour is **wait indefinitely** (timeoutMs = `Infinity`):
+     * the orchestrator and other callers never want to attach a camera
+     * with empty steps just because a cap took longer than 30s to come
+     * up. Pass an explicit finite `timeoutMs` to bound the wait, or an
+     * `AbortSignal` to cancel externally. `Infinity` is honoured natively
+     * — no `setTimeout` is registered (Node's setTimeout silently clamps
+     * values above ~24.8d, so we must skip the timer entirely).
+     */
+    awaitReady(capName: string, scope: ReadinessScope, opts?: AwaitReadyOptions): Promise<void>;
+    /**
+     * Observable: every transition (starting/ready/down) dispatches to
+     * `handler`. On subscription, if the snapshot has a current state,
+     * the handler fires ONCE asynchronously with that state as the
+     * initial transition (duration = 0) so late subscribers can pick up
+     * current state without racing the next transition.
+     *
+     * Returns an unsubscribe function.
+     */
+    onReadyState(capName: string, scope: ReadinessScope, handler: ReadinessHandler): () => void;
+    private emitTransition;
+    /**
+     * Update snapshot + dispatch to subscribers. Idempotent: same
+     * `generation + state` replay is a no-op for both snapshot and
+     * subscribers.
+     *
+     * Defensive against malformed payloads (legal reason: a mock bus's
+     * `getRecent` may ignore the category filter and replay unrelated
+     * events when we hydrate at construction time).
+     */
+    private ingest;
+    /**
+     * `agent.offline` demux. When an agent disconnects ungracefully,
+     * its BaseAddon's shutdown hook doesn't fire — consumers would
+     * otherwise keep waiting on a stale `ready`. Walk the snapshot and
+     * synthesize a `down` transition for every node-scoped record bound
+     * to the disconnected `nodeId`, skipping records already `down`.
+     *
+     * Synthesis is LOCAL: we don't re-emit on the bus. Every registry
+     * (one per process) receives the same `agent.offline` and reacts
+     * independently, which means no duplicated downs and no central
+     * supervisor required.
+     */
+    private synthesizeDownForNode;
+}
+/**
+ * Given a list of `(capName, scope)` pairs that a just-disconnected
+ * node owned, emit a `down` transition for each. Callers (kernel
+ * supervisor, hub `$node.disconnected` handler) wire this up once they
+ * know which caps the node held.
+ */
+export declare function emitDownForOwnedCaps(registry: ReadinessRegistry, owned: ReadonlyArray<{
+    readonly capName: string;
+    readonly scope: ReadinessScope;
+}>): void;
+export { scopeKey };
+//# sourceMappingURL=readiness-registry.d.ts.map

package/dist/readiness/readiness-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness-registry.d.ts","sourceRoot":"","sources":["../../src/readiness/readiness-registry.ts"],"names":[],"mappings":"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"}

package/dist/schemas/auth-records.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Zod schemas for persisted record types.
+ *
+ * These schemas serve as the single source of truth for types that are
+ * stored in the settings-store backend and retrieved via tRPC. They
+ * replace the manual TypeScript interfaces with schema-derived types,
+ * enabling runtime validation when reading from the backend.
+ *
+ * Convention: each schema is named `<Type>Schema`, the inferred TS type
+ * keeps the original name for backward compatibility.
+ */
+import { z } from 'zod';
+export declare const UserRoleSchema: z.ZodEnum<{
+    admin: "admin";
+    viewer: "viewer";
+    super_admin: "super_admin";
+    agent: "agent";
+}>;
+export type UserRole = z.infer<typeof UserRoleSchema>;
+export declare const UserRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    username: z.ZodString;
+    passwordHash: z.ZodString;
+    role: z.ZodEnum<{
+        admin: "admin";
+        viewer: "viewer";
+        super_admin: "super_admin";
+        agent: "agent";
+    }>;
+    allowedProviders: z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>;
+    allowedDevices: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type UserRecord = z.infer<typeof UserRecordSchema>;
+export declare const ApiKeyRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    role: z.ZodEnum<{
+        admin: "admin";
+        viewer: "viewer";
+        super_admin: "super_admin";
+        agent: "agent";
+    }>;
+    allowedProviders: z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>;
+    allowedDevices: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>;
+    tokenHash: z.ZodString;
+    tokenPrefix: z.ZodString;
+    createdAt: z.ZodNumber;
+    lastUsedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ApiKeyRecord = z.infer<typeof ApiKeyRecordSchema>;
+export declare const TokenScopeSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        addon: "addon";
+        capability: "capability";
+        "route-prefix": "route-prefix";
+    }>;
+    target: z.ZodString;
+}, z.core.$strip>;
+export type TokenScope = z.infer<typeof TokenScopeSchema>;
+export declare const ScopedTokenSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    name: z.ZodString;
+    tokenHash: z.ZodString;
+    tokenPrefix: z.ZodString;
+    scopes: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            addon: "addon";
+            capability: "capability";
+            "route-prefix": "route-prefix";
+        }>;
+        target: z.ZodString;
+    }, z.core.$strip>>;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+    lastUsedAt: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodNumber;
+}, z.core.$strip>;
+export type ScopedToken = z.infer<typeof ScopedTokenSchema>;
+//# sourceMappingURL=auth-records.d.ts.map

package/dist/schemas/auth-records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-records.d.ts","sourceRoot":"","sources":["../../src/schemas/auth-records.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,cAAc;;;;;EAAsD,CAAA;AACjF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAKrD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;iBAS3B,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;iBAU7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAI7D,eAAO,MAAM,gBAAgB;;;;;;;iBAG3B,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;iBAU5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/storage/filesystem-storage-provider.d.ts

@@ -0,0 +1,37 @@
+import type { IStorageProvider, StorageLocationType, StorageResolveInput, StorageWriteInput, StorageReadInput, StorageExistsInput, StorageListInput, StorageDeleteInput, StorageAvailableSpaceInput } from '../index.js';
+/**
+ * Filesystem storage provider — serves all location types from a local directory tree.
+ *
+ * Default layout:
+ *   {rootPath}/recordings-high/
+ *   {rootPath}/recordings-low/
+ *   {rootPath}/recordings-clips/
+ *   {rootPath}/event-images/
+ *   {rootPath}/models/
+ *   {rootPath}/addons-data/
+ *   {rootPath}/logs/
+ *   /tmp/camstack-cache/   (cache is always local)
+ *
+ * Individual location paths can be overridden.
+ */
+export declare class FilesystemStorageProvider implements IStorageProvider {
+    readonly id = "local";
+    readonly name = "Local Filesystem";
+    readonly supportedLocations: readonly StorageLocationType[];
+    private readonly rootPath;
+    private readonly locationPaths;
+    constructor(rootPath: string, overrides?: Partial<Record<StorageLocationType, string>>);
+    resolve({ location, relativePath }: StorageResolveInput): string;
+    write({ location, relativePath, data }: StorageWriteInput): Promise<void>;
+    read({ location, relativePath }: StorageReadInput): Promise<Buffer>;
+    exists({ location, relativePath }: StorageExistsInput): Promise<boolean>;
+    list({ location, prefix }: StorageListInput): Promise<readonly string[]>;
+    delete({ location, relativePath }: StorageDeleteInput): Promise<void>;
+    getAvailableSpace({ location }: StorageAvailableSpaceInput): Promise<number | null>;
+    /** Get the resolved path for a location type */
+    getLocationPath(location: StorageLocationType): string;
+    /** Get the root path */
+    getRootPath(): string;
+}
+export default FilesystemStorageProvider;
+//# sourceMappingURL=filesystem-storage-provider.d.ts.map

package/dist/storage/filesystem-storage-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem-storage-provider.d.ts","sourceRoot":"","sources":["../../src/storage/filesystem-storage-provider.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC3B,MAAM,aAAa,CAAA;AAyBpB;;;;;;;;;;;;;;GAcG;AACH,qBAAa,yBAA0B,YAAW,gBAAgB;IAChE,QAAQ,CAAC,EAAE,WAAU;IACrB,QAAQ,CAAC,IAAI,sBAAqB;IAClC,QAAQ,CAAC,kBAAkB,EAAE,SAAS,mBAAmB,EAAE,CAA8B;IAEzF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAkC;gBAEpD,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC;IAmBtF,OAAO,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,EAAE,mBAAmB,GAAG,MAAM;IAM1D,KAAK,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBzE,IAAI,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;IAInE,MAAM,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;IASxE,IAAI,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC;IAYxE,MAAM,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAKrE,iBAAiB,CAAC,EAAE,QAAQ,EAAE,EAAE,0BAA0B,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAsBzF,gDAAgD;IAChD,eAAe,CAAC,QAAQ,EAAE,mBAAmB,GAAG,MAAM;IAMtD,wBAAwB;IACxB,WAAW,IAAI,MAAM;CAGtB;AAED,eAAe,yBAAyB,CAAA"}

package/dist/types/agent-pipeline-settings.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Agent + camera pipeline settings — the persisted shapes that back the
+ * 3-level resolution model:
+ *
+ *   1. Agent declares which addons it runs by default (every addonId in
+ *      the catalog gets an entry with enabled/modelId/settings). Seeded
+ *      automatically from the catalog on first boot, editable after.
+ *
+ *   2. Camera opts in or out of specific addonIds via a boolean overlay
+ *      (`stepToggles`). Absent = inherit agent. Present = force.
+ *
+ *   3. Escape hatch: camera can pin a full pipeline wholesale for a
+ *      specific agent via `pipelineByAgent[agentNodeId]`. When set, it
+ *      bypasses addonDefaults + stepToggles entirely.
+ *
+ * The resolver walks this chain and emits the existing
+ * `CameraPipelineConfig` shape that the runner consumes — no changes
+ * required downstream of the orchestrator.
+ */
+import type { CameraPipelineConfig } from './camera-pipeline.js';
+/**
+ * Per-addon configuration stored under `agent.addonDefaults[addonId]`.
+ * Every addon in the catalog gets one entry — whether enabled or not.
+ * Operators edit these to pick models, tune settings, flip default
+ * enabled state for their hardware.
+ */
+export interface AgentAddonConfig {
+    readonly enabled: boolean;
+    readonly modelId: string;
+    readonly settings: Readonly<Record<string, unknown>>;
+}
+/**
+ * Partial override of a single addon's config for one (device, agent) pair.
+ * Every field is optional — the resolver shallow-merges this patch on top
+ * of the agent.addonDefaults base, so operators can override one field
+ * (e.g. just the model) without redeclaring the whole config. The merge is
+ * per-field on the top-level interface keys only: when `settings` is present
+ * on the patch, it fully replaces the base `settings` map (no key-level
+ * deep merge inside `settings`).
+ */
+export interface CameraStepOverridePatch {
+    readonly enabled?: boolean;
+    readonly modelId?: string;
+    readonly settings?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Per-agent pipeline settings. Phase 2f: engine + hwaccel + audio
+ * ownership moved to per-addon global settings (detection-pipeline,
+ * decoder-nodeav/ffmpeg, audio-analyzer). What's left on the
+ * orchestrator is the per-step defaults map (modelId / step settings)
+ * consumed by the resolver. The authoritative engine triple is read
+ * from the `detection-pipeline` addon's global settings via
+ * `readDetectionPipelineEngine()`.
+ */
+export interface AgentPipelineSettings {
+    readonly addonDefaults: Readonly<Record<string, AgentAddonConfig>>;
+}
+/**
+ * Per-camera pipeline settings. Sparse by design — a camera that has
+ * accepted every agent default has an empty record here. `stepToggles`
+ * are keyed on `addonId` (flat), not on tree-path, so operators can
+ * enable/disable an addon irrespective of where it sits in the
+ * resolved tree.
+ */
+export interface CameraPipelineSettings {
+    readonly pinnedAgentNodeId?: string;
+    readonly stepToggles?: Readonly<Record<string, boolean>>;
+    /**
+     * L2.5 per-agent per-step override. Shallow-merged on top of the L1
+     * agent defaults AFTER the L2 flat stepToggles overlay but BEFORE the
+     * L3 wholesale bypass. `pipelineByAgent[agent]` still takes full
+     * precedence when present — the L2.5 map for that agent is ignored.
+     * When an L2.5 patch has `enabled` set, it supersedes the corresponding
+     * L2 `stepToggles` entry for that (agent, addonId) pair; L2 still
+     * applies when the L2.5 patch leaves `enabled` undefined.
+     */
+    readonly stepOverridesByAgent?: Readonly<Record<string, Readonly<Record<string, CameraStepOverridePatch>>>>;
+    /**
+     * Per-agent wholesale pipeline override. Engine is NOT stored here —
+     * the override runs under the engine selected on that agent via the
+     * detection-pipeline addon's global settings. Operator picks steps
+     * + audio model/enabled only. This keeps the override portable
+     * across agent-moves and prevents a camera from being pinned to an
+     * engine the agent doesn't host.
+     */
+    readonly pipelineByAgent?: Readonly<Record<string, {
+        readonly steps: CameraPipelineConfig['steps'];
+        readonly audio: {
+            readonly modelId: string;
+            readonly enabled: boolean;
+        } | null;
+    }>>;
+}
+//# sourceMappingURL=agent-pipeline-settings.d.ts.map

package/dist/types/agent-pipeline-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-pipeline-settings.d.ts","sourceRoot":"","sources":["../../src/types/agent-pipeline-settings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAOhE;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACrD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACtD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAgB,gBAAgB,CAAC,CAAC,CAAA;CACjF;AAED;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;IACnC,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAgB,OAAO,CAAC,CAAC,CAAA;IACtE;;;;;;;;OAQG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,QAAQ,CACtC,MAAM,CAAC,MAAM,EAAoB,QAAQ,CACvC,MAAM,CAAC,MAAM,EAAgB,uBAAuB,CAAC,CACtD,CAAC,CACH,CAAA;IACD;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,QAAQ,CACjC,MAAM,CAAC,MAAM,EAAoB;QAC/B,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAA;QAC7C,QAAQ,CAAC,KAAK,EAAE;YAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;SAAE,GAAG,IAAI,CAAA;KAC/E,CAAC,CACH,CAAA;CACF"}

package/dist/types/camera-pipeline.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Per-camera pipeline configuration — the canonical shape carried by the
+ * orchestrator's `pipelines/<deviceId>` store and pushed to the runner
+ * inside every `attachCamera` payload.
+ *
+ * Model: a camera declares WHAT to execute (ordered tree of steps) and
+ * WHERE to execute it (engine runtime+backend+format). The runner holds
+ * this in RAM for the lifetime of the attach, swaps it atomically when
+ * the orchestrator re-sends (hot reload on edit or rebalance).
+ *
+ * `PipelineStepInput` already exists in `pipeline-executor.cap.ts` and is
+ * the stateless step shape accepted by `runPipeline`. Reusing it here
+ * keeps the edit → persist → execute round-trip shape-identical with
+ * zero conversion.
+ */
+import type { PipelineStepInputOutput } from '../capabilities/pipeline-executor.cap.js';
+import type { PipelineEngineChoice } from './pipeline.js';
+/**
+ * A camera's end-to-end pipeline: which engine to run on, which video
+ * steps (ordered tree), and optional audio classification. Null `audio`
+ * or `audio.enabled === false` means audio classification is disabled
+ * for this camera — metering (dB/RMS) stays orthogonal, it's part of
+ * `audio-analyzer` not tied to this config.
+ */
+export interface CameraPipelineConfig {
+    readonly engine: PipelineEngineChoice;
+    readonly steps: readonly PipelineStepInputOutput[];
+    readonly audio?: {
+        readonly engine: PipelineEngineChoice;
+        readonly modelId: string;
+        readonly enabled: boolean;
+        /**
+         * Audio-classifier step settings (`enabledAudioClasses`,
+         * `minConfidence`) sourced from the agent's
+         * `addonDefaults['audio-classifier'].settings` and overlaid by any
+         * per-device patch. The audio-analyzer reads these at runtime to
+         * filter macro classes and gate by score.
+         */
+        readonly settings?: Readonly<Record<string, unknown>>;
+    } | null;
+}
+/**
+ * Named preset applied to one or more cameras. The camera stores a
+ * copy of the template's config at apply time — no live reference.
+ * Templates let operators curate reusable pipelines without re-authoring
+ * step trees per-camera.
+ */
+export interface PipelineTemplate {
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly config: CameraPipelineConfig;
+    /** ISO 8601 — creation timestamp. */
+    readonly createdAt: string;
+    /** ISO 8601 — last modification timestamp. */
+    readonly updatedAt: string;
+}
+//# sourceMappingURL=camera-pipeline.d.ts.map

package/dist/types/camera-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-pipeline.d.ts","sourceRoot":"","sources":["../../src/types/camera-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAA;AACvF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AAEzD;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAA;IACrC,QAAQ,CAAC,KAAK,EAAE,SAAS,uBAAuB,EAAE,CAAA;IAClD,QAAQ,CAAC,KAAK,CAAC,EAAE;QACf,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAA;QACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;QACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;QACzB;;;;;;WAMG;QACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;KACtD,GAAG,IAAI,CAAA;CACT;AAED;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAA;IACrC,qCAAqC;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B"}