@camstack/addon-osd-manager 0.1.21 → 0.1.22

package/dist/index.mjs

@@ -6629,7 +6629,7 @@ function method(input, output, options) {
 		input,
 		output,
 		kind: options?.kind ?? "query",
-		auth: options?.auth ?? "protected",
+		...options?.auth !== void 0 ? { auth: options.auth } : {},
 		...options?.access !== void 0 ? { access: options.access } : {},
 		...options?.caller !== void 0 ? { caller: options.caller } : {},
 		timeoutMs: options?.timeoutMs
@@ -6659,8 +6659,17 @@ var adminUiCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
-		getStaticDir: method(_void(), StaticDirOutputSchema$1),
-		getVersion: method(_void(), VersionOutputSchema$1)
+		/**
+		* `internal: true` did not gate the mount (see the 2026-08-26 note on
+		* `data-store-provider`) — both methods were reachable on the AppRouter
+		* by ANY authenticated session at the default `auth: 'protected'`, and
+		* `getStaticDir` leaks a hub filesystem path. The only caller is
+		* `main.ts`'s static-file bootstrap, via `capRegistry.getSingletonForNode`
+		* — never tRPC — so `auth: 'admin'` costs it nothing. The actual admin-ui
+		* SPA assets are served as plain static files, unaffected by this gate.
+		*/
+		getStaticDir: method(_void(), StaticDirOutputSchema$1, { auth: "admin" }),
+		getVersion: method(_void(), VersionOutputSchema$1, { auth: "admin" })
 	}
 };
 var DeviceType = /* @__PURE__ */ function(DeviceType) {
@@ -6996,8 +7005,23 @@ var viewerUiCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
-		getStaticDir: method(_void(), StaticDirOutputSchema),
-		getVersion: method(_void(), VersionOutputSchema)
+		/**
+		* `internal: true` did not gate the mount (see the 2026-08-26 note on
+		* `data-store-provider`) — both methods were reachable on the AppRouter
+		* by ANY authenticated session at the default `auth: 'protected'`, and
+		* `getStaticDir` leaks a hub filesystem path.
+		*
+		* ⚠ Checked before gating: the VIEWER app IS used by a non-admin user
+		* (`roberta`), but it never calls `viewerUi.*` over tRPC. The static SPA
+		* it loads is served by the plain `GET /viewer/*` Fastify route in
+		* `main.ts`, which reads `staticDir`/`indexPath` from a module-level
+		* cache populated ONCE at boot via `capRegistry.getSingletonForNode`
+		* (in-process, not tRPC) — the cap's tRPC procedure is never on that
+		* request path. `auth: 'admin'` here does not block a single viewer
+		* user from loading the app.
+		*/
+		getStaticDir: method(_void(), StaticDirOutputSchema, { auth: "admin" }),
+		getVersion: method(_void(), VersionOutputSchema, { auth: "admin" })
 	}
 };
 /**
@@ -7672,24 +7696,6 @@ var RecordingRetentionSchema = object({
 	maxSizeGb: number().min(0).optional()
 });
 /**
-* Scrub-thumbnail fidelity preset — the single per-camera selector bundling the
-* sprite tile RESOLUTION + JPEG QUALITY the recorder packs timeline-scrub
-* previews at. Five graduated steps; absent on a config = `standard` (the
-* shipped default, matching `sheet-geometry`/`sheet-composer`).
-*
-* Existing sheets are IMMUTABLE — a changed preset applies to NEW windows only.
-* Each window's index sidecar carries its own tile dims, so a camera whose
-* preset changed over time renders every historical window at the dims it was
-* written with.
-*/
-var ScrubThumbnailPresetSchema = _enum([
-	"minimal",
-	"low",
-	"standard",
-	"high",
-	"max"
-]);
-/**
 * The full per-camera recording intent — the wire shape of a RecordingTarget.
 *
 * `bands` is the ONLY authored recording intent: what to record, when, and on
@@ -7697,7 +7703,11 @@ var ScrubThumbnailPresetSchema = _enum([
 * other field is a storage knob (profiles, segment length, retention, scrub).
 *
 * STRICT on purpose: the legacy authoring surface (`schedule`/`schedules`/
-* `triggers`/`preBufferSec`/`postBufferSec`/`rules`) was retired 2026-07-30.
+* `triggers`/`preBufferSec`/`postBufferSec`/`rules`) was retired 2026-07-30,
+* and `scrubThumbnails` — a five-step fidelity knob for a sprite tier that was
+* deleted on 2026-07-24 and had ZERO consumers in the recorder — on 2026-08-25
+* (D62: a switch that writes a store nobody reads is worse than no switch).
+* Stored rows keep loading: the READ schema is `.strip()` (config-store.ts).
 * A stale caller must fail loudly — silently stripping its legacy intent would
 * persist a band-less config, i.e. silently stop recording the camera.
 */
