@camstack/types 1.2.106 → 1.2.108

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_event_category = require("./event-category-EY0GNjV9.js");
-const require_sleep = require("./sleep-CUuoW-kk.js");
+const require_sleep = require("./sleep-OOwhyQIx.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");
@@ -4349,7 +4349,18 @@ var addonPagesSourceCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { listPages: require_sleep.method(zod.z.void(), zod.z.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: require_sleep.method(zod.z.void(), zod.z.array(AddonPageDeclarationSchema).readonly(), { auth: "admin" }) }
 };
 //#endregion
 //#region src/capabilities/addon-routes.cap.ts
@@ -4652,7 +4663,20 @@ var addonWidgetsSourceCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { listWidgets: require_sleep.method(zod.z.void(), zod.z.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: require_sleep.method(zod.z.void(), zod.z.array(WidgetMetadataSchema).readonly(), { auth: "admin" }) }
 };
 //#endregion
 //#region src/capabilities/addon-widgets.cap.ts
@@ -7101,7 +7125,17 @@ var customModelRegistryCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { listModels: require_sleep.method(zod.z.void(), zod.z.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: require_sleep.method(zod.z.void(), zod.z.array(CustomModelDescriptorSchema).readonly(), { auth: "admin" }) }
 };
 //#endregion
 //#region src/capabilities/settings-store.cap.ts
@@ -7374,6 +7408,23 @@ var EngineInfoSchema = zod.z.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
@@ -7395,20 +7446,23 @@ var dataStoreProviderCapability = {
 	internal: true,
 	methods: {
 		/** Self-description — how the orchestrator picks a registrant. */
-		getEngineInfo: require_sleep.method(zod.z.void(), EngineInfoSchema),
+		getEngineInfo: require_sleep.method(zod.z.void(), EngineInfoSchema, { auth: "admin" }),
 		/** Get a single value by key from a collection. */
 		get: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
 			collection: zod.z.string(),
 			key: zod.z.string()
-		}), zod.z.unknown()),
+		}), zod.z.unknown(), { auth: "admin" }),
 		/** Set a value by key in a collection (upsert). */
 		set: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
 			collection: zod.z.string(),
 			key: zod.z.string(),
 			value: zod.z.unknown()
-		}), zod.z.void(), { kind: "mutation" }),
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Get all entries matching an optional filter. */
 		query: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
@@ -7417,52 +7471,80 @@ var dataStoreProviderCapability = {
 			/**
 			* SQL-level column projection — MUST mirror `settings-store.query`.
 			*
-			* This is the second schema the same call passes through, and Zod
-			* objects STRIP what they do not declare: a field present on the door
-			* and absent here does not error, it silently disappears one hop before
-			* the engine, and the caller concludes the projection does nothing.
-			* `data-door-schema-parity.spec.ts` is what keeps the two in step.
+			* ⚠ 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: zod.z.array(zod.z.string()).readonly().optional()
-		}), zod.z.array(SettingsRecordSchema).readonly()),
+		}), zod.z.array(SettingsRecordSchema).readonly(), { auth: "admin" }),
 		/** Insert a new record. */
 		insert: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
 			collection: zod.z.string(),
 			record: SettingsRecordSchema
-		}), zod.z.void(), { kind: "mutation" }),
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Update an existing record by ID. */
 		update: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
 			collection: zod.z.string(),
 			id: zod.z.string(),
 			data: zod.z.record(zod.z.string(), zod.z.unknown())
-		}), zod.z.void(), { kind: "mutation" }),
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Delete a record by key/ID. */
 		delete: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
 			collection: zod.z.string(),
 			key: zod.z.string()
-		}), zod.z.void(), { kind: "mutation" }),
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Delete every record matching `filter`, in one statement. */
 		deleteWhere: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
 			collection: zod.z.string(),
 			filter: MutationFilterSchema
