@camstack/types 1.0.2 → 1.0.4

package/dist/capabilities/addons.cap.d.ts

@@ -63,9 +63,9 @@ declare const AddonListItemSchema: z.ZodObject<{
     hasBackup: z.ZodOptional<z.ZodBoolean>;
     health: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         phase: z.ZodEnum<{
+            failed: "failed";
             pending: "pending";
             healthy: "healthy";
-            failed: "failed";
         }>;
         retryCount: z.ZodNumber;
         firstFailureAt: z.ZodNullable<z.ZodNumber>;
@@ -143,10 +143,10 @@ declare const UpdateFrameworkPackageResultSchema: z.ZodObject<{
     restartingAt: z.ZodNumber;
 }, z.core.$strip>;
 declare const BulkUpdateItemStatusSchema: z.ZodEnum<{
-    failed: "failed";
     queued: "queued";
-    updating: "updating";
     done: "done";
+    failed: "failed";
+    updating: "updating";
     "done-pending-restart": "done-pending-restart";
 }>;
 declare const BulkUpdateItemSchema: z.ZodObject<{
@@ -155,10 +155,10 @@ declare const BulkUpdateItemSchema: z.ZodObject<{
     fromVersion: z.ZodString;
     toVersion: z.ZodString;
     status: z.ZodEnum<{
-        failed: "failed";
         queued: "queued";
-        updating: "updating";
         done: "done";
+        failed: "failed";
+        updating: "updating";
         "done-pending-restart": "done-pending-restart";
     }>;
     error: z.ZodOptional<z.ZodString>;
@@ -167,8 +167,8 @@ declare const BulkUpdateItemSchema: z.ZodObject<{
 }, z.core.$strip>;
 declare const BulkUpdatePhaseSchema: z.ZodEnum<{
     system: "system";
-    regular: "regular";
     restarting: "restarting";
+    regular: "regular";
     finalizing: "finalizing";
 }>;
 declare const BulkUpdateStateSchema: z.ZodObject<{
@@ -182,8 +182,8 @@ declare const BulkUpdateStateSchema: z.ZodObject<{
     current: z.ZodNullable<z.ZodString>;
     phase: z.ZodEnum<{
         system: "system";
-        regular: "regular";
         restarting: "restarting";
+        regular: "regular";
         finalizing: "finalizing";
     }>;
     cancelled: z.ZodBoolean;
@@ -193,10 +193,10 @@ declare const BulkUpdateStateSchema: z.ZodObject<{
         fromVersion: z.ZodString;
         toVersion: z.ZodString;
         status: z.ZodEnum<{
-            failed: "failed";
             queued: "queued";
-            updating: "updating";
             done: "done";
+            failed: "failed";
+            updating: "updating";
             "done-pending-restart": "done-pending-restart";
         }>;
         error: z.ZodOptional<z.ZodString>;
@@ -281,9 +281,9 @@ export declare const addonsCapability: {
             hasBackup: z.ZodOptional<z.ZodBoolean>;
             health: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 phase: z.ZodEnum<{
+                    failed: "failed";
                     pending: "pending";
                     healthy: "healthy";
-                    failed: "failed";
                 }>;
                 retryCount: z.ZodNumber;
                 firstFailureAt: z.ZodNullable<z.ZodNumber>;
@@ -509,122 +509,6 @@ export declare const addonsCapability: {
             toVersion: z.ZodString;
             restartingAt: z.ZodNumber;
         }, z.core.$strip>, "mutation">;
-        /**
-         * Kicks off a server-side bulk update operation and returns the bulk
-         * id immediately. The operation runs asynchronously; observe progress
-         * via the `AddonsBulkUpdateProgress` event or `getBulkUpdateState`.
-         * Items with `isSystem: true` use `deferRestart` — the hub restarts
-         * ONCE at the end of the system phase, after all system packages are
-         * installed.
-         *
-         * `items[].version` is REQUIRED — callers must pass the resolved
-         * version from `listUpdates`. There is no `'latest'` default here
-         * (unlike `updatePackage`) to guarantee deterministic bulk rolls.
-         */
-        readonly startBulkUpdate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            nodeId: z.ZodString;
-            items: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                version: z.ZodString;
-                isSystem: z.ZodBoolean;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>, z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$strip>, "mutation">;
-        /**
-         * Returns the current state of a bulk update by id.
-         * Returns `null` if the id is unknown or has been auto-cleaned
-         * (5 minutes after `completedAt` the record is evicted from memory).
-         */
-        readonly getBulkUpdateState: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
-            id: z.ZodString;
-            nodeId: z.ZodString;
-            startedAtMs: z.ZodNumber;
-            completedAtMs: z.ZodOptional<z.ZodNumber>;
-            total: z.ZodNumber;
-            completed: z.ZodNumber;
-            failed: z.ZodNumber;
-            current: z.ZodNullable<z.ZodString>;
-            phase: z.ZodEnum<{
-                system: "system";
-                regular: "regular";
-                restarting: "restarting";
-                finalizing: "finalizing";
-            }>;
-            cancelled: z.ZodBoolean;
-            items: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                isSystem: z.ZodBoolean;
-                fromVersion: z.ZodString;
-                toVersion: z.ZodString;
-                status: z.ZodEnum<{
-                    failed: "failed";
-                    queued: "queued";
-                    updating: "updating";
-                    done: "done";
-                    "done-pending-restart": "done-pending-restart";
-                }>;
-                error: z.ZodOptional<z.ZodString>;
-                startedAtMs: z.ZodOptional<z.ZodNumber>;
-                completedAtMs: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
-        /**
-         * Cancels an in-flight bulk update. The update loop exits after the
-         * currently-processing item completes — cancellation is not
-         * instantaneous. Has no effect once the `restarting` phase has been
-         * entered (the hub is already shutting down at that point).
-         * Returns `{ cancelled: false }` if the id is unknown, the operation
-         * has already completed, or the `restarting` phase is active.
-         */
-        readonly cancelBulkUpdate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            cancelled: z.ZodBoolean;
-        }, z.core.$strip>, "mutation">;
-        /**
-         * Lists all currently active (non-completed) bulk updates.
-         * If `nodeId` is provided, filters to only bulk updates targeting
-         * that node. Useful for restoring an in-progress banner on a fresh
-         * page load when the UI reconnects mid-operation.
-         */
-        readonly listActiveBulkUpdates: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            nodeId: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            nodeId: z.ZodString;
-            startedAtMs: z.ZodNumber;
-            completedAtMs: z.ZodOptional<z.ZodNumber>;
-            total: z.ZodNumber;
-            completed: z.ZodNumber;
-            failed: z.ZodNumber;
-            current: z.ZodNullable<z.ZodString>;
-            phase: z.ZodEnum<{
-                system: "system";
-                regular: "regular";
-                restarting: "restarting";
-                finalizing: "finalizing";
-            }>;
-            cancelled: z.ZodBoolean;
-            items: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                isSystem: z.ZodBoolean;
-                fromVersion: z.ZodString;
-                toVersion: z.ZodString;
-                status: z.ZodEnum<{
-                    failed: "failed";
-                    queued: "queued";
-                    updating: "updating";
-                    done: "done";
-                    "done-pending-restart": "done-pending-restart";
-                }>;
-                error: z.ZodOptional<z.ZodString>;
-                startedAtMs: z.ZodOptional<z.ZodNumber>;
-                completedAtMs: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly getVersions: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             name: z.ZodString;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
@@ -694,6 +578,193 @@ export declare const addonsCapability: {
             action: z.ZodString;
             input: z.ZodUnknown;
         }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        /**
+         * Start a lifecycle job (install / update / uninstall / restart) for one
+         * or more addon packages. Returns the `jobId` immediately — the job runs
+         * asynchronously. Observe progress via `EventCategory.AddonsJobProgress` /
+         * `AddonsJobLog` events or poll `getJob`.
+         *
+         * For a single-addon update on the hub the provider also routes
+         * `updatePackage` through this path so the fast swap + atomic-restart
+         * path (`applyStagedAddonUpdate`) is always used.
+         */
+        readonly startJob: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            kind: z.ZodEnum<{
+                update: "update";
+                install: "install";
+                uninstall: "uninstall";
+                restart: "restart";
+            }>;
+            targets: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strip>>;
+            nodeIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            jobId: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Retrieve a lifecycle job by id. Returns `null` when the id is unknown
+         * (e.g. evicted after the retention window).
+         */
+        readonly getJob: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            jobId: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<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<{
+                    queued: "queued";
+                    fetching: "fetching";
+                    staged: "staged";
+                    validating: "validating";
+                    applying: "applying";
+                    restarting: "restarting";
+                    applied: "applied";
+                    done: "done";
+                    failed: "failed";
+                    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<{
+                        queued: "queued";
+                        fetching: "fetching";
+                        staged: "staged";
+                        validating: "validating";
+                        applying: "applying";
+                        restarting: "restarting";
+                        applied: "applied";
+                        done: "done";
+                        failed: "failed";
+                        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>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * List lifecycle jobs. When `activeOnly` is true, only jobs still in
+         * `running` state are returned.
+         */
+        readonly listJobs: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            activeOnly: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodArray<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<{
+                    queued: "queued";
+                    fetching: "fetching";
+                    staged: "staged";
+                    validating: "validating";
+                    applying: "applying";
+                    restarting: "restarting";
+                    applied: "applied";
+                    done: "done";
+                    failed: "failed";
+                    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<{
+                        queued: "queued";
+                        fetching: "fetching";
+                        staged: "staged";
+                        validating: "validating";
+                        applying: "applying";
+                        restarting: "restarting";
+                        applied: "applied";
+                        done: "done";
+                        failed: "failed";
+                        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>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Cancel a lifecycle job that is queued but not yet actively running.
+         * Returns `{ cancelled: false }` if the job is unknown, already in a
+         * terminal state, or actively executing (cannot abort mid-flight).
+         */
+        readonly cancelJob: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            jobId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            cancelled: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
         readonly onAddonLogs: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             addonId: z.ZodString;
             level: z.ZodOptional<z.ZodEnum<{

package/dist/enums/event-category.d.ts

@@ -444,14 +444,15 @@ export declare enum EventCategory {
     DeviceSleeping = "device.sleeping",
     RetentionCleanup = "retention.cleanup",
     /**
-     * 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 (`AddonsJobProgress`/`AddonsJobLog`). Retained
+     * (with `BulkUpdateState`) only to avoid regenerating the event maps; removed
+     * in F4 once live bulk progress is re-implemented over the engine events.
      */
     AddonsBulkUpdateProgress = "addons.bulk-update-progress",
+    AddonsJobProgress = "addons.job-progress",
+    AddonsJobLog = "addons.job-log",
     /**
      * A container's child visibility toggled (hidden/shown). Emitted by the
      * `accessories` cap when a child device is hidden or revealed.