@@ -7720,14 +7730,7 @@ var RecordingConfigSchema = object({
 	* "off" is the absence of a covering band, never a band value.
 	*/
 	bands: array(RecordingBandSchema).default([]),
-	retention: RecordingRetentionSchema.optional(),
-	/**
-	* Per-camera scrub-thumbnail fidelity preset (resolution + JPEG quality for
-	* timeline-scrub sprite previews). Absent = `standard`. Applies to NEW
-	* windows only — existing sheets are immutable, and each window's index
-	* carries its own tile dims so mixed-preset history renders correctly.
-	*/
-	scrubThumbnails: ScrubThumbnailPresetSchema.optional()
+	retention: RecordingRetentionSchema.optional()
 }).strict();
 /**
 * Entity-relocation job state (storage entity-routing spec, Phase 4).
@@ -7803,10 +7806,11 @@ var RelocateFootageInputSchema = object({
 * `RecordingConfig.enabled` or camera wrapper bindings. */
 var StorageMigrationLeaseInputSchema = object({ leaseId: string().min(1) });
 var StorageMigrationFootageMoveInputSchema = RelocateFootageInputSchema.extend({ leaseId: string().min(1) });
-var StorageMigrationMediaMoveInputSchema = object({
+var RelocateMediaInputSchema = object({
 	toLocationId: string(),
 	throttleMbps: number().min(1).max(1e3).optional()
-}).extend({ leaseId: string().min(1) });
+});
+var StorageMigrationMediaMoveInputSchema = RelocateMediaInputSchema.extend({ leaseId: 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. */
@@ -8101,7 +8105,26 @@ var LabelDefinitionSchema = object({
 	description: string().optional(),
 	icon: string().optional()
 });
-var ClassMapDefinitionSchema = object({
+/**
+* Wire schema for a per-model CATALOG classMap override
+* (`ModelCatalogEntry.classMap` / `ModelConvertMetadata.classMap`) —
+* restricted to {@link CLASS_MAP_MACRO_TARGETS}, the only macros the
+* detection pipeline executor actually routes.
+*
+* This is deliberately a DIFFERENT, narrower shape than the general-purpose
+* `ClassMapDefinition` interface above (e.g. `IDetectionAddon.getClassMap()`
+* and the audio `YAMNET_TO_MACRO` catalog both use macro targets outside this
+* enum) — the two used to share the name `ClassMapDefinition`/
+* `ClassMapDefinitionSchema`, which made the schema-type-twin guard
+* (`scripts/check-schema-type-twins.ts`) flag them as a duplicated shape. They
+* are not: it is two different concepts colliding on a name. Keep this type
+* under its own name rather than reusing `ClassMapDefinition` — reusing it
+* would either narrow every `ClassMapDefinition` consumer to the four
+* detection macros (breaking `YAMNET_TO_MACRO`) or drop the validation this
+* schema exists for (see the "rejects a classMap whose target is not a
+* detection macro" test in `model-catalog-schema.test.ts`).
+*/
+var DetectionCatalogClassMapSchema = object({
 	mapping: record(string(), _enum([
 		"person",
 		"vehicle",
@@ -8306,7 +8329,7 @@ var ModelCatalogEntrySchema = object({
 	* applies (Frigate / COCO public catalog). Set on a custom model whose raw
 	* labels already ARE the CamStack macros (Scrypted identity map).
 	*/
-	classMap: ClassMapDefinitionSchema.optional()
+	classMap: DetectionCatalogClassMapSchema.optional()
 });
 var ConvertTargetSchema = discriminatedUnion("format", [object({
 	format: literal("openvino"),
@@ -8336,7 +8359,7 @@ var ModelConvertMetadataSchema = object({
 		"segmentation"
 	]),
 	faceAlignment: boolean().optional(),
-	classMap: ClassMapDefinitionSchema.optional()
+	classMap: DetectionCatalogClassMapSchema.optional()
 });
 var ConvertResultSchema = object({
 	entry: ModelCatalogEntrySchema,
@@ -9209,7 +9232,18 @@ var addonPagesSourceCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { listPages: method(_void(), array(AddonPageDeclarationSchema).readonly()) }
+	methods: { 
+	/**
+	* `internal: true` did not gate the mount (see the 2026-08-26 note on
+	* `data-store-provider`) — this was reachable on the AppRouter by ANY
+	* authenticated session at the default `auth: 'protected'`. The only
+	* consumer, the `addon-pages-aggregator` builtin, reads it via
+	* `ctx.capabilities.getCollection('addon-pages-source')` — LOCAL-PROCESS
+	* only, never tRPC (per `ctx.capabilities` seeing only the local
+	* process). The public, enriched listing admin-ui actually consumes is
+	* the separate `addon-pages` cap, unaffected by this change.
+	*/
+listPages: method(_void(), array(AddonPageDeclarationSchema).readonly(), { auth: "admin" }) }
 };
 var AddonHttpRouteSchema = object({
 	method: _enum([
@@ -9506,7 +9540,20 @@ var addonWidgetsSourceCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { listWidgets: method(_void(), array(WidgetMetadataSchema).readonly()) }
+	methods: { 
+	/**
+	* `internal: true` did not gate the mount (see the 2026-08-26 note on
+	* `data-store-provider`) — this was reachable on the AppRouter by ANY
+	* authenticated session at the default `auth: 'protected'`. The only
+	* consumer, the `addon-widgets-aggregator` builtin, reads it via
+	* `ctx.capabilities.getCollection('addon-widgets-source')` — LOCAL-PROCESS
+	* only, never tRPC. The public, enriched listing admin-ui actually
+	* consumes is the separate `addon-widgets` cap (`listWidgets` there is
+	* gated separately, and a `preAuth: true` widget is surfaced through the
+	* PUBLIC `auth.listLoginMethods` contribution channel instead) —
+	* neither is affected by this change.
+	*/
+listWidgets: method(_void(), array(WidgetMetadataSchema).readonly(), { auth: "admin" }) }
 };
 /**
 * `addon-widgets` — system-scoped singleton aggregator cap. Public-facing
@@ -11670,7 +11717,17 @@ var customModelRegistryCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { listModels: method(_void(), array(CustomModelDescriptorSchema).readonly()) }
+	methods: { 
+	/**
+	* `internal: true` did not gate the mount (see the 2026-08-26 note on
+	* `data-store-provider`) — this was reachable on the AppRouter by ANY
+	* authenticated session at the default `auth: 'protected'`. The only
+	* consumer, the detection-pipeline's model resolution
+	* (`addon-pipeline/src/detection-pipeline/provider.ts`), calls
+	* `ctx.api.customModelRegistry.listModels.query()` — UDS/Moleculer,
+	* never tRPC — so `auth: 'admin'` costs it nothing.
+	*/
+listModels: method(_void(), array(CustomModelDescriptorSchema).readonly(), { auth: "admin" }) }
 };
 /**
 * Query filter for settings-store collections.
@@ -11794,11 +11851,26 @@ var settingsStoreCapability = {
 			key: string(),
 			value: unknown()
 		}), _void(), { kind: "mutation" }),
-		/** Get all entries matching an optional filter. */
+		/**
+		* Rows matching a filter.
+		*
+		* `columns` is a SQL-level projection: the engine SELECTs only those
+		* columns (plus the primary key) instead of the whole row. It is the only
+		* way to stop paying disk for a column that is discarded — a heavy JSON
+		* column dominates the row, and dropping it in JS after the read pays every
+		* byte first. Measured on the live `pipeline-analytics:tracks` table: a
+		* 501-row page is 4.6 MB whole and 0.11 MB projected, same index, same
+		* plan.
+		*
+		* The engine REFUSES a column it cannot serve rather than omitting it —
+		* see `SettingsQueryInput.columns` for why a projection may not be
+		* forgiving the way a predicate is.
+		*/
 		query: method(object({
 			namespace: string().optional(),
 			collection: string(),
-			filter: QueryFilterSchema.optional()
+			filter: QueryFilterSchema.optional(),
+			columns: array(string()).readonly().optional()
 		}), array(SettingsRecordSchema).readonly()),
 		/** Insert a new record. */
 		insert: method(object({
@@ -11924,6 +11996,23 @@ var EngineInfoSchema = object({
 * go through `settings-store`; they never see this cap, and an engine
 * never sees a caller.
 *
+* ⚠ **`internal: true` DOES NOT gate the mount, and until 2026-08-26 this
+* comment claimed otherwise.** `resolveCapMount` never reads the field, so this
+* cap was live on the AppRouter with every method at the default
+* `auth: 'protected'` — i.e. readable by ANY authenticated session, admin or
+* not. Verified against the live hub: `dataStoreProvider.query` returned raw
+* settings rows including a provider credential, bypassing the secret redaction
+* that `deviceManager.listAll` and friends go through.
+*
+* Every method is now `auth: 'admin'` EXPLICITLY, including the five reads —
+* they had no options object at all, which is exactly how they kept the
+* permissive default while the mutations looked deliberate. The explicit
+* annotation is the fix that works today; making `internal` mean something at
+* mount time is the systemic one, and it is not free: 22 caps declare it, only
+* 4 are `mount: 'skip'`, and forcing admin on all of them would change the auth
+* of surfaces the viewer and admin-ui call as non-admin users. That decision is
+* the operator's, not a side effect of this file.
+*
 * Design notes:
 *   - **Stateless dispatch.** Every method carries its own
 *     `namespace` + `collection`, so an engine keeps no per-caller state
@@ -11945,64 +12034,105 @@ var dataStoreProviderCapability = {
 	internal: true,
 	methods: {
 		/** Self-description — how the orchestrator picks a registrant. */
-		getEngineInfo: method(_void(), EngineInfoSchema),
+		getEngineInfo: method(_void(), EngineInfoSchema, { auth: "admin" }),
 		/** Get a single value by key from a collection. */
 		get: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			key: string()
-		}), unknown()),
+		}), unknown(), { auth: "admin" }),
 		/** Set a value by key in a collection (upsert). */
 		set: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			key: string(),
 			value: unknown()
-		}), _void(), { kind: "mutation" }),
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Get all entries matching an optional filter. */
 		query: method(object({
 			namespace: string().optional(),
 			collection: string(),
-			filter: QueryFilterSchema.optional()
-		}), array(SettingsRecordSchema).readonly()),
+			filter: QueryFilterSchema.optional(),
+			/**
+			* SQL-level column projection — MUST mirror `settings-store.query`.
+			*
+			* ⚠ An earlier version of this comment blamed Zod stripping, and that
+			* was wrong — corrected 2026-08-26 after the hop map
+			* (`docs/design/2026-08-26-mappa-hop-argomenti.md`) traced the path.
+			* There is **no Zod parse at all** between the door and the engine: the
+			* dispatcher forwards the payload verbatim and UDS carries it whole. A
+			* field declared here reaches `SqliteSettingsBackend` either way.
+			*
+			* What actually lost `columns` was the THIRD declaration of this shape:
+			* `SettingsQueryInput` in `interfaces/storage.ts`, a hand-written TS
+			* interface the engine destructures from. The field existed on both
+			* schemas and the engine still never read it, because nothing checks a
+			* registered provider against `InferProvider<cap>` —
+			* `ProviderRegistration.provider` is typed `object`.
+			*
+			* It is declared here anyway, and must stay in step with
+			* `settings-store.query`: a caller reading only the cap definitions has
+			* to be able to see that this call carries a projection.
+			* `data-door-schema-parity.spec.ts` keeps the two aligned.
+			*/
+			columns: array(string()).readonly().optional()
+		}), array(SettingsRecordSchema).readonly(), { auth: "admin" }),
 		/** Insert a new record. */
 		insert: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			record: SettingsRecordSchema
-		}), _void(), { kind: "mutation" }),
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Update an existing record by ID. */
 		update: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			id: string(),
 			data: record(string(), unknown())
-		}), _void(), { kind: "mutation" }),
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Delete a record by key/ID. */
 		delete: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			key: string()
-		}), _void(), { kind: "mutation" }),
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Delete every record matching `filter`, in one statement. */
 		deleteWhere: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			filter: MutationFilterSchema