-		}), zod.z.object({ deleted: zod.z.number().int() }), { kind: "mutation" }),
+		}), zod.z.object({ deleted: zod.z.number().int() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Apply `data` to every record matching `filter`, in one statement. */
 		updateWhere: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
 			collection: zod.z.string(),
 			filter: MutationFilterSchema,
 			data: zod.z.record(zod.z.string(), zod.z.unknown())
-		}), zod.z.object({ updated: zod.z.number().int() }), { kind: "mutation" }),
+		}), zod.z.object({ updated: zod.z.number().int() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Count entries in a collection, optionally filtered. */
 		count: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
 			collection: zod.z.string(),
 			filter: QueryFilterSchema.optional()
-		}), zod.z.number()),
+		}), zod.z.number(), { auth: "admin" }),
 		/** Grouped counts per ((field-origin)/bucketSize) bucket, filtered. */
 		histogram: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
@@ -7474,19 +7556,22 @@ var dataStoreProviderCapability = {
 		}), zod.z.array(zod.z.object({
 			bucket: zod.z.number().int(),
 			count: zod.z.number().int()
-		})).readonly()),
+		})).readonly(), { auth: "admin" }),
 		/** Check if a collection is empty. */
 		isEmpty: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
 			collection: zod.z.string()
-		}), zod.z.boolean()),
+		}), zod.z.boolean(), { auth: "admin" }),
 		/** Declare a typed (SQL-backed) collection with columns + indexes. */
 		declareCollection: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
 			collection: zod.z.string(),
 			columns: zod.z.array(CollectionColumnSchema).readonly(),
 			indexes: zod.z.array(CollectionIndexSchema).readonly().optional()
-		}), zod.z.void(), { kind: "mutation" })
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 //#endregion
@@ -9471,13 +9556,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: require_sleep.method(zod.z.object({
 			crop: zod.z.instanceof(Uint8Array),
 			width: zod.z.number(),
 			height: zod.z.number()
-		}), EmbeddingResultSchema),
-		encodeText: require_sleep.method(zod.z.object({ text: zod.z.string() }), EmbeddingResultSchema),
-		getInfo: require_sleep.method(zod.z.void(), EmbeddingInfoSchema)
+		}), EmbeddingResultSchema, { auth: "admin" }),
+		encodeText: require_sleep.method(zod.z.object({ text: zod.z.string() }), EmbeddingResultSchema, { auth: "admin" }),
+		getInfo: require_sleep.method(zod.z.void(), EmbeddingInfoSchema, { auth: "admin" })
 	}
 };
 //#endregion
@@ -9818,7 +9910,23 @@ var llmRuntimeCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
-		complete: require_sleep.method(LlmRuntimeCompleteInputSchema, LlmGenerateResultSchema, { kind: "mutation" }),
+		/**
+		* `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: require_sleep.method(LlmRuntimeCompleteInputSchema, LlmGenerateResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		ensureStarted: require_sleep.method(zod.z.object({ runtime: ManagedRuntimeConfigSchema }), LlmRuntimeStatusSchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -9827,7 +9935,7 @@ var llmRuntimeCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		status: require_sleep.method(zod.z.object({}), LlmRuntimeStatusSchema),
+		status: require_sleep.method(zod.z.object({}), LlmRuntimeStatusSchema, { auth: "admin" }),
 		installModel: require_sleep.method(zod.z.object({ model: ManagedModelRefSchema }), zod.z.void(), {
 			kind: "mutation",
 			auth: "admin"
@@ -9836,8 +9944,8 @@ var llmRuntimeCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		listLocalModels: require_sleep.method(zod.z.object({}), zod.z.array(LlmNodeModelSchema)),
-		getDiskUsage: require_sleep.method(zod.z.object({}), LlmRuntimeDiskUsageSchema)
+		listLocalModels: require_sleep.method(zod.z.object({}), zod.z.array(LlmNodeModelSchema), { auth: "admin" }),
+		getDiskUsage: require_sleep.method(zod.z.object({}), LlmRuntimeDiskUsageSchema, { auth: "admin" })
 	}
 };
 //#endregion
@@ -14615,7 +14723,17 @@ var oauthIntegrationCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { getDescriptor: require_sleep.method(zod.z.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: require_sleep.method(zod.z.void(), OauthIntegrationDescriptorSchema, { auth: "admin" }) }
 };
 //#endregion
 //#region src/capabilities/pipeline-analytics.cap.ts
@@ -19628,6 +19746,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: require_sleep.method(zod.z.object({
 			claims: SsoBridgeClaimsSchema,
 			/**
@@ -19640,8 +19772,8 @@ var ssoBridgeCapability = {
 			* linking rather than produce an eternal token.
 			*/
 			ttlSec: zod.z.union([zod.z.number().int().positive(), zod.z.literal("never")]).optional()
