@camstack/types 1.0.3 → 1.0.5

package/dist/interfaces/config-port.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Minimal configuration port consumed by the shared `NodeRuntime`.
+ *
+ * The runtime never reaches a concrete config service: hub and agent each
+ * supply their own adapter (the hub over its `ConfigService`, the agent over
+ * env + `/data/agent.json`). Keeping the surface to a namespaced get/set keeps
+ * the runtime host-agnostic — a port leak (the runtime reaching a backend type)
+ * must break the agent build, which is the desired signal.
+ */
+export interface ConfigPort {
+    /** Read a namespaced config value (e.g. "capabilities.singleton.storage"). */
+    get<T = string>(key: string): T | undefined;
+    /** Persist a namespaced config value. May be async (storage-backed). */
+    set(key: string, value: unknown): void | Promise<void>;
+}

package/dist/interfaces/event-bus.d.ts

@@ -278,7 +278,7 @@ export interface SystemReadyStatePayload {
  *   `framework-update`      — single system-package update via `updateFrameworkPackage`
  *   `manual`                — operator-triggered restart (restartServer)
  *   `system`                — internal / supervisor-initiated restart
- *   `framework-bulk-update` — multi-package bulk update orchestrated by BulkUpdateCoordinator
+ *   `framework-bulk-update` — multi-package bulk update run as one lifecycle engine job
  */
 export interface PendingRestartMarkerPayload {
     readonly kind: 'framework-update' | 'manual' | 'system' | 'framework-bulk-update';
@@ -799,6 +799,21 @@ export interface EventCatalog {
         }>;
         readonly timestamp: number;
     };
+    /**
+     * Per-node detection-engine runtime-provisioning transition. Carries
+     * the `EngineProvisioningState` snapshot (runtimeId / device / phase +
+     * optional progress / error / nextRetryAt). `nodeId` rides on
+     * `event.source.nodeId`. Emitted by the detection-pipeline provider on
+     * every state change. Phase 2.
+     */
+    'pipeline.engine-provisioning': {
+        readonly runtimeId: 'onnx' | 'openvino' | 'coreml' | null;
+        readonly device: string | null;
+        readonly state: 'idle' | 'installing' | 'verifying' | 'ready' | 'failed';
+        readonly progress?: number;
+        readonly error?: string;
+        readonly nextRetryAt?: number;
+    };
     /**
      * Cluster topology snapshot — same payload shape that
      * `nodes.topology` returns. Emitted by the hub on any agent /
@@ -952,12 +967,10 @@ export interface EventCatalog {
         readonly freedMB?: number;
     };
     /**
-     * Progress snapshot emitted by `BulkUpdateCoordinator` on every state
-     * transition (item status change, phase change, completion, cancel).
-     * Payload is `BulkUpdateState`. Admin UI subscribes via `useLiveEvent`
-     * to drive the sticky `BulkUpdateBanner` and per-row `AddonRowBadge`.
-     *
-     * Spec: docs/superpowers/specs/2026-05-21-addons-bulk-update-progress-design.md
+     * Legacy bulk-update progress snapshot (payload `BulkUpdateState`). No longer
+     * emitted — F3 removed the coordinator that produced it; "Update all" now runs
+     * as one lifecycle engine job. Retained only to keep the event maps stable;
+     * removed in F4 once live bulk progress moves to the engine events.
      */
     'addons.bulk-update-progress': BulkUpdateState;
     /**

package/dist/interfaces/pipeline-executor-capability.d.ts

@@ -6,6 +6,7 @@ import type { FrameResult, DetectorOutput } from '../types/detection.js';
 import type { ConfigUISchema } from './config-ui.js';
 import type { InferenceCapabilities } from './inference-capabilities.js';
 import type { IAddonResolver } from './pipeline-runner.js';
+import type { EngineProvisioning } from '../capabilities/pipeline-executor.cap.js';
 /**
  * Step configuration for pipeline execution — no runtime/backend (comes
  * from engine). Phase 7 (settings redesign) removed the generic
@@ -72,6 +73,13 @@ export interface IPipelineExecutorProvider {
     getGlobalPipelineConfig(): Promise<PipelineConfig | null>;
     /** Get the currently selected engine (bootstrap default on the node). */
     getSelectedEngine(): Promise<PipelineEngineChoice>;
+    /**
+     * Per-node detection-engine provisioning snapshot (idle / installing /
+     * verifying / ready / failed). Read by the cap and the inference gate.
+     * The cap routes `{ nodeId }` for provider resolution only — each node
+     * returns its own local machine state, so the provider takes no args.
+     */
+    getEngineProvisioning(): EngineProvisioning;
     getOrchestratorConfigSchema(): Promise<ConfigUISchema>;
     /** Get full inference capabilities (addon models, runtimes, etc.) */
     getCapabilities(forceRefresh?: boolean): Promise<InferenceCapabilities>;

package/dist/lifecycle/framework-swap.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export declare const frameworkSwapPackageSchema: z.ZodObject<{
+    name: z.ZodString;
+    stagedPath: z.ZodString;
+    backupPath: z.ZodString;
+    toVersion: z.ZodString;
+    fromVersion: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type FrameworkSwapPackage = z.infer<typeof frameworkSwapPackageSchema>;
+export declare const pendingFrameworkSwapSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    taskId: z.ZodString;
+    packages: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        stagedPath: z.ZodString;
+        backupPath: z.ZodString;
+        toVersion: z.ZodString;
+        fromVersion: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    requestedAtMs: z.ZodNumber;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip>;
+export type PendingFrameworkSwap = z.infer<typeof pendingFrameworkSwapSchema>;
+export declare const frameworkSwapConfirmSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    taskId: z.ZodString;
+    backups: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        backupPath: z.ZodString;
+        livePath: z.ZodString;
+    }, z.core.$strip>>;
+    appliedAtMs: z.ZodNumber;
+    bootAttempts: z.ZodNumber;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip>;
+export type FrameworkSwapConfirm = z.infer<typeof frameworkSwapConfirmSchema>;

package/dist/lifecycle/index.d.ts

@@ -0,0 +1,2 @@
+export * from './job.js';
+export * from './framework-swap.js';

package/dist/lifecycle/job.d.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+export declare const jobKindSchema: z.ZodEnum<{
+    update: "update";
+    install: "install";
+    uninstall: "uninstall";
+    restart: "restart";
+}>;
+export type JobKind = z.infer<typeof jobKindSchema>;
+export declare const taskPhaseSchema: z.ZodEnum<{
+    failed: "failed";
+    queued: "queued";
+    fetching: "fetching";
+    staged: "staged";
+    validating: "validating";
+    applying: "applying";
+    restarting: "restarting";
+    applied: "applied";
+    done: "done";
+    skipped: "skipped";
+}>;
+export type TaskPhase = z.infer<typeof taskPhaseSchema>;
+export declare const taskTargetSchema: z.ZodEnum<{
+    addon: "addon";
+    framework: "framework";
+}>;
+export type TaskTarget = z.infer<typeof taskTargetSchema>;
+export declare const taskLogEntrySchema: z.ZodObject<{
+    tsMs: z.ZodNumber;
+    nodeId: z.ZodString;
+    packageName: z.ZodString;
+    phase: z.ZodEnum<{
+        failed: "failed";
+        queued: "queued";
+        fetching: "fetching";
+        staged: "staged";
+        validating: "validating";
+        applying: "applying";
+        restarting: "restarting";
+        applied: "applied";
+        done: "done";
+        skipped: "skipped";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type TaskLogEntry = z.infer<typeof taskLogEntrySchema>;
+export declare const lifecycleTaskSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    nodeId: z.ZodString;
+    packageName: z.ZodString;
+    fromVersion: z.ZodNullable<z.ZodString>;
+    toVersion: z.ZodString;
+    target: z.ZodEnum<{
+        addon: "addon";
+        framework: "framework";
+    }>;
+    phase: z.ZodEnum<{
+        failed: "failed";
+        queued: "queued";
+        fetching: "fetching";
+        staged: "staged";
+        validating: "validating";
+        applying: "applying";
+        restarting: "restarting";
+        applied: "applied";
+        done: "done";
+        skipped: "skipped";
+    }>;
+    stagedPath: z.ZodNullable<z.ZodString>;
+    attempts: z.ZodNumber;
+    steps: z.ZodArray<z.ZodObject<{
+        tsMs: z.ZodNumber;
+        nodeId: z.ZodString;
+        packageName: z.ZodString;
+        phase: z.ZodEnum<{
+            failed: "failed";
+            queued: "queued";
+            fetching: "fetching";
+            staged: "staged";
+            validating: "validating";
+            applying: "applying";
+            restarting: "restarting";
+            applied: "applied";
+            done: "done";
+            skipped: "skipped";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    error: z.ZodNullable<z.ZodString>;
+    startedAtMs: z.ZodNullable<z.ZodNumber>;
+    finishedAtMs: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type LifecycleTask = z.infer<typeof lifecycleTaskSchema>;
+export declare const lifecycleJobStateSchema: z.ZodEnum<{
+    running: "running";
+    failed: "failed";
+    completed: "completed";
+    "partially-failed": "partially-failed";
+    cancelled: "cancelled";
+}>;
+export type LifecycleJobState = z.infer<typeof lifecycleJobStateSchema>;
+export declare const lifecycleJobScopeSchema: z.ZodEnum<{
+    single: "single";
+    bulk: "bulk";
+    cluster: "cluster";
+}>;
+export type LifecycleJobScope = z.infer<typeof lifecycleJobScopeSchema>;
+export declare const lifecycleJobSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    kind: z.ZodEnum<{
+        update: "update";
+        install: "install";
+        uninstall: "uninstall";
+        restart: "restart";
+    }>;
+    createdAtMs: z.ZodNumber;
+    createdBy: z.ZodString;
+    scope: z.ZodEnum<{
+        single: "single";
+        bulk: "bulk";
+        cluster: "cluster";
+    }>;
+    tasks: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        nodeId: z.ZodString;
+        packageName: z.ZodString;
+        fromVersion: z.ZodNullable<z.ZodString>;
+        toVersion: z.ZodString;
+        target: z.ZodEnum<{
+            addon: "addon";
+            framework: "framework";
+        }>;
+        phase: z.ZodEnum<{
+            failed: "failed";
+            queued: "queued";
+            fetching: "fetching";
+            staged: "staged";
+            validating: "validating";
+            applying: "applying";
+            restarting: "restarting";
+            applied: "applied";
+            done: "done";
+            skipped: "skipped";
+        }>;
+        stagedPath: z.ZodNullable<z.ZodString>;
+        attempts: z.ZodNumber;
+        steps: z.ZodArray<z.ZodObject<{
+            tsMs: z.ZodNumber;
+            nodeId: z.ZodString;
+            packageName: z.ZodString;
+            phase: z.ZodEnum<{
+                failed: "failed";
+                queued: "queued";
+                fetching: "fetching";
+                staged: "staged";
+                validating: "validating";
+                applying: "applying";
+                restarting: "restarting";
+                applied: "applied";
+                done: "done";
+                skipped: "skipped";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        startedAtMs: z.ZodNullable<z.ZodNumber>;
+        finishedAtMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    state: z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        completed: "completed";
+        "partially-failed": "partially-failed";
+        cancelled: "cancelled";
+    }>;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip>;
+export type LifecycleJob = z.infer<typeof lifecycleJobSchema>;

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

@@ -54,6 +54,13 @@ export interface CameraStepOverridePatch {
  */
 export interface AgentPipelineSettings {
     readonly addonDefaults: Readonly<Record<string, AgentAddonConfig>>;
+    /**
+     * Optional per-node camera capacity cap. When set, the load balancer will
+     * not assign more than this many cameras to this agent. `null` = unlimited.
+     * Defaults to `null` on the Zod schema so existing persisted blobs load
+     * without migration.
+     */
+    readonly maxCameras?: number | null;
 }
 /**
  * Per-camera pipeline settings. Sparse by design — a camera that has

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",