-		}), object({ deleted: number().int() }), { kind: "mutation" }),
+		}), object({ deleted: number().int() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Apply `data` to every record matching `filter`, in one statement. */
 		updateWhere: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			filter: MutationFilterSchema,
 			data: record(string(), unknown())
-		}), object({ updated: number().int() }), { kind: "mutation" }),
+		}), object({ updated: number().int() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Count entries in a collection, optionally filtered. */
 		count: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			filter: QueryFilterSchema.optional()
-		}), number()),
+		}), number(), { auth: "admin" }),
 		/** Grouped counts per ((field-origin)/bucketSize) bucket, filtered. */
 		histogram: method(object({
 			namespace: string().optional(),
@@ -12014,19 +12144,22 @@ var dataStoreProviderCapability = {
 		}), array(object({
 			bucket: number().int(),
 			count: number().int()
-		})).readonly()),
+		})).readonly(), { auth: "admin" }),
 		/** Check if a collection is empty. */
 		isEmpty: method(object({
 			namespace: string().optional(),
 			collection: string()
-		}), boolean()),
+		}), boolean(), { auth: "admin" }),
 		/** Declare a typed (SQL-backed) collection with columns + indexes. */
 		declareCollection: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			columns: array(CollectionColumnSchema).readonly(),
 			indexes: array(CollectionIndexSchema).readonly().optional()