-		}), zod.z.object({ token: zod.z.string() })),
-		verifyBridgeToken: require_sleep.method(zod.z.object({ token: zod.z.string() }), SsoBridgeClaimsSchema.nullable())
+		}), zod.z.object({ token: zod.z.string() }), { auth: "admin" }),
+		verifyBridgeToken: require_sleep.method(zod.z.object({ token: zod.z.string() }), SsoBridgeClaimsSchema.nullable(), { auth: "admin" })
 	}
 };
 //#endregion
@@ -19794,8 +19926,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: require_sleep.method(zod.z.object({ locationId: zod.z.string() }), EvictableUsageSchema),
+		getEvictableUsage: require_sleep.method(zod.z.object({ locationId: zod.z.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
@@ -19804,7 +19943,10 @@ var storageEvictableCapability = {
 		evict: require_sleep.method(zod.z.object({
 			locationId: zod.z.string(),
 			targetBytes: zod.z.number().int().positive()
-		}), EvictResultSchema, { kind: "mutation" })
+		}), EvictResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 //#endregion
@@ -19911,43 +20053,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: require_sleep.method(zod.z.void(), ProviderInfoSchema),
+		getProviderInfo: require_sleep.method(zod.z.void(), ProviderInfoSchema, { auth: "admin" }),
 		/** Validate config + probe connectivity. Called on add and on edit. */
 		testLocation: require_sleep.method(zod.z.object({ config: zod.z.record(zod.z.string(), zod.z.unknown()) }), TestLocationResultSchema, { auth: "admin" }),
 		resolve: require_sleep.method(zod.z.object({
 			location: StorageLocationSchema,
 			relativePath: zod.z.string()
-		}), zod.z.string()),
+		}), zod.z.string(), { auth: "admin" }),
 		write: require_sleep.method(zod.z.object({
 			location: StorageLocationSchema,
 			relativePath: zod.z.string(),
 			data: zod.z.instanceof(Uint8Array)
-		}), zod.z.void(), { kind: "mutation" }),
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		read: require_sleep.method(zod.z.object({
 			location: StorageLocationSchema,
 			relativePath: zod.z.string()
-		}), zod.z.instanceof(Uint8Array)),
+		}), zod.z.instanceof(Uint8Array), { auth: "admin" }),
 		exists: require_sleep.method(zod.z.object({
 			location: StorageLocationSchema,
 			relativePath: zod.z.string()
-		}), zod.z.boolean()),
+		}), zod.z.boolean(), { auth: "admin" }),
 		list: require_sleep.method(zod.z.object({
 			location: StorageLocationSchema,
 			prefix: zod.z.string().optional()
-		}), zod.z.array(zod.z.string()).readonly()),
+		}), zod.z.array(zod.z.string()).readonly(), { auth: "admin" }),
 		delete: require_sleep.method(zod.z.object({
 			location: StorageLocationSchema,
 			relativePath: zod.z.string()
-		}), zod.z.void(), { kind: "mutation" }),
-		getAvailableSpace: require_sleep.method(zod.z.object({ location: StorageLocationSchema }), zod.z.number().nullable()),
-		beginUpload: require_sleep.method(BeginUploadInputSchema, BeginUploadResultSchema, { kind: "mutation" }),
-		writeChunk: require_sleep.method(WriteChunkInputSchema, zod.z.void(), { kind: "mutation" }),
-		finalizeUpload: require_sleep.method(FinalizeUploadInputSchema, zod.z.void(), { kind: "mutation" }),
-		abortUpload: require_sleep.method(AbortUploadInputSchema, zod.z.void(), { kind: "mutation" }),
-		beginDownload: require_sleep.method(BeginDownloadInputSchema, BeginDownloadResultSchema, { kind: "mutation" }),
-		readChunk: require_sleep.method(ReadChunkInputSchema, zod.z.instanceof(Uint8Array)),
-		endDownload: require_sleep.method(EndDownloadInputSchema, zod.z.void(), { kind: "mutation" })
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getAvailableSpace: require_sleep.method(zod.z.object({ location: StorageLocationSchema }), zod.z.number().nullable(), { auth: "admin" }),
+		beginUpload: require_sleep.method(BeginUploadInputSchema, BeginUploadResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		writeChunk: require_sleep.method(WriteChunkInputSchema, zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		finalizeUpload: require_sleep.method(FinalizeUploadInputSchema, zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		abortUpload: require_sleep.method(AbortUploadInputSchema, zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		beginDownload: require_sleep.method(BeginDownloadInputSchema, BeginDownloadResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		readChunk: require_sleep.method(ReadChunkInputSchema, zod.z.instanceof(Uint8Array), { auth: "admin" }),
+		endDownload: require_sleep.method(EndDownloadInputSchema, zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 //#endregion
@@ -20286,9 +20467,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: require_sleep.method(zod.z.object({ userId: zod.z.string().optional() }), zod.z.object({ optionsJSON: zod.z.record(zod.z.string(), zod.z.unknown()) }), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		finishAuthentication: require_sleep.method(zod.z.object({
 			/** Required — the user the assertion belongs to (verified). */
@@ -20297,11 +20497,13 @@ var userPasskeysCapability = {
 			response: zod.z.record(zod.z.string(), zod.z.unknown())
 		}), zod.z.object({ verified: zod.z.boolean() }), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		beginDiscoverableAuthentication: require_sleep.method(zod.z.object({}), zod.z.object({ optionsJSON: zod.z.record(zod.z.string(), zod.z.unknown()) }), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		finishDiscoverableAuthentication: require_sleep.method(zod.z.object({ 
 		/** AuthenticationResponseJSON from the browser. */
@@ -20310,7 +20512,8 @@ response: zod.z.record(zod.z.string(), zod.z.unknown()) }), zod.z.object({
 			userId: zod.z.string().nullable()
 		}), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		listPasskeys: require_sleep.method(zod.z.object({ userId: zod.z.string() }), zod.z.array(PasskeySummarySchema), { auth: "admin" }),
 		removePasskey: require_sleep.method(zod.z.object({
@@ -20490,6 +20693,14 @@ var VectorStatsResultSchema = zod.z.object({
 	/** False when the backend ranks approximately. */
 	exact: zod.z.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",
@@ -20497,14 +20708,26 @@ var vectorStoreCapability = {
 	internal: true,
 	methods: {
 		/** Idempotent. Re-declaring with a different `dim` is an error, not a wipe. */
-		declareIndex: require_sleep.method(VectorDeclareIndexInputSchema, zod.z.void(), { kind: "mutation" }),
-		upsert: require_sleep.method(VectorUpsertInputSchema, VectorUpsertResultSchema, { kind: "mutation" }),
-		query: require_sleep.method(VectorQueryInputSchema, VectorQueryResultSchema),
+		declareIndex: require_sleep.method(VectorDeclareIndexInputSchema, zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		upsert: require_sleep.method(VectorUpsertInputSchema, VectorUpsertResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		query: require_sleep.method(VectorQueryInputSchema, VectorQueryResultSchema, { auth: "admin" }),
 		/** Metadata by id, no vectors — see {@link VectorGetResultSchema}. */
-		getByIds: require_sleep.method(VectorGetInputSchema, VectorGetResultSchema),
-		deleteByIds: require_sleep.method(VectorDeleteInputSchema, VectorDeleteResultSchema, { kind: "mutation" }),
-		deleteByFilter: require_sleep.method(VectorDeleteByFilterInputSchema, VectorDeleteResultSchema, { kind: "mutation" }),
-		stats: require_sleep.method(VectorStatsInputSchema, VectorStatsResultSchema)
+		getByIds: require_sleep.method(VectorGetInputSchema, VectorGetResultSchema, { auth: "admin" }),
+		deleteByIds: require_sleep.method(VectorDeleteInputSchema, VectorDeleteResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteByFilter: require_sleep.method(VectorDeleteByFilterInputSchema, VectorDeleteResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		stats: require_sleep.method(VectorStatsInputSchema, VectorStatsResultSchema, { auth: "admin" })
 	}
 };
 //#endregion