@camstack/system 1.2.154 → 1.2.156

package/dist/builtins/system-config/system-config.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BPlfW-CG.js");
+const require_dist = require("../../dist-CDgIzo82.js");
 //#region src/builtins/system-config/system-config.addon.ts
 /**
 * Built-in `system-config` addon — Phase 4 of the settings redesign.

package/dist/builtins/system-config/system-config.addon.mjs

@@ -1,4 +1,4 @@
-import { Kt as hydrateSchema, Ot as errMsg, kt as BaseAddon } from "../../dist-D_NyUV6Y.mjs";
+import { Kt as hydrateSchema, Ot as errMsg, kt as BaseAddon } from "../../dist-LvKus-mT.mjs";
 //#region src/builtins/system-config/system-config.addon.ts
 /**
 * Built-in `system-config` addon — Phase 4 of the settings redesign.

package/dist/builtins/winston-logging/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BPlfW-CG.js");
+const require_dist = require("../../dist-CDgIzo82.js");
 const require_formatter = require("../../formatter-DqAKDlvN.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);

package/dist/builtins/winston-logging/index.mjs

@@ -1,4 +1,4 @@
-import { kt as BaseAddon, rt as logDestinationCapability } from "../../dist-D_NyUV6Y.mjs";
+import { kt as BaseAddon, rt as logDestinationCapability } from "../../dist-LvKus-mT.mjs";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 import * as path$1 from "node:path";
 import path from "node:path";

package/dist/{dist-BPlfW-CG.js → dist-CDgIzo82.js}

@@ -4166,18 +4166,61 @@ var RelocateFootageInputSchema = zod.z.object({
 * `RecordingConfig.enabled` or camera wrapper bindings. */
 var StorageMigrationLeaseInputSchema = zod.z.object({ leaseId: zod.z.string().min(1) });
 var StorageMigrationFootageMoveInputSchema = RelocateFootageInputSchema.extend({ leaseId: zod.z.string().min(1) });
+/**
+* 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.
+*/
+var MediaRelocateModeSchema = zod.z.enum([
+	"move",
+	"seal",
+	"gallery"
+]);
 var RelocateMediaInputSchema = zod.z.object({
 	toLocationId: zod.z.string(),
-	throttleMbps: zod.z.number().min(1).max(1e3).optional()
+	throttleMbps: zod.z.number().min(1).max(1e3).optional(),
+	/** Omitted = `move`, the pre-existing behaviour. */
+	mode: MediaRelocateModeSchema.optional()
+});
+/** 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. */
+var UnstampedEventMediaCountSchema = zod.z.object({
+	media: zod.z.number().int().nonnegative(),
+	retrainFrames: zod.z.number().int().nonnegative(),
+	total: zod.z.number().int().nonnegative()
 });
 var StorageMigrationMediaMoveInputSchema = RelocateMediaInputSchema.extend({ leaseId: zod.z.string().min(1) });
-/** 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}. */
 var StorageMigrationClassSchema = zod.z.enum([
 	"recordings",
 	"recordingsLow",
-	"eventMedia"
+	"eventMedia",
+	"backups",
+	"galleryMedia"
 ]);
 /** A destination is always an existing, fully-qualified location id. The
 * migration API intentionally never changes a source location's `basePath`:
@@ -4185,20 +4228,56 @@ var StorageMigrationClassSchema = zod.z.enum([
 var StorageMigrationDestinationsSchema = zod.z.object({
 	recordings: zod.z.string().min(1).optional(),
 	recordingsLow: zod.z.string().min(1).optional(),
-	eventMedia: zod.z.string().min(1).optional()
+	eventMedia: zod.z.string().min(1).optional(),
+	backups: zod.z.string().min(1).optional(),
+	galleryMedia: zod.z.string().min(1).optional()
 }).refine((value) => Object.keys(value).length > 0, { message: "select at least one storage class" });
+/**
+* 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.
+*/
+var StorageMigrationModeSchema = zod.z.enum(["blocking", "nonBlocking"]);
 /** Shared input for planning and starting an orchestrated storage migration. */
 var StorageMigrationInputSchema = zod.z.object({
 	destinations: StorageMigrationDestinationsSchema,
-	throttleMbps: zod.z.number().min(1).max(1e3).optional()
+	throttleMbps: zod.z.number().min(1).max(1e3).optional(),
+	/** Omitted = `blocking`, which stays the default. */
+	mode: StorageMigrationModeSchema.optional()
 });
