@camstack/types 1.2.122 → 1.2.124

package/dist/interfaces/relocate.d.ts

@@ -91,24 +91,77 @@ export declare const StorageMigrationFootageMoveInputSchema: z.ZodObject<{
     leaseId: z.ZodString;
 }, z.core.$strip>;
 export type StorageMigrationFootageMoveInput = z.infer<typeof StorageMigrationFootageMoveInputSchema>;
+/**
+ * What a `relocateMedia` pass DOES. One engine, three passes — never a second
+ * mover (the engine already walks both collections with a timestamp cursor and
+ * already has a stamp-without-copy path).
+ *
+ *  - `move`    — the default and the historical behaviour: event-media and
+ *                retrain blobs move to `toLocationId` and their rows are
+ *                stamped. The enrolled gallery is skipped (D197).
+ *  - `seal`    — ROWS ONLY, no bytes. Every row whose `locationId` is NULL is
+ *                stamped with `toLocationId`. `toLocationId` here is the id the
+ *                bytes ALREADY sit on — today's `eventMedia` default — because
+ *                a NULL row means "wherever `eventMedia` points *now*", and the
+ *                instant a repoint moves that pointer the row reads from the
+ *                new disk while its bytes are on the old one.
+ *  - `gallery` — the inverse selection of `move`: ONLY the retention-exempt
+ *                (enrolled-gallery) rows, which `move` deliberately skips.
+ *                `galleryMedia` is `cardinality: 'single'`, so this pass can
+ *                never run beside a live second location: it is stop-the-world
+ *                by construction, which is acceptable only because the gallery
+ *                is a few KB per enrolled sample.
+ */
+export declare const MediaRelocateModeSchema: z.ZodEnum<{
+    move: "move";
+    seal: "seal";
+    gallery: "gallery";
+}>;
+export type MediaRelocateMode = z.infer<typeof MediaRelocateModeSchema>;
 export declare const RelocateMediaInputSchema: z.ZodObject<{
     toLocationId: z.ZodString;
     throttleMbps: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        move: "move";
+        seal: "seal";
+        gallery: "gallery";
+    }>>;
 }, z.core.$strip>;
 export type RelocateMediaInput = z.infer<typeof RelocateMediaInputSchema>;
+/** How many rows still carry NO `locationId` — the population a repoint would
+ *  silently re-aim at a disk that does not hold their bytes. Zero is the only
+ *  value that permits a non-blocking `eventMedia` cutover. */
+export declare const UnstampedEventMediaCountSchema: z.ZodObject<{
+    media: z.ZodNumber;
+    retrainFrames: z.ZodNumber;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+export type UnstampedEventMediaCount = z.infer<typeof UnstampedEventMediaCountSchema>;
 export declare const StorageMigrationMediaMoveInputSchema: z.ZodObject<{
     toLocationId: z.ZodString;
     throttleMbps: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        move: "move";
+        seal: "seal";
+        gallery: "gallery";
+    }>>;
     leaseId: z.ZodString;
 }, z.core.$strip>;
 export type StorageMigrationMediaMoveInput = z.infer<typeof StorageMigrationMediaMoveInputSchema>;
-/** The independently selectable logical storage classes. `recordings`
- * encompasses the high and mid segment profiles; `recordingsLow` is low
- * segments; `eventMedia` is post-analysis blobs. */
+/** The independently selectable logical storage classes — every class
+ * `storage.listLocationDeclarations` reports, so an operator never meets a
+ * Zod enum error where they should meet an explanation.
+ *
+ * `recordings` encompasses the high and mid segment profiles; `recordingsLow`
+ * is low segments; `eventMedia` is post-analysis blobs; `galleryMedia` is the
+ * enrolled gallery; `backups` is the system backup archive. The last two have
+ * their own rules — see {@link StorageMigrationFindingCodeSchema}. */
 export declare const StorageMigrationClassSchema: z.ZodEnum<{
     recordings: "recordings";
     recordingsLow: "recordingsLow";
     eventMedia: "eventMedia";
+    backups: "backups";
+    galleryMedia: "galleryMedia";
 }>;
 export type StorageMigrationClass = z.infer<typeof StorageMigrationClassSchema>;
 /** A destination is always an existing, fully-qualified location id. The
@@ -118,21 +171,63 @@ export declare const StorageMigrationDestinationsSchema: z.ZodObject<{
     recordings: z.ZodOptional<z.ZodString>;
     recordingsLow: z.ZodOptional<z.ZodString>;
     eventMedia: z.ZodOptional<z.ZodString>;
+    backups: z.ZodOptional<z.ZodString>;
+    galleryMedia: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type StorageMigrationDestinations = z.infer<typeof StorageMigrationDestinationsSchema>;
+/**
+ * How a migration sequences the cutover against the byte move.
+ *
+ *  - `blocking`     — the historical order: pause, move every byte, repoint,
+ *                     resume. Recording is stopped for the whole move. Right
+ *                     for a small or a cold class, and the only legal mode for
+ *                     a `cardinality: 'single'` class.
+ *  - `nonBlocking`  — repoint FIRST, drain behind: seal, pause, repoint,
+ *                     refresh, resume, then move the past with everything
+ *                     running. The pause is three bounded instants (a detach +
+ *                     attach round, a write-gate drain, a lease) instead of one
+ *                     bounded by bytes. 1.09 TB at 7–14 MB/s is thirty hours of
+ *                     stopped recording under `blocking`; the same move is
+ *                     seconds of stopped recording under `nonBlocking`.
+ *
+ * The mode is on the JOB, not only on the input, because `status` is where an
+ * operator finds out which one is running.
+ */
+export declare const StorageMigrationModeSchema: z.ZodEnum<{
+    blocking: "blocking";
+    nonBlocking: "nonBlocking";
+}>;
+export type StorageMigrationMode = z.infer<typeof StorageMigrationModeSchema>;
 /** Shared input for planning and starting an orchestrated storage migration. */
 export declare const StorageMigrationInputSchema: z.ZodObject<{
     destinations: z.ZodObject<{
         recordings: z.ZodOptional<z.ZodString>;
         recordingsLow: z.ZodOptional<z.ZodString>;
         eventMedia: z.ZodOptional<z.ZodString>;
+        backups: z.ZodOptional<z.ZodString>;
+        galleryMedia: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     throttleMbps: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        blocking: "blocking";
+        nonBlocking: "nonBlocking";
+    }>>;
 }, z.core.$strip>;
 export type StorageMigrationInput = z.infer<typeof StorageMigrationInputSchema>;
