@camstack/system 1.2.157 → 1.2.159

package/dist/{dist-CDgIzo82.js → dist-Ck2jkBZk.js}

@@ -3682,6 +3682,53 @@ var CameraSwitchGroupSchema = zod.z.object({
 	/** Unix ms when the group was composed server-side. */
 	fetchedAt: zod.z.number()
 });
+/**
+* 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__";
+/**
+* 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;
+}
+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);
+	}
+}
 /** Friendly display labels for stream quality IDs. */
 var STREAM_QUALITY_LABELS = {
 	high: "High",
@@ -4291,13 +4338,49 @@ 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(),
+	/** 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(),
@@ -4367,6 +4450,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()
+});
+/**
 * `StorageLocationType` — an addon-declared id that identifies the *kind* of
 * storage a location serves. Defined here (not in `capabilities/storage.cap.ts`)
 * so the persisted record schema and the consumer-facing cap can both consume it
@@ -4470,6 +4653,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`.
@@ -4489,6 +4704,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
@@ -16908,8 +17136,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(),
@@ -18001,6 +18231,21 @@ var pipelineAnalyticsCapability = {
 		* it to zero.
 		*/
 		countUnstampedEventMedia: 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: 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: method(zod.z.object({}), zod.z.array(RelocateJobSchema).readonly(), {
@@ -20958,6 +21203,35 @@ var storageMigrationCapability = {
 		cancel: 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: 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: 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: method(StorageMigrationDrainInputSchema, zod.z.object({ jobId: zod.z.string() }), {
+			kind: "mutation",
+			auth: "admin"
 		})
 	}
 };
@@ -21520,12 +21794,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
@@ -21630,7 +21930,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(),
@@ -21659,6 +21972,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. */
@@ -21697,6 +22072,10 @@ var vectorStoreCapability = {
 		query: method(VectorQueryInputSchema, VectorQueryResultSchema, { auth: "admin" }),
 		/** Metadata by id, no vectors — see {@link VectorGetResultSchema}. */
 		getByIds: method(VectorGetInputSchema, VectorGetResultSchema, { auth: "admin" }),
+		/** Metadata AND vectors, by named id — see {@link VectorFetchInputSchema}. */
+		fetchByIds: method(VectorFetchInputSchema, VectorFetchResultSchema, { auth: "admin" }),
+		/** One page of the whole index, unranked — see {@link VectorScanInputSchema}. */
+		scan: method(VectorScanInputSchema, VectorScanResultSchema, { auth: "admin" }),
 		deleteByIds: method(VectorDeleteInputSchema, VectorDeleteResultSchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -29398,6 +29777,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: method(RelocateResidueInputSchema, RelocateResidueSchema, {
+			kind: "query",
+			auth: "admin"
+		}),
 		/** Cancel a running or queued relocate job. A queued job never runs. */
 		cancelRelocateJob: method(zod.z.object({ jobId: zod.z.string() }), zod.z.object({ cancelled: zod.z.boolean() }), {
 			kind: "mutation",
@@ -36222,6 +36615,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",
@@ -37386,6 +37785,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",
@@ -37932,12 +38337,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",
@@ -38772,6 +39195,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",
@@ -38784,6 +39213,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",
@@ -41770,6 +42205,12 @@ Object.defineProperty(exports, "METHOD_ACCESS_MAP", {
 		return METHOD_ACCESS_MAP;
 	}
 });
+Object.defineProperty(exports, "REDACTED_SECRET", {
+	enumerable: true,
+	get: function() {
+		return REDACTED_SECRET;
+	}
+});
 Object.defineProperty(exports, "RUNTIME_DEFAULTS", {
 	enumerable: true,
 	get: function() {
@@ -41800,6 +42241,12 @@ Object.defineProperty(exports, "SOURCE_DEVICE_TYPES", {
 		return SOURCE_DEVICE_TYPES;
 	}
 });
+Object.defineProperty(exports, "STORAGE_ACCESS_FALLBACK", {
+	enumerable: true,
+	get: function() {
+		return STORAGE_ACCESS_FALLBACK;
+	}
+});
 Object.defineProperty(exports, "STREAM_PROFILE_META", {
 	enumerable: true,
 	get: function() {
@@ -41908,6 +42355,12 @@ Object.defineProperty(exports, "buildStreamParamsConfigSchema", {
 		return buildStreamParamsConfigSchema;
 	}
 });
+Object.defineProperty(exports, "collectSecretConfigKeys", {
+	enumerable: true,
+	get: function() {
+		return collectSecretConfigKeys;
+	}
+});
 Object.defineProperty(exports, "coreBlockAddonId", {
 	enumerable: true,
 	get: function() {