-/** 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.
+*/
 var StorageMigrationPhaseSchema = zod.z.enum([
 	"planning",
+	"sealing",
 	"pausing",
 	"moving",
+	"draining",
 	"verifying",
 	"repointing",
 	"refreshing",
@@ -4223,6 +4302,9 @@ var StorageMigrationMoveSchema = zod.z.object({
 var StorageMigrationJobSchema = zod.z.object({
 	jobId: zod.z.string(),
 	phase: StorageMigrationPhaseSchema,
+	/** Which order this job is running. `status` is the only place an operator
+	*  can tell a seconds-long cutover from a thirty-hour one. */
+	mode: StorageMigrationModeSchema,
 	destinations: StorageMigrationDestinationsSchema,
 	throttleMbps: zod.z.number(),
 	moves: zod.z.array(StorageMigrationMoveSchema),
@@ -4235,13 +4317,54 @@ var StorageMigrationJobSchema = zod.z.object({
 	finishedAt: zod.z.number().nullable(),
 	error: zod.z.string().nullable()
 });
+/**
+* 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.
+*/
+var StorageMigrationFindingCodeSchema = zod.z.enum([
+	"sharesDeviceWithSource",
+	"deviceIdentityUnknown",
+	"unstampedEventMediaRows",
+	"blockingOnly",
+	"noMover"
+]);
+var StorageMigrationFindingSchema = zod.z.object({
+	code: StorageMigrationFindingCodeSchema,
+	storageClass: StorageMigrationClassSchema,
+	/** Human-readable, already carrying the ids and counts. */
+	message: zod.z.string()
+});
 var StorageMigrationPlanSchema = zod.z.object({
 	destinations: StorageMigrationDestinationsSchema,
+	/** The mode this plan was built for. A plan is only valid for its mode: the
+	*  `eventMedia` seal gate and the single-cardinality refusal both depend on
+	*  it. */
+	mode: StorageMigrationModeSchema,
 	moves: zod.z.array(zod.z.object({
 		storageClass: StorageMigrationClassSchema,
 		fromLocationId: zod.z.string(),
 		toLocationId: zod.z.string()
-	}))
+	})),
+	findings: zod.z.array(StorageMigrationFindingSchema)
 });
 /**
 * `StorageLocationType` — an addon-declared id that identifies the *kind* of
@@ -17867,6 +17990,17 @@ var pipelineAnalyticsCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* How many media / retrain rows still carry NO `locationId`.
+		*
+		* A NULL row means "wherever `eventMedia` points NOW", so the instant a
+		* repoint moves that pointer every such row reads from the new disk while
+		* its bytes are on the old one — the archive goes dark until a drain
+		* happens to stamp it. This count is what the migration planner's
+		* non-blocking gate reads; `relocateMedia({ mode: 'seal' })` is what drives
+		* it to zero.
+		*/
+		countUnstampedEventMedia: method(zod.z.object({}), UnstampedEventMediaCountSchema, { auth: "admin" }),
 		/** Every relocate job this addon knows about, newest first (in RAM: the
 		*  move is resumable, so a lost list costs nothing but the display). */
 		listRelocateMediaJobs: method(zod.z.object({}), zod.z.array(RelocateJobSchema).readonly(), {
@@ -20718,7 +20852,24 @@ var storageCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		deleteLocation: method(zod.z.object({ id: zod.z.string() }), zod.z.void(), {
+		/**
+		* Remove a location record. REFUSES a location that still holds data —
+		* deleting a drained location whose durable rows still name it is how this
+		* hub acquired 2 131 ghost `recordings:high` segments, and playback does
+		* not stat, so the operator sees a silent black window rather than an
+		* error.
+		*
+		* `force` exists because the occupancy check is BEST-EFFORT and refuses on
+		* "unknown" as well as on "occupied" (a read that fails must not authorise
+		* a destruction — D49). A location on a removed disk, on another node, or
+		* behind a remote provider answers "unknown" forever, and a refusal an
+		* operator cannot override is its own failure mode. `force: true` is
+		* logged, loudly, with what the check saw.
+		*/
+		deleteLocation: method(zod.z.object({
+			id: zod.z.string(),
+			force: zod.z.boolean().optional()
+		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "admin"
 		}),
@@ -36071,6 +36222,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.countUnstampedEventMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.deleteDeviceEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",

package/dist/{dist-D_NyUV6Y.mjs → dist-LvKus-mT.mjs}

@@ -4166,18 +4166,61 @@ var RelocateFootageInputSchema = z.object({
 * `RecordingConfig.enabled` or camera wrapper bindings. */
 var StorageMigrationLeaseInputSchema = z.object({ leaseId: z.string().min(1) });
 var StorageMigrationFootageMoveInputSchema = RelocateFootageInputSchema.extend({ leaseId: z.string().min(1) });
+/**
+* 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.
+*/
+var MediaRelocateModeSchema = z.enum([
+	"move",
+	"seal",
+	"gallery"
+]);
 var RelocateMediaInputSchema = z.object({
 	toLocationId: z.string(),
-	throttleMbps: z.number().min(1).max(1e3).optional()
+	throttleMbps: z.number().min(1).max(1e3).optional(),
+	/** Omitted = `move`, the pre-existing behaviour. */
+	mode: MediaRelocateModeSchema.optional()
+});
+/** 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. */
+var UnstampedEventMediaCountSchema = z.object({
+	media: z.number().int().nonnegative(),
+	retrainFrames: z.number().int().nonnegative(),
+	total: z.number().int().nonnegative()
 });
 var StorageMigrationMediaMoveInputSchema = RelocateMediaInputSchema.extend({ leaseId: z.string().min(1) });
-/** 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}. */
 var StorageMigrationClassSchema = z.enum([
 	"recordings",
 	"recordingsLow",
-	"eventMedia"
+	"eventMedia",
+	"backups",
+	"galleryMedia"
 ]);
 /** A destination is always an existing, fully-qualified location id. The
 * migration API intentionally never changes a source location's `basePath`:
@@ -4185,20 +4228,56 @@ var StorageMigrationClassSchema = z.enum([
 var StorageMigrationDestinationsSchema = z.object({
 	recordings: z.string().min(1).optional(),
 	recordingsLow: z.string().min(1).optional(),
-	eventMedia: z.string().min(1).optional()
+	eventMedia: z.string().min(1).optional(),
+	backups: z.string().min(1).optional(),
+	galleryMedia: z.string().min(1).optional()
 }).refine((value) => Object.keys(value).length > 0, { message: "select at least one storage class" });
+/**
+* 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.
+*/
+var StorageMigrationModeSchema = z.enum(["blocking", "nonBlocking"]);
 /** Shared input for planning and starting an orchestrated storage migration. */
 var StorageMigrationInputSchema = z.object({
 	destinations: StorageMigrationDestinationsSchema,
-	throttleMbps: z.number().min(1).max(1e3).optional()
+	throttleMbps: z.number().min(1).max(1e3).optional(),
+	/** Omitted = `blocking`, which stays the default. */
+	mode: StorageMigrationModeSchema.optional()
 });
-/** 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.
+*/
 var StorageMigrationPhaseSchema = z.enum([
 	"planning",
+	"sealing",
 	"pausing",
 	"moving",
+	"draining",
 	"verifying",
 	"repointing",
 	"refreshing",
@@ -4223,6 +4302,9 @@ var StorageMigrationMoveSchema = z.object({
 var StorageMigrationJobSchema = z.object({
 	jobId: z.string(),
 	phase: StorageMigrationPhaseSchema,
+	/** Which order this job is running. `status` is the only place an operator
+	*  can tell a seconds-long cutover from a thirty-hour one. */
+	mode: StorageMigrationModeSchema,
 	destinations: StorageMigrationDestinationsSchema,
 	throttleMbps: z.number(),
 	moves: z.array(StorageMigrationMoveSchema),
@@ -4235,13 +4317,54 @@ var StorageMigrationJobSchema = z.object({
 	finishedAt: z.number().nullable(),
 	error: z.string().nullable()
 });
+/**
+* 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.
+*/
+var StorageMigrationFindingCodeSchema = z.enum([
+	"sharesDeviceWithSource",
+	"deviceIdentityUnknown",
+	"unstampedEventMediaRows",
+	"blockingOnly",
+	"noMover"
+]);
+var StorageMigrationFindingSchema = z.object({
+	code: StorageMigrationFindingCodeSchema,
+	storageClass: StorageMigrationClassSchema,
+	/** Human-readable, already carrying the ids and counts. */
+	message: z.string()
+});
 var StorageMigrationPlanSchema = z.object({
 	destinations: StorageMigrationDestinationsSchema,
+	/** The mode this plan was built for. A plan is only valid for its mode: the
+	*  `eventMedia` seal gate and the single-cardinality refusal both depend on
+	*  it. */
+	mode: StorageMigrationModeSchema,
 	moves: z.array(z.object({
 		storageClass: StorageMigrationClassSchema,
 		fromLocationId: z.string(),
 		toLocationId: z.string()
-	}))
+	})),
+	findings: z.array(StorageMigrationFindingSchema)
 });
 /**
 * `StorageLocationType` — an addon-declared id that identifies the *kind* of
@@ -17867,6 +17990,17 @@ var pipelineAnalyticsCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* How many media / retrain rows still carry NO `locationId`.
+		*
+		* A NULL row means "wherever `eventMedia` points NOW", so the instant a
+		* repoint moves that pointer every such row reads from the new disk while
+		* its bytes are on the old one — the archive goes dark until a drain
+		* happens to stamp it. This count is what the migration planner's
+		* non-blocking gate reads; `relocateMedia({ mode: 'seal' })` is what drives
+		* it to zero.
+		*/
+		countUnstampedEventMedia: method(z.object({}), UnstampedEventMediaCountSchema, { auth: "admin" }),
 		/** Every relocate job this addon knows about, newest first (in RAM: the
 		*  move is resumable, so a lost list costs nothing but the display). */
 		listRelocateMediaJobs: method(z.object({}), z.array(RelocateJobSchema).readonly(), {
@@ -20718,7 +20852,24 @@ var storageCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		deleteLocation: method(z.object({ id: z.string() }), z.void(), {
+		/**
+		* Remove a location record. REFUSES a location that still holds data —
+		* deleting a drained location whose durable rows still name it is how this
+		* hub acquired 2 131 ghost `recordings:high` segments, and playback does
+		* not stat, so the operator sees a silent black window rather than an
+		* error.
+		*
+		* `force` exists because the occupancy check is BEST-EFFORT and refuses on
+		* "unknown" as well as on "occupied" (a read that fails must not authorise
+		* a destruction — D49). A location on a removed disk, on another node, or
+		* behind a remote provider answers "unknown" forever, and a refusal an
+		* operator cannot override is its own failure mode. `force: true` is
+		* logged, loudly, with what the check saw.
+		*/
+		deleteLocation: method(z.object({
+			id: z.string(),
+			force: z.boolean().optional()
+		}), z.void(), {
 			kind: "mutation",
 			auth: "admin"
 		}),
@@ -36071,6 +36222,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.countUnstampedEventMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.deleteDeviceEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",

package/dist/index.d.ts

@@ -48,6 +48,8 @@ export type { ReverseProxyOptions } from './http/reverse-proxy.js';
 export { proxyToUpstream } from './http/reverse-proxy.js';
 export type { ChildFanoutDelta, ChildFanoutRegistry, ChildFanoutSample, CrossNodeEventStats, EventFanoutMode, EventPlaneCounters, EventPlaneReader, EventPlaneSources, EventPlaneWindow, } from './kernel/event-plane-report.js';
 export { createEventPlaneMeter, createEventPlaneReader, diffEventPlane, EVENT_PLANE_TOP_N, formatEventPlane, } from './kernel/event-plane-report.js';
+export type { SocketPeerDelta, SocketPeerSample, SocketPlaneBaseline, SocketPlaneCounters, SocketPlaneMeter, SocketPlaneReader, SocketPlaneRegistry, SocketPlaneRegistryChild, SocketPlaneSources, SocketPlaneWindow, } from './kernel/socket-plane-report.js';
+export { createSocketPlaneMeter, createSocketPlaneReader, diffSocketPlane, EMPTY_SOCKET_PLANE_BASELINE, formatSocketPlane, SOCKET_PLANE_TOP_N, } from './kernel/socket-plane-report.js';
 export type { HeapDiagnosticDeps, HeapDiagnosticRequest, HeapSpaceReader, HeapSpaceUsage, } from './kernel/heap-spaces.js';
 export { DECISIVE_HEAP_SPACES, emitHeapDiagnosticReport, formatHeapSpaces, HEAP_SPACE_REPORT_MIN_MB, heapSnapshotAuthorised, heapSpaceField, readHeapSpaces, RUNNER_HEAP_SNAPSHOT_ENV, selectReportedSpaces, } from './kernel/heap-spaces.js';
 export type { DeferredHeapWatchSink, HeapReclaimer, HeapReclaimOptions, HeapSample, HeapWatchProbes, HeapWatchSink, LoopDelayMeter, LoopDelaySample, RssBreakdown, RssBudgetOptions, RssBudgetState, RssGrowthShape, RunnerHeapWatchOptions, } from './kernel/heap-watch.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_dist = require("./dist-BPlfW-CG.js");
+const require_dist = require("./dist-CDgIzo82.js");
 const require_builtins_alerts_alerts_addon = require("./builtins/alerts/alerts.addon.js");
 require("./builtins/alerts/index.js");
 const require_formatter = require("./formatter-DqAKDlvN.js");
@@ -26,7 +26,7 @@ require("./builtins/system-config/index.js");
 const require_builtins_winston_logging_index = require("./builtins/winston-logging/index.js");
 const require_file_data_plane = require("./file-data-plane-DO8KbxCe.js");
 const require_tls$1 = require("./tls-BxQlomxd.js");
-const require_manifest_python_deps = require("./manifest-python-deps-COeSr7el.js");
+const require_manifest_python_deps = require("./manifest-python-deps-DVODn-qc.js");
 const require_resource_monitor = require("./resource-monitor-CdnzxBLP.js");
 const require_custom_action_registry = require("./custom-action-registry-jY0NOZK8.js");
 let zod = require("zod");
@@ -95332,6 +95332,8 @@ exports.DataPlaneRegistry = DataPlaneRegistry;
 exports.DeviceManagerAddon = require_builtins_device_manager_device_manager_addon.DeviceManagerAddon;
 exports.DeviceRegistry = require_manifest_python_deps.DeviceRegistry;
 exports.DeviceStore = require_builtins_sqlite_storage_index.DeviceStore$1;
+exports.EMPTY_SOCKET_DIRECTION = require_manifest_python_deps.EMPTY_SOCKET_DIRECTION;
+exports.EMPTY_SOCKET_PLANE_BASELINE = require_manifest_python_deps.EMPTY_SOCKET_PLANE_BASELINE;
 exports.EVENT_PLANE_TOP_N = require_manifest_python_deps.EVENT_PLANE_TOP_N;
 exports.EVENT_TOPIC_PREFIX = require_manifest_python_deps.EVENT_TOPIC_PREFIX;
 exports.EngineManagerResolver = EngineManagerResolver;
@@ -95405,6 +95407,7 @@ exports.ReadinessTimeoutError = require_dist.ReadinessTimeoutError;
 exports.ReplEngine = ReplEngine;
 exports.RingBuffer = RingBuffer;
 exports.SERVER_AUTH_OID = require_tls$1.SERVER_AUTH_OID;
+exports.SOCKET_PLANE_TOP_N = require_manifest_python_deps.SOCKET_PLANE_TOP_N;
 exports.ScopedLogger = ScopedLogger;
 exports.ScopedTokenManager = require_builtins_local_auth_local_auth_addon.ScopedTokenManager;
 exports.SocketChannel = require_manifest_python_deps.SocketChannel;
@@ -95490,6 +95493,9 @@ exports.createProcessService = createProcessService;
 exports.createReadinessService = createReadinessService;
 exports.createReadinessServiceForRegistry = createReadinessServiceForRegistry;
 exports.createScopedProcessManager = createScopedProcessManager;
+exports.createSocketDirectionCounters = require_manifest_python_deps.createSocketDirectionCounters;
+exports.createSocketPlaneMeter = require_manifest_python_deps.createSocketPlaneMeter;
+exports.createSocketPlaneReader = require_manifest_python_deps.createSocketPlaneReader;
 exports.createStreamProbeBrokerService = createStreamProbeBrokerService;
 exports.createUdsAddonContext = require_manifest_python_deps.createUdsAddonContext;
 exports.createUdsEventBridge = require_manifest_python_deps.createUdsEventBridge;
@@ -95503,6 +95509,7 @@ exports.describeProviderKindDrift = describeProviderKindDrift;
 exports.describeRss = require_manifest_python_deps.describeRss;
 exports.detectWorkspacePackagesDir = detectWorkspacePackagesDir;
 exports.diffEventPlane = require_manifest_python_deps.diffEventPlane;
+exports.diffSocketPlane = require_manifest_python_deps.diffSocketPlane;
 Object.defineProperty(exports, "downloadBinary", {
 	enumerable: true,
 	get: function() {
@@ -95550,6 +95557,7 @@ Object.defineProperty(exports, "findInPath", {
 exports.formatEventPlane = require_manifest_python_deps.formatEventPlane;
 exports.formatHeapSpaces = require_manifest_python_deps.formatHeapSpaces;
 exports.formatLogLine = require_formatter.formatLogLine;
+exports.formatSocketPlane = require_manifest_python_deps.formatSocketPlane;
 exports.getBrokerEventBus = require_manifest_python_deps.getBrokerEventBus;
 exports.getCapUsageRegistry = require_manifest_python_deps.getCapUsageRegistry;
 Object.defineProperty(exports, "getFfmpegDownloadUrl", {
@@ -95629,6 +95637,7 @@ exports.readTlsAccessStatus = require_tls$1.readTlsAccessStatus;
 exports.readTlsMode = require_tls$1.readTlsMode;
 exports.readinessKey = require_dist.readinessKey;
 exports.reclaimIntervalMs = require_manifest_python_deps.reclaimIntervalMs;
+exports.recordSocketFrame = require_manifest_python_deps.recordSocketFrame;
 exports.registerEventBusService = require_manifest_python_deps.registerEventBusService;
 exports.registerLanHttpHandler = require_tls$1.registerLanHttpHandler;
 exports.reissueTlsLeaf = require_tls$1.reissueTlsLeaf;
@@ -95637,6 +95646,7 @@ exports.resolveHwAccel = require_manifest_python_deps.resolveHwAccel;
 exports.resolveNpmInvocation = require_manifest_python_deps.resolveNpmInvocation;
 exports.runHubAddonBoot = runHubAddonBoot;
 exports.runNpm = require_manifest_python_deps.runNpm;
+exports.sampleSocketDirection = require_manifest_python_deps.sampleSocketDirection;
 exports.scheduleSelfRestart = scheduleSelfRestart;
 exports.scopeKey = require_dist.scopeKey;
 exports.scopesAllowAddon = require_dist.scopesAllowAddon;
@@ -95647,6 +95657,8 @@ exports.serializeTypedArrays = require_manifest_python_deps.serializeTypedArrays
 exports.setHubConnected = require_manifest_python_deps.setHubConnected;
 exports.setNodeEventInterest = require_manifest_python_deps.setNodeEventInterest;
 exports.shouldReclaim = require_manifest_python_deps.shouldReclaim;
+exports.socketDirectionBytes = require_manifest_python_deps.socketDirectionBytes;
+exports.socketDirectionMessages = require_manifest_python_deps.socketDirectionMessages;
 exports.startHeapWatch = require_manifest_python_deps.startHeapWatch;
 exports.startRunnerHeapWatch = require_manifest_python_deps.startRunnerHeapWatch;
 exports.strandedMb = require_manifest_python_deps.strandedMb;