-/** The durable coordinator state machine. The only phase that changes default
- * locations is `repointing`, after every selected mover has completed and been
- * verified. */
+/**
+ * The durable coordinator state machine.
+ *
+ * `blocking`:
+ *   planning → pausing → moving → verifying → repointing → refreshing → resuming → done
+ *
+ * `nonBlocking`:
+ *   planning → sealing → pausing → repointing → refreshing → resuming → draining → verifying → done
+ *
+ * Same phases, different order plus two new ones — not a second mover.
+ * `sealing` closes the `eventMedia` NULL-row hole BEFORE anything is paused;
+ * `draining` runs the same movers UNLEASED, after every writer is back up.
+ * `repointing` is still the only phase that changes a default location.
+ */
 export declare const StorageMigrationPhaseSchema: z.ZodEnum<{
     moving: "moving";
     verifying: "verifying";
@@ -140,7 +235,9 @@ export declare const StorageMigrationPhaseSchema: z.ZodEnum<{
     done: "done";
     cancelled: "cancelled";
     planning: "planning";
+    sealing: "sealing";
     pausing: "pausing";
+    draining: "draining";
     repointing: "repointing";
     refreshing: "refreshing";
     resuming: "resuming";
@@ -157,6 +254,8 @@ export declare const StorageMigrationMoveSchema: z.ZodObject<{
         recordings: "recordings";
         recordingsLow: "recordingsLow";
         eventMedia: "eventMedia";
+        backups: "backups";
+        galleryMedia: "galleryMedia";
     }>;
     fromLocationId: z.ZodString;
     toLocationId: z.ZodString;
@@ -180,15 +279,23 @@ export declare const StorageMigrationJobSchema: z.ZodObject<{
         done: "done";
         cancelled: "cancelled";
         planning: "planning";
+        sealing: "sealing";
         pausing: "pausing";
+        draining: "draining";
         repointing: "repointing";
         refreshing: "refreshing";
         resuming: "resuming";
     }>;
+    mode: z.ZodEnum<{
+        blocking: "blocking";
+        nonBlocking: "nonBlocking";
+    }>;
     destinations: z.ZodObject<{
         recordings: z.ZodOptional<z.ZodString>;
         recordingsLow: z.ZodOptional<z.ZodString>;
         eventMedia: z.ZodOptional<z.ZodString>;
+        backups: z.ZodOptional<z.ZodString>;
+        galleryMedia: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     throttleMbps: z.ZodNumber;
     moves: z.ZodArray<z.ZodObject<{
@@ -196,6 +303,8 @@ export declare const StorageMigrationJobSchema: z.ZodObject<{
             recordings: "recordings";
             recordingsLow: "recordingsLow";
             eventMedia: "eventMedia";
+            backups: "backups";
+            galleryMedia: "galleryMedia";
         }>;
         fromLocationId: z.ZodString;
         toLocationId: z.ZodString;
@@ -223,20 +332,94 @@ export declare const StorageMigrationJobSchema: z.ZodObject<{
     error: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export type StorageMigrationJob = z.infer<typeof StorageMigrationJobSchema>;
+/**
+ * What the planner NOTICED but did not refuse.
+ *
+ * A refusal throws — the operator cannot miss it. A finding is the other half:
+ * something true about this plan that changes what the operator should expect,
+ * surfaced where they read it rather than in a document they will not open.
+ *
+ *  - `sharesDeviceWithSource` — the destination realpath's to the same place as
+ *    the source. The move will be a row re-stamp, not a byte move, and it buys
+ *    no redundancy. NOTE: this is PATH identity, not `st_dev` — two distinct
+ *    directories on one filesystem are NOT detected. See
+ *    `deviceIdentityUnknown`.
+ *  - `deviceIdentityUnknown` — a location carries a `nodeId` other than this
+ *    one (or has no `basePath`), so its realpath cannot be taken here and the
+ *    same-device question was not answered at all. Stated rather than assumed
+ *    clear: a check that silently never fires is worse than no check.
+ *  - `unstampedEventMediaRows` — how many `eventMedia`/retrain rows still carry
+ *    no `locationId`. Non-zero refuses a `nonBlocking` cutover.
+ *  - `blockingOnly` — this class is `cardinality: 'single'`, so it can never
+ *    span two locations and can only ever be moved stop-the-world.
+ *  - `noMover` — the class is selectable and planned, but no addon owns a mover
+ *    for it. The migration cannot move its bytes.
+ */
+export declare const StorageMigrationFindingCodeSchema: z.ZodEnum<{
+    sharesDeviceWithSource: "sharesDeviceWithSource";
+    deviceIdentityUnknown: "deviceIdentityUnknown";
+    unstampedEventMediaRows: "unstampedEventMediaRows";
+    blockingOnly: "blockingOnly";
+    noMover: "noMover";
+}>;
+export type StorageMigrationFindingCode = z.infer<typeof StorageMigrationFindingCodeSchema>;
+export declare const StorageMigrationFindingSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        sharesDeviceWithSource: "sharesDeviceWithSource";
+        deviceIdentityUnknown: "deviceIdentityUnknown";
+        unstampedEventMediaRows: "unstampedEventMediaRows";
+        blockingOnly: "blockingOnly";
+        noMover: "noMover";
+    }>;
+    storageClass: z.ZodEnum<{
+        recordings: "recordings";
+        recordingsLow: "recordingsLow";
+        eventMedia: "eventMedia";
+        backups: "backups";
+        galleryMedia: "galleryMedia";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type StorageMigrationFinding = z.infer<typeof StorageMigrationFindingSchema>;
 export declare const StorageMigrationPlanSchema: z.ZodObject<{
     destinations: z.ZodObject<{
         recordings: z.ZodOptional<z.ZodString>;
         recordingsLow: z.ZodOptional<z.ZodString>;
         eventMedia: z.ZodOptional<z.ZodString>;
+        backups: z.ZodOptional<z.ZodString>;
+        galleryMedia: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
+    mode: z.ZodEnum<{
+        blocking: "blocking";
+        nonBlocking: "nonBlocking";
+    }>;
     moves: z.ZodArray<z.ZodObject<{
         storageClass: z.ZodEnum<{
             recordings: "recordings";
             recordingsLow: "recordingsLow";
             eventMedia: "eventMedia";
+            backups: "backups";
+            galleryMedia: "galleryMedia";
         }>;
         fromLocationId: z.ZodString;
         toLocationId: z.ZodString;
     }, z.core.$strip>>;
+    findings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            sharesDeviceWithSource: "sharesDeviceWithSource";
+            deviceIdentityUnknown: "deviceIdentityUnknown";
+            unstampedEventMediaRows: "unstampedEventMediaRows";
+            blockingOnly: "blockingOnly";
+            noMover: "noMover";
+        }>;
+        storageClass: z.ZodEnum<{
+            recordings: "recordings";
+            recordingsLow: "recordingsLow";
+            eventMedia: "eventMedia";
+            backups: "backups";
+            galleryMedia: "galleryMedia";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type StorageMigrationPlan = z.infer<typeof StorageMigrationPlanSchema>;

package/dist/{sleep-DUxF5DdC.js → sleep-CJrvRDlD.js}

@@ -3445,6 +3445,7 @@ function createDeviceProxy(api, binding, opts) {
 			getStorageMigrationMoveStatus: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getStorageMigrationMoveStatus", "query", input),
 			cancelStorageMigrationMove: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "cancelStorageMigrationMove", "mutation", input),
 			relocateMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "relocateMedia", "mutation", input),
+			countUnstampedEventMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "countUnstampedEventMedia", "query", input),
 			listRelocateMediaJobs: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRelocateMediaJobs", "query", input),
 			cancelRelocateMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "cancelRelocateMedia", "mutation", input),
 			listOpsLog: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listOpsLog", "query", input),

package/dist/{sleep-C9C8EoK8.mjs → sleep-L5-bG_a_.mjs}

@@ -3445,6 +3445,7 @@ function createDeviceProxy(api, binding, opts) {
 			getStorageMigrationMoveStatus: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getStorageMigrationMoveStatus", "query", input),
 			cancelStorageMigrationMove: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "cancelStorageMigrationMove", "mutation", input),
 			relocateMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "relocateMedia", "mutation", input),
+			countUnstampedEventMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "countUnstampedEventMedia", "query", input),
 			listRelocateMediaJobs: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRelocateMediaJobs", "query", input),
 			cancelRelocateMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "cancelRelocateMedia", "mutation", input),
 			listOpsLog: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listOpsLog", "query", input),

package/package.json

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