@camstack/types 1.2.124 → 1.2.127

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_event_category = require("./event-category-BaEgqJNv.js");
-const require_sleep = require("./sleep-CJrvRDlD.js");
+const require_sleep = require("./sleep-CWWLTM6W.js");
 const require_canonical_hash = require("./canonical-hash-DNV8S5ET.js");
 const require_enums = require("./enums.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
@@ -1193,6 +1193,69 @@ function composeSwitchedOff(input) {
 	};
 }
 //#endregion
+//#region src/interfaces/config-ui-secrets.ts
+/**
+* The value a redacted secret is replaced with on every read surface.
+*
+* It is also the WRITE-BACK token: an `upsertLocation` that sends this value
+* back for a key means "keep what is stored", which is what lets an operator
+* rename a location without retyping its password. A literal an operator could
+* plausibly choose as a real password would turn that convenience into a way
+* to lock yourself out, hence the sentinel shape.
+*/
+var REDACTED_SECRET = "__camstack_redacted__";
+/** Is this field's stored value a credential? */
+function isSecretConfigField(field) {
+	if (field.type === "password") return true;
+	return "secret" in field && field.secret === true;
+}
+/**
+* Every config key in `schema` whose value is a secret, including keys nested
+* inside `group` / `sub-tabs` containers.
+*/
+function collectSecretConfigKeys(schema) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const section of sectionsOf(schema)) for (const field of fieldsOf(section)) walkField(field, keys);
+	return keys;
+}
+/**
+* True when the value is a readable schema declaring at least one field of any
+* kind. Lets a caller tell "this provider has no secrets" from "this provider's
+* schema could not be read", which are the same empty set otherwise.
+*/
+function schemaDeclaresAnyField(schema) {
+	for (const section of sectionsOf(schema)) if (fieldsOf(section).length > 0) return true;
+	return false;
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sectionsOf(schema) {
+	if (!isRecord$2(schema)) return [];
+	const sections = schema["sections"];
+	return Array.isArray(sections) ? sections : [];
+}
+function fieldsOf(node) {
+	if (!isRecord$2(node)) return [];
+	const fields = node["fields"];
+	return Array.isArray(fields) ? fields : [];
+}
+function walkField(field, out) {
+	if (!isRecord$2(field)) return;
+	const type = field["type"];
+	const key = field["key"];
+	if ((type === "password" || field["secret"] === true) && typeof key === "string" && key.length > 0) out.add(key);
+	if (type === "group") {
+		for (const child of fieldsOf(field)) walkField(child, out);
+		return;
+	}
+	if (type === "sub-tabs") {
+		const tabs = field["tabs"];
+		if (!Array.isArray(tabs)) return;
+		for (const tab of tabs) for (const child of fieldsOf(tab)) walkField(child, out);
+	}
+}
+//#endregion
 //#region src/interfaces/device-capabilities/camera.ts
 /** Friendly display labels for stream quality IDs. */
 var STREAM_QUALITY_LABELS = {
@@ -2189,6 +2252,21 @@ var RelocateJobSchema = zod.z.object({
 	bytesMoved: zod.z.number().int(),
 	/** Total files discovered up front; null while (or when) unknown. */
 	filesTotal: zod.z.number().int().nullable(),
+	/**
+	* Rows this run CORRECTED while moving them — a durable mutation the move
+	* made that nobody asked for, so it is reported where the operator reads the
+	* job rather than only in a log line.
+	*
+	* A footage segment records its byte count in its own NAME, and the durable
+	* hour row derives its aggregates from those names. A file that does not
+	* match its name therefore makes the ledger's sums — and with them quota and
+	* pressure eviction — wrong by the difference, and only a rename can fix it.
+	* On 2026-08-30 one such row also stalled a 110 749-file drain permanently.
+	*
+	* Absent on lanes where the question has no meaning: a media blob's size is
+	* in its row, not in its name, so `MediaRelocateEngine` never reconciles one.
+	*/
+	rowsReconciled: zod.z.number().int().nonnegative().optional(),
 	startedAt: zod.z.number(),
 	finishedAt: zod.z.number().nullable(),
 	error: zod.z.string().nullable()
@@ -2257,14 +2335,42 @@ var RelocateMediaInputSchema = zod.z.object({
 	/** 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()
+/**
+* The unstamped population of ONE collection — split, because the gate and the
+* operator ask two different questions and only one of them has to be cheap.
+*
+* `present` is the GATE: "is there at least one row that would be orphaned by a
+* repoint". It is a single indexed seek to the first matching row, so it stays
+* answerable on a saturated disk and answers in O(log n) precisely in the state
+* that matters — after a seal, when the population is empty.
+*
+* `rows` is the NUMBER, for the refusal message and the operator's sense of
+* scale. It is a second, indexed `COUNT(*)`, and `null` means **not
+* measurable** — never zero. `{ present: true, rows: null }` is a legitimate
+* and useful answer: "there are some, and this read could not say how many"
+* still refuses the cutover, which is the whole job.
+*/
+var UnstampedRowsSchema = zod.z.object({
+	present: zod.z.boolean(),
+	rows: zod.z.number().int().nonnegative().nullable()
 });
+/**
+* How many rows still carry NO `locationId` — the population a repoint would
+* silently re-aim at a disk that does not hold their bytes.
+*
+* **`null` = the count could not be taken**, and it is NOT permission to cut
+* over. The gate opens on a measured absence and on nothing else; an unread
+* collection and an empty one are different facts, and this repo has already
+* paid for conflating them (`RelocateResidueSchema`, D295).
+*/
+var UnstampedEventMediaCountSchema = zod.z.object({
+	media: UnstampedRowsSchema,
+	retrainFrames: UnstampedRowsSchema,
+	/** True when EITHER collection holds one. The refusal reads this. */
+	anyPresent: zod.z.boolean(),
+	/** Sum across both, or `null` when either lane could not be counted. */
+	total: zod.z.number().int().nonnegative().nullable()
+}).nullable();
 var StorageMigrationMediaMoveInputSchema = RelocateMediaInputSchema.extend({ leaseId: zod.z.string().min(1) });
 /** The independently selectable logical storage classes — every class
 * `storage.listLocationDeclarations` reports, so an operator never meets a
@@ -2350,13 +2456,53 @@ var StorageMigrationParticipantSchema = zod.z.enum([
 	"recorder",
 	"analytics"
 ]);
+/**
+* The mover's own numbers, folded onto the coordinator's durable move record.
+*
+* The long half of a non-blocking migration is `draining`, and it is measured
+* in hours: 136 885 files at ~4 MB/s is about five of them. Before this shape
+* existed the only place those numbers appeared was a Loki line, so an operator
+* watching the Admin UI saw `phase: draining` and nothing else for a whole
+* afternoon.
+*
+* It is POLLED, never pushed. Events are telemetry and may be dropped
+* (D8/D11), and a dropped progress event is indistinguishable from a stalled
+* mover — which is the exact failure this is meant to end. The coordinator's
+* `waitForMoves` already fetches the whole {@link RelocateJob} on every tick to
+* read `state`; folding the counters costs no extra read and makes the durable
+* record say afterwards how far a move actually got.
+*
+* `filesTotal` is `null` for "no honest denominator" and is never zero-filled:
+* a windowed footage job (`sinceMs`) and a node with no ledger both genuinely
+* cannot say M, and a 0 there would render as "100 % done".
+*/
+var StorageMigrationMoveProgressSchema = zod.z.object({
+	filesMoved: zod.z.number().int().nonnegative(),
+	/** The archive census — the **M** of "N of M" (D295). `null` = unknowable. */
+	filesTotal: zod.z.number().int().nonnegative().nullable(),
+	bytesMoved: zod.z.number().int().nonnegative(),
+	/** Rows the mover corrected while moving them — see `RelocateJob`. Absent on
+	*  a lane that cannot reconcile. A migration that silently rewrote durable
+	*  rows would be the same failure as one that silently skipped them. */
+	rowsReconciled: zod.z.number().int().nonnegative().optional(),
+	/** The MOVER's start, not the migration's: a drain restarted after an addon
+	*  crash gets a new mover, and a rate computed from the migration's start
+	*  would silently average in the time nothing was running. */
+	startedAt: zod.z.number(),
+	/** When the coordinator last read these numbers. Paired with `startedAt` it
+	*  is the only honest rate: both clocks are the hub's, so a UI never has to
+	*  subtract its own. */
+	observedAt: zod.z.number()
+});
 var StorageMigrationMoveSchema = zod.z.object({
 	storageClass: StorageMigrationClassSchema,
 	fromLocationId: zod.z.string(),
 	toLocationId: zod.z.string(),
 	moverJobId: zod.z.string().nullable(),
 	state: RelocateJobStateSchema.nullable(),
-	error: zod.z.string().nullable()
+	error: zod.z.string().nullable(),
+	/** Last observed mover counters; `null` until the mover has been polled once. */
+	progress: StorageMigrationMoveProgressSchema.nullable()
 });
 var StorageMigrationJobSchema = zod.z.object({
 	jobId: zod.z.string(),
@@ -2425,6 +2571,106 @@ var StorageMigrationPlanSchema = zod.z.object({
 	})),
 	findings: zod.z.array(StorageMigrationFindingSchema)
 });
+/**
+* Which single-flight engine owns a class of work.
+*
+* Shared rather than re-declared per consumer: the coordinator lanes its moves
+* by it, and `storageMigration.movers` labels a mover with it so an operator
+* can see *which* engine is busy when a drain refuses to start beside another.
+*/
+var StorageMigrationLaneSchema = zod.z.enum(["footage", "media"]);
+/**
+* A mover as it exists RIGHT NOW, whether or not a migration job owns it.
+*
+* The coordinator's job record is the state of record for a migration, and its
+* moves carry {@link StorageMigrationMoveProgress}. But the movers are usable
+* standalone — `recording.relocateFootage` and `pipelineAnalytics.relocateMedia`
+* are both operator-callable, and on 2026-08-29 a five-hour drain was armed that
+* way because no supported UI path existed. A mover armed like that has no job
+* to fold progress into, so it has to be readable on its own or it is invisible.
+*
+* `migrationJobId` is what tells the two apart: `null` means nothing here
+* orchestrated it.
+*/
+var StorageMigrationMoverSchema = zod.z.object({
+	lane: StorageMigrationLaneSchema,
+	job: RelocateJobSchema,
+	/** The coordinator job that armed this mover, or `null` for a mover armed
+	*  directly against the owning addon. */
+	migrationJobId: zod.z.string().nullable(),
+	/** When the hub read these counters. Stamped here so a rate is `bytesMoved`
+	*  over (`observedAt` − `job.startedAt`) with BOTH ends on the hub's clock —
+	*  a browser subtracting its own `Date.now()` from a server `startedAt` is a
+	*  rate made of two different clocks. */
+	observedAt: zod.z.number()
+});
+/**
+* What a SOURCE still holds for one storage class — the number that makes a
+* "drain remaining" action honest rather than hopeful.
+*
+* It comes from the archive (`SegmentHourLedger.census` for footage, the media
+* engine's own selection count for media), never from the resident index: a
+* drain sized off `RecordingIndex` is what reported `done` over 80.3 GB it had
+* never been told about (D295).
+*
+* `items`/`bytes` are `null` for "the archive could not be asked", which is
+* deliberately NOT zero: a drain is still offered for an unknown residue,
+* because refusing on an unanswerable read would hide exactly the case an
+* operator needs to act on.
+*/
+var StorageMigrationResidueSchema = zod.z.object({
+	storageClass: StorageMigrationClassSchema,
+	/** The location still holding the data. `'*'` for the media lane, whose rows
+	*  move from wherever they are rather than from one named source. */
+	fromLocationId: zod.z.string(),
+	/** Where a drain would move it — the class's CURRENT default. */
+	toLocationId: zod.z.string(),
+	/** Segments (footage lane) or rows (media lane) still on the source. */
+	items: zod.z.number().int().nonnegative().nullable(),
+	/** Bytes on the source; `null` when the lane counts rows rather than bytes. */
+	bytes: zod.z.number().int().nonnegative().nullable()
+});
+/**
+* Run the DRAIN half and nothing else.
+*
+* A migration that reached `done` has already repointed, so `start` correctly
+* refuses its destination ("already the default") — there is nothing left to
+* repoint. But the drain can fail, be cancelled, be interrupted by a restart,
+* or finish against a work list that was a tenth of the archive (D295), and
+* before this there was no supported way to run only that half: the only way
+* through was calling `recording.relocateFootage` by hand over admin tRPC.
+*
+* `drain` NEVER calls `setDefaultLocations`. That is what keeps `start`'s
+* refusal meaningful: the two verbs are disjoint, so nothing here can silently
+* re-repoint a class that is already migrated.
+*/
+var StorageMigrationDrainInputSchema = zod.z.object({
+	/** The classes to drain. Each must appear in `storageMigration.residue`, so
+	*  a class whose source is already empty is refused rather than started. */
+	classes: zod.z.array(StorageMigrationClassSchema).min(1),
+	throttleMbps: zod.z.number().min(1).max(1e3).optional()
+});
+/** What a footage source still holds, asked of the durable hour ledger. */
+var RelocateResidueInputSchema = zod.z.object({
+	fromLocationId: zod.z.string().min(1),
+	/** Narrow to one logical class; omit for every profile on the location. */
+	footageClass: RelocateFootageClassSchema.optional()
+});
+/** `null` = the archive could not answer (no ledger on this node, or the
+*  aggregate failed). Never conflated with an empty source. */
+var RelocateResidueSchema = zod.z.object({
+	segments: zod.z.number().int().nonnegative(),
+	bytes: zod.z.number().int().nonnegative()
+}).nullable();
+/** How many rows a media pass would still act on against a given target — the
+*  media lane's denominator AND its residue, from ONE derivation so the two can
+*  never disagree. `null` = the count could not be taken. */
+var RelocatableMediaCountSchema = zod.z.object({ rows: zod.z.number().int().nonnegative() }).nullable();
+var RelocatableMediaCountInputSchema = zod.z.object({
+	toLocationId: zod.z.string().min(1),
+	/** Omitted = `move`. */
+	mode: MediaRelocateModeSchema.optional()
+});
 //#endregion
 //#region src/interfaces/server-analysis.ts
 var SUB_DETECTION_TYPES = ["face", "plate"];
@@ -2542,6 +2788,38 @@ var StorageLocationRefSchema = zod.z.union([StorageLocationTypeSchema, zod.z.str
 *   two addons declaring the same `id` must agree on `cardinality` (validated
 *   at kernel aggregation time, not here).
 */
+/**
+* `StorageAccess` — how the service that DECLARED a storage-location kind
+* actually reaches the bytes. It is the constraint that decides which
+* `storage-provider`s may back a location of that kind.
+*
+* - `'local-path'` — the service asks `storage.resolve` for a path string and
+*   then does its own `node:fs` I/O on it (the recorder's segment writer, the
+*   post-analysis media roots). Only a provider that serves a genuine local
+*   filesystem (`getProviderInfo().nodeLocal === true`) can satisfy that: a
+*   remote provider's `resolve` returns a path on the REMOTE host, and
+*   `fs.readdir` of it on this node either fails or — far worse — succeeds
+*   against a same-named local directory that is something else entirely.
+*
+* - `'cap-mediated'` — every byte travels through the `storage` cap
+*   (`read`/`write`, or `beginUpload`/`writeChunk`/`finalizeUpload`). The
+*   service never sees a path, so any provider can back it. `backups` is the
+*   one kind that qualifies today.
+*
+* Before this existed, `recordings` was unreachable by SFTP/S3/WebDAV only as
+* an EMERGENT property of how the recorder happened to be written. Nothing
+* refused the configuration; the first write simply went somewhere wrong, and
+* a recording write that goes wrong surfaces as a silent black window rather
+* than an error (the read path does not `stat`). This turns that accident into
+* a declared, enforced, testable refusal.
+*/
+var StorageAccessSchema = zod.z.enum(["local-path", "cap-mediated"]);
+/**
+* What an ABSENT `access` means. Fail-closed: a declaration that says nothing
+* is treated as if it does raw filesystem I/O, so a remote provider is
+* refused for it. The permissive value must be written down.
+*/
+var STORAGE_ACCESS_FALLBACK = "local-path";
 var StorageLocationDeclarationSchema = zod.z.object({
 	/**
 	* Global location identifier, e.g. `recordings` or `recordingsLow`.
@@ -2561,6 +2839,19 @@ var StorageLocationDeclarationSchema = zod.z.object({
 	*/
 	cardinality: zod.z.enum(["single", "multi"]),
 	/**
+	* HOW the declaring service reaches the bytes — and therefore WHICH
+	* providers may back a location of this kind. See {@link StorageAccessSchema}
+	* and {@link STORAGE_ACCESS_FALLBACK}.
+	*
+	* Absent means `'local-path'`. That default is FAIL-CLOSED on purpose: it
+	* can only over-restrict (refuse a remote provider for a kind that might
+	* have coped) and never under-restrict. Declaring `'cap-mediated'` is the
+	* permissive direction and is therefore never inferred — a repo guard
+	* (`scripts/check-storage-access-declarations.ts`) refuses to let it be
+	* reached by omission.
+	*/
+	access: StorageAccessSchema.optional(),
+	/**
 	* When set, the default instance for this location inherits its resolved
 	* root from the named location's default instance. Useful for derivative
 	* slots (e.g. `recordingsLow` → `recordings`) so operators only need to
@@ -10272,6 +10563,15 @@ var deviceManagerCapability = {
 		* calls are sync. Bindings change rarely (only on wrapper toggle or
 		* device add/remove) — clients invalidate via the
 		* `capability.binding-changed` event.
+		*
+		* "A single round-trip" describes the CLIENT's side and used not to
+		* describe the server's: until 2026-08-30 the resolver read the persisted
+		* wrapper activations once per device, so answering this cost one
+		* settings-door RPC per device — 1 020 on the live 1 019-device hub, and
+		* it did not return in 240 s against `SystemMirror.init`'s 15 s budget.
+		* The server side is now two reads for the whole fleet. Anything PERIODIC
+		* still belongs on `getBindings` / `getBindingsBatch` (D12); this remains
+		* a warm seed.
 		*/
 		getAllBindings: require_sleep.method(zod.z.object({}), zod.z.array(DeviceBindingsForDeviceSchema)),
 		/**
@@ -17671,8 +17971,10 @@ var TrackSchema = zod.z.object({
 	lastSeen: zod.z.number(),
 	/** Frame-rate position history (subject to maxPositionHistory cap). */
 	positions: zod.z.array(TrackPositionSchema).readonly(),
-	/** Periodic snapshots at snapshotIntervalMs cadence (subject to
-	*  saveThumbnails policy). */
+	/** Periodic snapshots at snapshotIntervalMs cadence — DEBUG media, produced
+	*  only while `MediaSettings.debugMediaEnabled` is on for the camera (D299;
+	*  the retired `saveThumbnails` used to gate this and the rolling
+	*  `lastFrame` together). Empty is the healthy default, not a capture gap. */
 	snapshots: zod.z.array(TrackSnapshotSchema).readonly(),
 	/** Deduplicated zones the track has entered at least once. Zone IDS. */
 	zonesVisited: zod.z.array(zod.z.string()).readonly(),
@@ -18762,8 +19064,34 @@ var pipelineAnalyticsCapability = {
 		* 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.
+		*
+		* TWO indexed statements per collection, not a walk. It used to page the
+		* whole collection at 200 rows per RPC ordered by an unindexed column, so
+		* on the live hub — 1 254 576 rows — it hit the 60 s RPC deadline every
+		* time it was called, and the migration it gates could never start. The
+		* cheap question (`present`: is there at least one) is asked first and
+		* separately from the expensive one (`rows`), because only the first has
+		* to be answerable for the gate to do its job.
+		*
+		* **`null` is "not measurable", never zero** — at either level. An
+		* unreadable collection must not read as a sealed one.
 		*/
 		countUnstampedEventMedia: require_sleep.method(zod.z.object({}), UnstampedEventMediaCountSchema, { auth: "admin" }),
+		/**
+		* How many rows a pass would STILL act on against `toLocationId`.
+		*
+		* One derivation, two consumers: it is the media lane's denominator (the
+		* **M** the footage lane gets from the ledger census — D295) and it is the
+		* residue behind "drain remaining". Deriving them separately is how "N of M"
+		* ends up comparing two different populations.
+		*
+		* `null` means the count could not be taken; it is never zero-filled,
+		* because a zero here reads as "nothing left to move".
+		*/
+		countRelocatableMedia: require_sleep.method(RelocatableMediaCountInputSchema, RelocatableMediaCountSchema, {
+			kind: "query",
+			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: require_sleep.method(zod.z.object({}), zod.z.array(RelocateJobSchema).readonly(), {
@@ -21946,6 +22274,35 @@ var storageMigrationCapability = {
 		cancel: require_sleep.method(zod.z.object({ jobId: zod.z.string() }), zod.z.object({ cancelled: zod.z.boolean() }), {
 			kind: "mutation",
 			auth: "admin"
+		}),
+		/**
+		* Every mover running RIGHT NOW, in both lanes, with its counters.
+		*
+		* `status` covers a migration's own moves — the coordinator folds their
+		* progress onto the durable job record it is already polling. This covers
+		* the other case, and it is not hypothetical: a drain armed straight against
+		* `recording.relocateFootage` (the only path that existed before
+		* {@link drain}) has no job to fold into and would otherwise be invisible.
+		*/
+		movers: require_sleep.method(zod.z.object({}), zod.z.array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }),
+		/**
+		* What each class's SOURCE still holds, from the archive — never from the
+		* resident index (D295). Only classes with something left (or something
+		* unknown) are listed, so an empty list means there is nothing to drain and
+		* the UI has no honest button to offer.
+		*/
+		residue: require_sleep.method(zod.z.object({}), zod.z.array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }),
+		/**
+		* Run the drain half alone, on a class whose default has ALREADY moved.
+		*
+		* It never repoints anything, which is what lets `start` keep refusing a
+		* destination that is already the default: the two verbs cannot be confused
+		* for one another, and no operator can re-repoint a migrated class through
+		* this door.
+		*/
+		drain: require_sleep.method(StorageMigrationDrainInputSchema, zod.z.object({ jobId: zod.z.string() }), {
+			kind: "mutation",
+			auth: "admin"
 		})
 	}
 };
@@ -22518,12 +22875,38 @@ response: zod.z.record(zod.z.string(), zod.z.unknown()) }), zod.z.object({
 *
 * ## Why this is a capability and not a helper
 *
-* Six stores in `addon-post-analysis` already hold vectors — object CLIP, face,
-* plate, vehicle, identity, and the event store's derivatives — and every one of
-* them keeps its vectors in a `JSON` settings-store column and ranks them by
-* brute-force cosine in JS. Measured on the live hub that costs ~11.7 KB per row
-* (512 floats as TEXT, `JSON.parse`d on every search) and made semantic search
-* load 5,000 rows before ranking anything.
+* This capability was introduced with the claim that SIX stores in
+* `addon-post-analysis` held vectors in a `JSON` settings-store column — object
+* CLIP, face, plate, vehicle, identity, and the event store's derivatives. That
+* claim was never true, and leaving it here made five stores look like pending
+* work when three of them have no vector at all. Counted column by column on
+* 2026-08-30, exactly THREE ever held one:
+*
+*  - `object-clip`      — 512-dim CLIP image embedding, migrated 2026-08-06.
+*  - `faces.embedding`  — 512-dim ArcFace face embedding, migrated 2026-08-30.
+*  - `identity-samples.embedding` — the same ArcFace vector for an ENROLLED
+*    face, migrated 2026-08-30 into its OWN index (see below).
+*
+* `plates` and `vehicle-samples` store a plate STRING and a score; `vehicles`
+* and `identities` store a name; the event store stores no derivative vector.
+* They are not migration candidates and never were.
+*
+* Measured on the live hub the JSON encoding cost ~11.7 KB per row (512 floats
+* as TEXT, `JSON.parse`d on every search) and made semantic search load 5,000
+* rows before ranking anything.
+*
+* ## One index per COMPARISON, never per encoder
+*
+* `faces` and `identity-samples` hold the same 512 ArcFace dims from the same
+* model, and they still get two indexes. An index is a set of things that are
+* ranked against each other and that live and die together, and these two are
+* neither: a `faces` row is TRACK-OWNED and cascades away with its track under
+* a per-camera capacity cap, an `identity-samples` row is retention-EXEMPT
+* forever and is the gallery every recognition ranks against. One index would
+* mean every gallery load and every reconcile carried a filter whose failure
+* mode is either ranking a candidate against itself or reclaiming an enrolled
+* person's only sample. The dimension they share is not a reason to share an
+* index; the question they answer is, and it differs.
 *
 * The fix is not a faster loop, it is a different backend — and the backend
 * should be replaceable without touching six callers. So: a singleton
@@ -22628,7 +23011,20 @@ var VectorQueryResultSchema = zod.z.object({
 	*/
 	scanned: zod.z.number(),
 	/** True when the backend could not consider every row that passed the filter. */
-	truncated: zod.z.boolean()
+	truncated: zod.z.boolean(),
+	/**
+	* The `topK` the backend actually ran with.
+	*
+	* Every backend has a ceiling — sqlite-vec's is 4,096 — and a caller asking
+	* past it used to learn nothing but a boolean, from a WARN in the provider's
+	* own log rather than in its answer. That is how an audit asking for 20,000
+	* consumed 4,096 and reported `examined: 4096` as if it had walked the index,
+	* for weeks. `truncated` says THAT the answer was short; this says BY HOW
+	* MUCH, in the return value, where the caller cannot fail to see it.
+	*
+	* Equals the requested `topK` whenever nothing was lowered.
+	*/
+	effectiveTopK: zod.z.number().int().positive()
 });
 var VectorDeleteInputSchema = zod.z.object({
 	index: zod.z.string(),
@@ -22657,6 +23053,68 @@ var VectorGetResultSchema = zod.z.object({ items: zod.z.array(zod.z.object({
 	id: zod.z.string(),
 	metadata: VectorMetadataSchema
 })) });
+/**
+* Ids to read back WITH their vectors.
+*
+* The sibling of {@link VectorGetResultSchema}, and deliberately a separate
+* method rather than a flag on it: `getByIds` promises no vectors and its one
+* caller depends on that promise. This one promises the opposite.
+*
+* It exists because a store cannot put its vectors here otherwise. An ArcFace
+* gallery is ranked IN PROCESS, per detection, against every enrolled sample —
+* a per-face cross-process KNN would be a network round trip inside the
+* recognition loop. So the gallery is loaded once and held in RAM, and loading
+* it requires the index to hand the floats back. Without this method the only
+* way to keep a readable vector is a JSON column, which is the thing this
+* capability exists to delete.
+*
+* BOUNDED BY THE CALLER: ids are named, never "everything". Enumerating an
+* index is {@link VectorScanInputSchema}'s job, and it returns no vectors.
+*/
+var VectorFetchInputSchema = zod.z.object({
+	index: zod.z.string(),
+	ids: zod.z.array(zod.z.string())
+});
+var VectorFetchResultSchema = zod.z.object({ items: zod.z.array(zod.z.object({
+	id: zod.z.string(),
+	/** base64 Float32LE — the same wire form `upsert` accepts. */
+	vector: zod.z.string(),
+	metadata: VectorMetadataSchema
+})) });
+/**
+* ENUMERATE an index: one page of rows in a stable order, no ranking.
+*
+* A reconcile does not want the nearest rows, it wants ALL of them, and asking
+* a KNN for "all" is the wrong question twice over. It hits the backend's `k`
+* ceiling — 4,096 on sqlite-vec against a 22,128-row index — and it needs a
+* probe vector it does not have, so the audit passed a ZERO vector whose cosine
+* distance to every row is degenerate. `examined: 4096` then read as "we
+* looked" for as long as anyone cared to read it.
+*
+* This is the primitive that question actually needs: a bounded page, ordered
+* by the backend's own row order, costing no distance computation at all.
+* Vectors are NOT returned — an enumeration that shipped 2 KB per row would be
+* the full-table read this capability was built to stop.
+*/
+var VectorScanInputSchema = zod.z.object({
+	index: zod.z.string(),
+	/** Opaque resume point. `0` starts at the top; pass back `nextCursor`. */
+	cursor: zod.z.number().int().nonnegative().default(0),
+	limit: zod.z.number().int().positive()
+});
+var VectorScanResultSchema = zod.z.object({
+	items: zod.z.array(zod.z.object({
+		id: zod.z.string(),
+		metadata: VectorMetadataSchema
+	})),
+	/**
+	* Where the next page starts, or `null` when the walk reached the end.
+	*
+	* `null` is the ONLY end-of-index signal. A caller must not infer the end
+	* from a short page: a backend is free to return fewer rows than asked.
+	*/
+	nextCursor: zod.z.number().int().nonnegative().nullable()
+});
 var VectorStatsInputSchema = zod.z.object({ index: zod.z.string() });
 var VectorStatsResultSchema = zod.z.object({
 	/** Provider id, so an operator can tell brute force from an ANN index. */
@@ -22695,6 +23153,10 @@ var vectorStoreCapability = {
 		query: require_sleep.method(VectorQueryInputSchema, VectorQueryResultSchema, { auth: "admin" }),
 		/** Metadata by id, no vectors — see {@link VectorGetResultSchema}. */
 		getByIds: require_sleep.method(VectorGetInputSchema, VectorGetResultSchema, { auth: "admin" }),
+		/** Metadata AND vectors, by named id — see {@link VectorFetchInputSchema}. */
+		fetchByIds: require_sleep.method(VectorFetchInputSchema, VectorFetchResultSchema, { auth: "admin" }),
+		/** One page of the whole index, unranked — see {@link VectorScanInputSchema}. */
+		scan: require_sleep.method(VectorScanInputSchema, VectorScanResultSchema, { auth: "admin" }),
 		deleteByIds: require_sleep.method(VectorDeleteInputSchema, VectorDeleteResultSchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -30657,6 +31119,20 @@ var recordingCapability = {
 			kind: "query",
 			auth: "admin"
 		}),
+		/**
+		* What a location STILL holds, asked of the durable hour ledger.
+		*
+		* The number behind "drain remaining": segments and bytes that would still
+		* have to move off `fromLocationId`. It is a ledger aggregate — the archive
+		* — because the resident index is not the archive (D295), and a drain sized
+		* off the index is exactly what reported `done` over 80.3 GB on 2026-08-29.
+		* `null` means the archive could not be asked (no ledger on this node, or
+		* the aggregate failed) and is never conflated with an empty source.
+		*/
+		getRelocateResidue: require_sleep.method(RelocateResidueInputSchema, RelocateResidueSchema, {
+			kind: "query",
+			auth: "admin"
+		}),
 		/** Cancel a running or queued relocate job. A queued job never runs. */
 		cancelRelocateJob: require_sleep.method(zod.z.object({ jobId: zod.z.string() }), zod.z.object({ cancelled: zod.z.boolean() }), {
 			kind: "mutation",
@@ -40890,6 +41366,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.countRelocatableMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.countUnstampedEventMedia": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -42054,6 +42536,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.getRelocateResidue": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"recording.getStorageMigrationMoveStatus": {
 		capName: "recording",
 		capScope: "system",
@@ -42600,12 +43088,30 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"storageMigration.drain": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"storageMigration.movers": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageMigration.plan": {
 		capName: "storage-migration",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
+	"storageMigration.residue": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageMigration.start": {
 		capName: "storage-migration",
 		capScope: "system",
@@ -43440,6 +43946,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"vectorStore.fetchByIds": {
+		capName: "vector-store",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"vectorStore.getByIds": {
 		capName: "vector-store",
 		capScope: "system",
@@ -43452,6 +43964,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"vectorStore.scan": {
+		capName: "vector-store",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"vectorStore.stats": {
 		capName: "vector-store",
 		capScope: "system",
@@ -46678,6 +47196,7 @@ function createSystemProxy(api) {
 			cancelStorageMigrationMove: (input) => dispatch("recording", "cancelStorageMigrationMove", "mutation", input),
 			relocateFootage: (input) => dispatch("recording", "relocateFootage", "mutation", input),
 			listRelocateJobs: (input) => dispatch("recording", "listRelocateJobs", "query", input),
+			getRelocateResidue: (input) => dispatch("recording", "getRelocateResidue", "query", input),
 			cancelRelocateJob: (input) => dispatch("recording", "cancelRelocateJob", "mutation", input),
 			planStorageRebalance: (input) => dispatch("recording", "planStorageRebalance", "query", input),
 			startStorageRebalance: (input) => dispatch("recording", "startStorageRebalance", "mutation", input)
@@ -46741,7 +47260,10 @@ function createSystemProxy(api) {
 			plan: (input) => dispatch("storageMigration", "plan", "query", input),
 			start: (input) => dispatch("storageMigration", "start", "mutation", input),
 			status: (input) => dispatch("storageMigration", "status", "query", input),
-			cancel: (input) => dispatch("storageMigration", "cancel", "mutation", input)
+			cancel: (input) => dispatch("storageMigration", "cancel", "mutation", input),
+			movers: (input) => dispatch("storageMigration", "movers", "query", input),
+			residue: (input) => dispatch("storageMigration", "residue", "query", input),
+			drain: (input) => dispatch("storageMigration", "drain", "mutation", input)
 		},
 		streamBroker: {
 			fetchEventMedia: (input) => dispatch("streamBroker", "fetchEventMedia", "mutation", input),
@@ -51485,6 +52007,7 @@ exports.REACHABILITY_POLL_INTERVAL_MS = REACHABILITY_POLL_INTERVAL_MS;
 exports.REACHABILITY_PROBE_TIMEOUT_MS = REACHABILITY_PROBE_TIMEOUT_MS;
 exports.RECOGNITION_TYPES = RECOGNITION_TYPES;
 exports.RECORDING_EXPORT_MAX_READ_BYTES = RECORDING_EXPORT_MAX_READ_BYTES;
+exports.REDACTED_SECRET = REDACTED_SECRET;
 exports.RESERVED_BINDING_NAMES = RESERVED_BINDING_NAMES;
 exports.RESTORED_CAP_NAMES = RESTORED_CAP_NAMES;
 exports.ROOT_BUCKET_KEY = ROOT_BUCKET_KEY;
@@ -51523,11 +52046,15 @@ exports.RecordingStorageUsageSchema = RecordingStorageUsageSchema;
 exports.RecordingTriggersSchema = RecordingTriggersSchema;
 exports.RecordingWeekdaySchema = RecordingWeekdaySchema;
 exports.RedirectLoginMethodSchema = RedirectLoginMethodSchema;
+exports.RelocatableMediaCountInputSchema = RelocatableMediaCountInputSchema;
+exports.RelocatableMediaCountSchema = RelocatableMediaCountSchema;
 exports.RelocateFootageClassSchema = RelocateFootageClassSchema;
 exports.RelocateFootageInputSchema = RelocateFootageInputSchema;
 exports.RelocateJobSchema = RelocateJobSchema;
 exports.RelocateJobStateSchema = RelocateJobStateSchema;
 exports.RelocateMediaInputSchema = RelocateMediaInputSchema;
+exports.RelocateResidueInputSchema = RelocateResidueInputSchema;
+exports.RelocateResidueSchema = RelocateResidueSchema;
 exports.RenderedAsSchema = RenderedAsSchema;
 exports.ReportMotionInputSchema = ReportMotionInputSchema;
 exports.ReportedFailureContributionSchema = ReportedFailureContributionSchema;
@@ -51578,6 +52105,7 @@ exports.SOURCE_CAP_ACTIVE_FIELD = SOURCE_CAP_ACTIVE_FIELD;
 exports.SOURCE_CAP_CHANGED_AT_FIELD = SOURCE_CAP_CHANGED_AT_FIELD;
 exports.SOURCE_DEVICE_TYPES = SOURCE_DEVICE_TYPES;
 exports.SOURCE_INFO_METADATA_KEY = SOURCE_INFO_METADATA_KEY;
+exports.STORAGE_ACCESS_FALLBACK = STORAGE_ACCESS_FALLBACK;
 exports.STREAM_PROFILE_META = STREAM_PROFILE_META;
 exports.STREAM_QUALITY_LABELS = STREAM_QUALITY_LABELS;
 exports.SUB_DETECTION_TYPES = SUB_DETECTION_TYPES;
@@ -51627,6 +52155,7 @@ exports.SsoBridgeClaimsSchema = SsoBridgeClaimsSchema;
 exports.StartEmbeddedInputSchema = StartEmbeddedInputSchema;
 exports.StationaryObjectSchema = StationaryObjectSchema;
 exports.StorageAbortUploadInputSchema = AbortUploadInputSchema;
+exports.StorageAccessSchema = StorageAccessSchema;
 exports.StorageBeginDownloadInputSchema = BeginDownloadInputSchema;
 exports.StorageBeginDownloadResultSchema = BeginDownloadResultSchema;
 exports.StorageBeginUploadInputSchema = BeginUploadInputSchema;
@@ -51639,18 +52168,23 @@ exports.StorageLocationSchema = StorageLocationSchema;
 exports.StorageLocationTypeSchema = StorageLocationTypeSchema;
 exports.StorageMigrationClassSchema = StorageMigrationClassSchema;
 exports.StorageMigrationDestinationsSchema = StorageMigrationDestinationsSchema;
+exports.StorageMigrationDrainInputSchema = StorageMigrationDrainInputSchema;
 exports.StorageMigrationFindingCodeSchema = StorageMigrationFindingCodeSchema;
 exports.StorageMigrationFindingSchema = StorageMigrationFindingSchema;
 exports.StorageMigrationFootageMoveInputSchema = StorageMigrationFootageMoveInputSchema;
 exports.StorageMigrationInputSchema = StorageMigrationInputSchema;
 exports.StorageMigrationJobSchema = StorageMigrationJobSchema;
+exports.StorageMigrationLaneSchema = StorageMigrationLaneSchema;
 exports.StorageMigrationLeaseInputSchema = StorageMigrationLeaseInputSchema;
 exports.StorageMigrationMediaMoveInputSchema = StorageMigrationMediaMoveInputSchema;
 exports.StorageMigrationModeSchema = StorageMigrationModeSchema;
+exports.StorageMigrationMoveProgressSchema = StorageMigrationMoveProgressSchema;
 exports.StorageMigrationMoveSchema = StorageMigrationMoveSchema;
+exports.StorageMigrationMoverSchema = StorageMigrationMoverSchema;
 exports.StorageMigrationParticipantSchema = StorageMigrationParticipantSchema;
 exports.StorageMigrationPhaseSchema = StorageMigrationPhaseSchema;
 exports.StorageMigrationPlanSchema = StorageMigrationPlanSchema;
+exports.StorageMigrationResidueSchema = StorageMigrationResidueSchema;
 exports.StorageProviderInfoSchema = ProviderInfoSchema;
 exports.StorageReadChunkInputSchema = ReadChunkInputSchema;
 exports.StorageTestLocationResultSchema = TestLocationResultSchema;
@@ -51723,6 +52257,7 @@ exports.UNIT_TABLE = UNIT_TABLE;
 exports.UnifiedBrokerInfoSchema = BrokerInfoSchema$1;
 exports.UnitConversionError = UnitConversionError;
 exports.UnstampedEventMediaCountSchema = UnstampedEventMediaCountSchema;
+exports.UnstampedRowsSchema = UnstampedRowsSchema;
 exports.UpdateIntegrationInputSchema = UpdateIntegrationInputSchema;
 exports.UpdateStatusSchema = UpdateStatusSchema;
 exports.UpdateUserInputSchema = UpdateUserInputSchema;
@@ -51844,6 +52379,7 @@ exports.clusterStepSettingFieldsFor = clusterStepSettingFieldsFor;
 exports.clusterStepSettingKey = clusterStepSettingKey;
 exports.collectHydratedFieldEntries = require_sleep.collectHydratedFieldEntries;
 exports.collectHydratedFieldValues = require_sleep.collectHydratedFieldValues;
+exports.collectSecretConfigKeys = collectSecretConfigKeys;
 exports.colorCapability = colorCapability;
 exports.colorForKind = colorForKind;
 exports.commitWatchdogRestart = commitWatchdogRestart;
@@ -51984,6 +52520,7 @@ exports.isOccupancyRule = isOccupancyRule;
 exports.isRestoredCap = isRestoredCap;
 exports.isSameAddonId = isSameAddonId;
 exports.isScheduleActive = isScheduleActive;
+exports.isSecretConfigField = isSecretConfigField;
 exports.isSoftwareDecode = require_canonical_hash.isSoftwareDecode;
 exports.isSourceCap = isSourceCap;
 exports.isSystemDelivery = isSystemDelivery;
@@ -52131,6 +52668,7 @@ exports.runInferenceStep = runInferenceStep;
 exports.runtimeDevices = runtimeDevices;
 exports.runtimeStatePolicyFor = runtimeStatePolicyFor;
 exports.sceneMonitorCapability = sceneMonitorCapability;
+exports.schemaDeclaresAnyField = schemaDeclaresAnyField;
 exports.scopeInherits = scopeInherits;
 exports.scopeKey = require_sleep.scopeKey;
 exports.scopesAllowAddon = scopesAllowAddon;