-		}), _void(), { kind: "mutation" })
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 /**
@@ -13826,13 +13959,20 @@ var embeddingEncoderCapability = {
 	mode: "collection",
 	internal: true,
 	methods: {
+		/**
+		* `internal: true` did not gate the mount (see the 2026-08-26 note on
+		* `data-store-provider`) — every method below was reachable on the
+		* AppRouter by ANY authenticated session at the default
+		* `auth: 'protected'`. Consumers reach the encoder via `ctx.api` from
+		* `addon-post-analysis`, never tRPC.
+		*/
 		encode: method(object({
 			crop: _instanceof(Uint8Array),
 			width: number(),
 			height: number()
-		}), EmbeddingResultSchema),
-		encodeText: method(object({ text: string() }), EmbeddingResultSchema),
-		getInfo: method(_void(), EmbeddingInfoSchema)
+		}), EmbeddingResultSchema, { auth: "admin" }),
+		encodeText: method(object({ text: string() }), EmbeddingResultSchema, { auth: "admin" }),
+		getInfo: method(_void(), EmbeddingInfoSchema, { auth: "admin" })
 	}
 };
 /**
@@ -14141,12 +14281,28 @@ var llmRuntimeCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
+		/**
+		* `complete`, `status`, `listLocalModels` and `getDiskUsage` had NO
+		* `auth` override — `internal: true` did not gate the mount (see the
+		* 2026-08-26 note on `data-store-provider`), so they were reachable on
+		* the AppRouter by ANY authenticated session at the default
+		* `auth: 'protected'`, inconsistent with the rest of this cap (already
+		* `auth: 'admin'`) and with this file's own docblock: "the operator
+		* reaches this only through the `llm` cap's methods." The sole caller,
+		* `addon-ai`'s `runtime-client.ts`, reaches every method here via
+		* `ctx.api` + `nodePin` — never tRPC — so `auth: 'admin'` costs it
+		* nothing; the public `llm` cap (which end users and non-admin sessions
+		* legitimately call for chat/generation) is untouched.
+		*/
 		complete: method(LlmGenerateBaseInputSchema.extend({
 			images: array(LlmImageSchema).optional(),
 			runtime: ManagedRuntimeConfigSchema,
 			/** The managed profile's timeout, threaded by the hub provider. */
 			timeoutMs: number().int().positive().optional()
-		}), LlmGenerateResultSchema, { kind: "mutation" }),
+		}), LlmGenerateResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		ensureStarted: method(object({ runtime: ManagedRuntimeConfigSchema }), LlmRuntimeStatusSchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -14155,7 +14311,7 @@ var llmRuntimeCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		status: method(object({}), LlmRuntimeStatusSchema),
+		status: method(object({}), LlmRuntimeStatusSchema, { auth: "admin" }),
 		installModel: method(object({ model: ManagedModelRefSchema }), _void(), {
 			kind: "mutation",
 			auth: "admin"
@@ -14164,8 +14320,8 @@ var llmRuntimeCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		listLocalModels: method(object({}), array(LlmNodeModelSchema)),
-		getDiskUsage: method(object({}), LlmRuntimeDiskUsageSchema)
+		listLocalModels: method(object({}), array(LlmNodeModelSchema), { auth: "admin" }),
+		getDiskUsage: method(object({}), LlmRuntimeDiskUsageSchema, { auth: "admin" })
 	}
 };
 /**
@@ -18431,7 +18587,17 @@ var oauthIntegrationCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { getDescriptor: method(_void(), OauthIntegrationDescriptorSchema) }
+	methods: { 
+	/**
+	* `internal: true` did not gate the mount (see the 2026-08-26 note on
+	* `data-store-provider`) — `getDescriptor` was reachable on the AppRouter
+	* by ANY authenticated session at the default `auth: 'protected'`. The
+	* real caller is `/api/oauth2/authorize` and `/api/oauth2/integrations`
+	* (`oauth2-routes.ts`), which resolve the provider directly off the
+	* capability registry — never through tRPC. `auth: 'admin'` closes the
+	* tRPC surface without touching that path.
+	*/
+getDescriptor: method(_void(), OauthIntegrationDescriptorSchema, { auth: "admin" }) }
 };
 /**
 * pipeline-analytics — device-scoped wrapper cap. Refines raw
@@ -19830,6 +19996,29 @@ var pipelineAnalyticsCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Moves event media between locations — the OPERATOR's mover, without the
+		* coordinator's lease. Twin of `recording.relocateFootage`: the same
+		* engine the lease-gated coordinated migration uses
+		* (`startStorageMigrationMove`), armable in the background and WITHOUT
+		* pausing anything. Exists because `eventMedia` was the only storage
+		* class whose only move path went through the recorder's global pause.
+		*/
+		relocateMedia: method(RelocateMediaInputSchema, object({ jobId: string() }), {
+			kind: "mutation",
+			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(object({}), array(RelocateJobSchema).readonly(), {
+			kind: "query",
+			auth: "admin"
+		}),
+		/** Cancel a running or queued relocate job. */
+		cancelRelocateMedia: method(object({ jobId: string() }), object({ cancelled: boolean() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		listOpsLog: method(OpsLogQueryInputSchema, array(OpsLogEntrySchema).readonly(), {
 			kind: "query",
 			auth: "admin"
@@ -20189,6 +20378,11 @@ object({
 		"jpeg"
 	])
 });
+/**
+* Process-local frame identity. It is serializable so it can ride an in-process
+* capability call, but `registryId` deliberately prevents resolution in any
+* other process or execution group.
+*/
 var FrameRefSchema = object({
 	registryId: string().min(1),
 	id: string().min(1),
@@ -23142,6 +23336,20 @@ var ssoBridgeCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
+		/**
+		* `internal: true` did not gate the mount (see the 2026-08-26 note on
+		* `data-store-provider`) — `signBridgeToken` was reachable on the
+		* AppRouter by ANY authenticated session at the default
+		* `auth: 'protected'`. The claims (including `isAdmin`) are CALLER-
+		* SUPPLIED: an unprivileged session could have minted its own
+		* `isAdmin: true` bridge token and redeemed it at
+		* `/api/auth/sso/finish` to become admin — a full privilege escalation
+		* through the exact surface this cap exists to close (see the module
+		* docblock). Every real caller (`oauth-grants.ts`, `main.ts`
+		* registration, the OIDC/magic-link addons) reaches this through
+		* `ctx.api` / the in-process registry — never through tRPC — so
+		* `auth: 'admin'` costs those callers nothing.
+		*/
 		signBridgeToken: method(object({
 			claims: SsoBridgeClaimsSchema,
 			/**
@@ -23154,8 +23362,8 @@ var ssoBridgeCapability = {
 			* linking rather than produce an eternal token.
 			*/
 			ttlSec: union([number().int().positive(), literal("never")]).optional()
-		}), object({ token: string() })),
-		verifyBridgeToken: method(object({ token: string() }), SsoBridgeClaimsSchema.nullable())
+		}), object({ token: string() }), { auth: "admin" }),
+		verifyBridgeToken: method(object({ token: string() }), SsoBridgeClaimsSchema.nullable(), { auth: "admin" })
 	}
 };
 var ProviderListEntrySchema = discriminatedUnion("shouldSaveDiskSpace", [object({
@@ -23304,8 +23512,15 @@ var storageEvictableCapability = {
 	mode: "collection",
 	internal: true,
 	methods: {
+		/**
+		* `internal: true` did not gate the mount (see the 2026-08-26 note on
+		* `data-store-provider`) — this was reachable on the AppRouter by ANY
+		* authenticated session at the default `auth: 'protected'`. The only
+		* consumer is the orchestrator's `StoragePressureManager`, which calls
+		* `ctx.api` — never tRPC — so `auth: 'admin'` costs it nothing.
+		*/
 		/** Bytes this provider holds on the given location — drives proportional fan-out. */
-		getEvictableUsage: method(object({ locationId: string() }), EvictableUsageSchema),
+		getEvictableUsage: method(object({ locationId: string() }), EvictableUsageSchema, { auth: "admin" }),
 		/**
 		* Free approximately `targetBytes` of this provider's OWN least-valuable
 		* data on the location (oldest footage, expired clips, …). Returns what it
@@ -23314,7 +23529,10 @@ var storageEvictableCapability = {
 		evict: method(object({
 			locationId: string(),
 			targetBytes: number().int().positive()
-		}), EvictResultSchema, { kind: "mutation" })
+		}), EvictResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 /**
@@ -23417,43 +23635,82 @@ var storageProviderCapability = {
 	mode: "collection",
 	internal: true,
 	methods: {
+		/**
+		* Every method below except `testLocation` had NO `auth` override —
+		* `internal: true` did not gate the mount (see the 2026-08-26 note on
+		* `data-store-provider`), so this was reachable on the AppRouter by ANY
+		* authenticated session at the default `auth: 'protected'`: arbitrary
+		* read/write/delete/list against any storage location the operator has
+		* configured, keyed only by a caller-supplied `location` + `relativePath`
+		* — the same "public consumers never see this cap" claim that was false
+		* for `data-store-provider`, here gating raw file I/O instead of raw
+		* settings rows. The only legitimate caller,
+		* `addon-registry.service.ts`'s `activeStorageProvider`, calls the
+		* provider object directly (in-process) — never tRPC — so `auth: 'admin'`
+		* on every method costs it nothing. Public consumers already go through
+		* the separate `storage` singleton cap.
+		*/
 		/** Self-description for the "Add location" wizard. */
-		getProviderInfo: method(_void(), ProviderInfoSchema),
+		getProviderInfo: method(_void(), ProviderInfoSchema, { auth: "admin" }),
 		/** Validate config + probe connectivity. Called on add and on edit. */
 		testLocation: method(object({ config: record(string(), unknown()) }), TestLocationResultSchema, { auth: "admin" }),
 		resolve: method(object({
 			location: StorageLocationSchema,
 			relativePath: string()
-		}), string()),
+		}), string(), { auth: "admin" }),
 		write: method(object({
 			location: StorageLocationSchema,
 			relativePath: string(),
 			data: _instanceof(Uint8Array)
-		}), _void(), { kind: "mutation" }),
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		read: method(object({
 			location: StorageLocationSchema,
 			relativePath: string()
-		}), _instanceof(Uint8Array)),
+		}), _instanceof(Uint8Array), { auth: "admin" }),
 		exists: method(object({
 			location: StorageLocationSchema,
 			relativePath: string()
-		}), boolean()),
+		}), boolean(), { auth: "admin" }),
 		list: method(object({
 			location: StorageLocationSchema,
 			prefix: string().optional()
-		}), array(string()).readonly()),
+		}), array(string()).readonly(), { auth: "admin" }),
 		delete: method(object({
 			location: StorageLocationSchema,
 			relativePath: string()
-		}), _void(), { kind: "mutation" }),
-		getAvailableSpace: method(object({ location: StorageLocationSchema }), number().nullable()),
-		beginUpload: method(BeginUploadInputSchema, BeginUploadResultSchema, { kind: "mutation" }),
-		writeChunk: method(WriteChunkInputSchema, _void(), { kind: "mutation" }),
-		finalizeUpload: method(FinalizeUploadInputSchema, _void(), { kind: "mutation" }),
-		abortUpload: method(AbortUploadInputSchema, _void(), { kind: "mutation" }),
-		beginDownload: method(BeginDownloadInputSchema, BeginDownloadResultSchema, { kind: "mutation" }),
-		readChunk: method(ReadChunkInputSchema, _instanceof(Uint8Array)),
-		endDownload: method(EndDownloadInputSchema, _void(), { kind: "mutation" })
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getAvailableSpace: method(object({ location: StorageLocationSchema }), number().nullable(), { auth: "admin" }),
+		beginUpload: method(BeginUploadInputSchema, BeginUploadResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		writeChunk: method(WriteChunkInputSchema, _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		finalizeUpload: method(FinalizeUploadInputSchema, _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		abortUpload: method(AbortUploadInputSchema, _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		beginDownload: method(BeginDownloadInputSchema, BeginDownloadResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		readChunk: method(ReadChunkInputSchema, _instanceof(Uint8Array), { auth: "admin" }),
+		endDownload: method(EndDownloadInputSchema, _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 /** Profile-exported FormBuilder schema. Shape is ConfigUISchema at the UI. */
@@ -23786,9 +24043,28 @@ var userPasskeysCapability = {
 			auth: "admin",
 			access: "create"
 		}),
+		/**
+		* The four methods below had NO `auth` override — `internal: true` did
+		* not gate the mount (see the 2026-08-26 note on `data-store-provider`),
+		* so they were reachable on the AppRouter at the default
+		* `auth: 'protected'` (any authenticated session), inconsistent with
+		* every other method on this cap (all already `auth: 'admin'`).
+		*
+		* ⚠ Checked before gating: these are also the PRE-AUTH login-ceremony
+		* methods, so admin-gating them here must not break login for an
+		* unauthenticated principal. It doesn't — the real login path is the
+		* PUBLIC `auth.beginAuthentication` / `auth.finishAuthentication` /
+		* `auth.beginDiscoverableAuthentication` / `auth.finishDiscoverableAuthentication`
+		* procedures in `server/backend/src/api/core/auth.router.ts`, which call
+		* `provider.beginAuthentication(...)` etc. directly against the
+		* capability-registry-resolved provider — never through this cap's own
+		* tRPC route. `auth: 'admin'` here only closes a redundant, unused
+		* second entry point onto the same ceremony.
+		*/
 		beginAuthentication: method(object({ userId: string().optional() }), object({ optionsJSON: record(string(), unknown()) }), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		finishAuthentication: method(object({
 			/** Required — the user the assertion belongs to (verified). */
@@ -23797,11 +24073,13 @@ var userPasskeysCapability = {
 			response: record(string(), unknown())
 		}), object({ verified: boolean() }), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		beginDiscoverableAuthentication: method(object({}), object({ optionsJSON: record(string(), unknown()) }), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		finishDiscoverableAuthentication: method(object({ 
 		/** AuthenticationResponseJSON from the browser. */
@@ -23810,7 +24088,8 @@ response: record(string(), unknown()) }), object({
 			userId: string().nullable()
 		}), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		listPasskeys: method(object({ userId: string() }), array(PasskeySummarySchema), { auth: "admin" }),
 		removePasskey: method(object({
@@ -23988,6 +24267,14 @@ var VectorStatsResultSchema = object({
 	/** False when the backend ranks approximately. */
 	exact: boolean()
 });
+/**
+* `internal: true` did not gate the mount (see the 2026-08-26 note on
+* `data-store-provider`) — every method below was reachable on the AppRouter
+* by ANY authenticated session at the default `auth: 'protected'`. The only
+* consumers (`addon-post-analysis`'s embedding stores) reach this cap via
+* `ctx.api` — UDS/Moleculer, never tRPC — so `auth: 'admin'` on every method
+* costs them nothing. No client (viewer or admin-ui) calls `vectorStore.*`.
+*/
 var vectorStoreCapability = {
 	name: "vector-store",
 	scope: "system",
@@ -23995,14 +24282,26 @@ var vectorStoreCapability = {
 	internal: true,
 	methods: {
 		/** Idempotent. Re-declaring with a different `dim` is an error, not a wipe. */
-		declareIndex: method(VectorDeclareIndexInputSchema, _void(), { kind: "mutation" }),
-		upsert: method(VectorUpsertInputSchema, VectorUpsertResultSchema, { kind: "mutation" }),
-		query: method(VectorQueryInputSchema, VectorQueryResultSchema),
+		declareIndex: method(VectorDeclareIndexInputSchema, _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		upsert: method(VectorUpsertInputSchema, VectorUpsertResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		query: method(VectorQueryInputSchema, VectorQueryResultSchema, { auth: "admin" }),
 		/** Metadata by id, no vectors — see {@link VectorGetResultSchema}. */
-		getByIds: method(VectorGetInputSchema, VectorGetResultSchema),
-		deleteByIds: method(VectorDeleteInputSchema, VectorDeleteResultSchema, { kind: "mutation" }),
-		deleteByFilter: method(VectorDeleteByFilterInputSchema, VectorDeleteResultSchema, { kind: "mutation" }),
-		stats: method(VectorStatsInputSchema, VectorStatsResultSchema)
+		getByIds: method(VectorGetInputSchema, VectorGetResultSchema, { auth: "admin" }),
+		deleteByIds: method(VectorDeleteInputSchema, VectorDeleteResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteByFilter: method(VectorDeleteByFilterInputSchema, VectorDeleteResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		stats: method(VectorStatsInputSchema, VectorStatsResultSchema, { auth: "admin" })
 	}
 };
 var ClipSchema = object({
@@ -26851,7 +27150,27 @@ var faceGalleryCapability = {
 	scope: "system",
 	mode: "singleton",
 	methods: {
-		listIdentities: method(_void(), array(IdentitySchema).readonly()),
+		listIdentities: method(object({ 
+		/**
+		* Inline {@link IdentitySchema.coverBase64} on every row.
+		*
+		* Default `false`, the same inversion `listRecentFaces` and
+		* `listPlates` took on 2026-08-25 (see `include-crops-default.ts` for
+		* why the burden belongs on the caller that WANTS the bytes). Measured
+		* on the live hub the same day: four identities cost 40,979 B with the
+		* covers inline, ~10 KB of base64 per row, on a query this UI mounts
+		* four times and the viewer holds at `staleTime: 30_000`.
+		*
+		* Nothing loses its avatar: `coverMediaKey` is already on every row and
+		* the `event-media` plane serves that key `immutable` with an ETag.
+		*
+		* **This is an INPUT field, so it does not reach the addon until the
+		* next train** — the hub router validates cap inputs against its own
+		* compiled Zod and strips a key it does not know. Until then the
+		* provider sees `undefined`, which resolves to `false`: the cheap shape
+		* is what ships, and the opt-in becomes reachable when the train lands.
+		*/
+includeCrops: boolean().optional() }).optional(), array(IdentitySchema).readonly()),
 		createIdentity: method(object({ name: string().min(1) }), IdentitySchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -30104,8 +30423,10 @@ var PlateInfoSchema = object({
 	keyFrameMediaKey: string().optional(),
 	base64: string().optional(),
 	/**
-	* Same crop as a data-plane URL. `getPlateByTrack` returns this and
-	* never inlines JPEG; `listPlates` still inlines for the admin-ui.
+	* Same crop as a data-plane URL, always present when the plate has a stored
+	* crop. `getPlateByTrack` returns this and never inlines JPEG; `listPlates`
+	* and `searchPlates` inline the crop only when their `includeCrops` input is
+	* left at its `true` default.
 	*/
 	cropUrl: string().optional()
 });
@@ -30138,7 +30459,25 @@ var plateGalleryCapability = {
 	methods: {
 		listPlates: method(object({
 			deviceId: number().int().optional(),
-			limit: number().int().positive().optional()
+			limit: number().int().positive().optional(),
+			/**
+			* Inline the base64 crop on every row. Default `true` — the existing
+			* behaviour, kept so no caller breaks.
+			*
+			* Set `false` once the caller renders {@link PlateInfo.cropUrl}.
+			* Measured on the live hub at the 500 rows the Plates view asks for:
+			* 879,403 B and 27.7 s with the crops inline, against a few KiB of
+			* metadata without them — and the browser then caches the images.
+			*
+			* This is the plate twin of `faceGallery.listRecentFaces`'s option;
+			* plates were the one gallery list left without it.
+			*
+			* **This is an INPUT field, so it does not reach the addon until the
+			* next train.** The hub router validates cap inputs against its own
+			* compiled Zod and strips a key it does not know. Until the train
+			* ships, sending `false` is harmless and keeps the crops inline.
+			*/
+			includeCrops: boolean().optional()
 		}).optional(), array(PlateInfoSchema).readonly()),
 		getPlateByTrack: method(object({
 			deviceId: number().int(),
@@ -30149,7 +30488,9 @@ var plateGalleryCapability = {
 		searchPlates: method(object({
 			text: string().min(1),
 			maxDistance: number().int().min(0).optional(),
-			limit: number().int().positive().optional()
+			limit: number().int().positive().optional(),
+			/** See `listPlates.includeCrops`. Default `true`. */
+			includeCrops: boolean().optional()
 		}), array(PlateInfoSchema).readonly()),
 		/** Suggest groups of near-identical reads (same physical plate) for review/merge. */
 		suggestPlateClusters: method(object({
@@ -30169,7 +30510,13 @@ var plateGalleryCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		listVehicles: method(_void(), array(VehicleSchema).readonly()),
+		listVehicles: method(object({ 
+		/** Inline {@link VehicleSchema.coverBase64} on every row. Default
+		*  `false` — the vehicle twin of `faceGallery.listIdentities`'s
+		*  option; `coverMediaKey` + the `event-media` plane carry the picture.
+		*  INPUT field: stripped by the hub router until the train ships, which
+		*  resolves to `false` and is exactly the intended default. */
+includeCrops: boolean().optional() }).optional(), array(VehicleSchema).readonly()),
 		createVehicle: method(object({ name: string().min(1) }), VehicleSchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -36913,6 +37260,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.cancelRelocateMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.cancelStorageMigrationMove": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -37087,6 +37440,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.listRelocateMediaJobs": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.listRetrainAnnotations": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -37165,6 +37524,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.relocateMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.restageRetrainTrack": {
 		capName: "pipeline-analytics",
 		capScope: "device",