@camstack/types 1.2.107 → 1.2.108

package/dist/addon.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_err_msg = require("./err-msg-COpsHMw2.js");
 //#region src/generated/cap-input-defaults.ts
 /**

package/dist/addon.mjs

@@ -1,5 +1,5 @@
 import { t as EventCategory } from "./event-category-CIa_iT6b.mjs";
-import { B as ReadinessRegistry, E as adminUiCapability, L as nodePin, R as readNodePin, St as emitReadiness, T as DeviceType, V as ReadinessTimeoutError, W as scopeKey, _t as DisposerChain, a as asJsonObject, b as deviceOpsCapability, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, gt as DATAPLANE_SECRET_HEADER, h as createEventBusSliceSource, j as expandCapMethods, m as createDeviceProxy, p as isDeviceScopedCap, s as asString, t as sleep, u as parseJsonUnknown, vt as BaseAddon, x as viewerUiCapability, yt as normalizeAddonInitResult } from "./sleep-BLxqGLY0.mjs";
+import { B as ReadinessRegistry, E as adminUiCapability, L as nodePin, R as readNodePin, St as emitReadiness, T as DeviceType, V as ReadinessTimeoutError, W as scopeKey, _t as DisposerChain, a as asJsonObject, b as deviceOpsCapability, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, gt as DATAPLANE_SECRET_HEADER, h as createEventBusSliceSource, j as expandCapMethods, m as createDeviceProxy, p as isDeviceScopedCap, s as asString, t as sleep, u as parseJsonUnknown, vt as BaseAddon, x as viewerUiCapability, yt as normalizeAddonInitResult } from "./sleep-DCBRhx0s.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 //#region src/generated/cap-input-defaults.ts
 /**

package/dist/capabilities/addon-pages-source.cap.d.ts

@@ -28,6 +28,16 @@ export declare const addonPagesSourceCapability: {
     readonly mode: "collection";
     readonly internal: true;
     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.
+         */
         readonly listPages: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             label: z.ZodString;

package/dist/capabilities/addon-widgets-source.cap.d.ts

@@ -122,6 +122,18 @@ export declare const addonWidgetsSourceCapability: {
     readonly mode: "collection";
     readonly internal: true;
     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.
+         */
         readonly listWidgets: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             tab: z.ZodString;
             subTab: z.ZodOptional<z.ZodString>;

package/dist/capabilities/admin-ui.cap.d.ts

@@ -6,6 +6,15 @@ export declare const adminUiCapability: {
     readonly mode: "singleton";
     readonly internal: true;
     readonly methods: {
+        /**
+         * `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.
+         */
         readonly getStaticDir: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
             staticDir: z.ZodString;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;

package/dist/capabilities/custom-model-registry.cap.d.ts

@@ -161,6 +161,15 @@ export declare const customModelRegistryCapability: {
     readonly mode: "collection";
     readonly internal: true;
     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.
+         */
         readonly listModels: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             stepId: z.ZodString;
             entry: z.ZodObject<{

package/dist/capabilities/embedding-encoder.cap.d.ts

@@ -22,6 +22,13 @@ export declare const embeddingEncoderCapability: {
     readonly mode: "collection";
     readonly internal: true;
     readonly 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.
+         */
         readonly encode: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             crop: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
             width: z.ZodNumber;

package/dist/capabilities/llm-runtime.cap.d.ts

@@ -248,6 +248,19 @@ export declare const llmRuntimeCapability: {
     readonly mode: "singleton";
     readonly internal: true;
     readonly 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.
+         */
         readonly complete: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             addonId: z.ZodOptional<z.ZodString>;
             profileId: z.ZodOptional<z.ZodString>;

package/dist/capabilities/oauth-integration.cap.d.ts

@@ -140,6 +140,15 @@ export declare const oauthIntegrationCapability: {
     readonly mode: "collection";
     readonly internal: true;
     readonly 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.
+         */
         readonly getDescriptor: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
             integrationId: z.ZodString;
             displayName: z.ZodString;

package/dist/capabilities/sso-bridge.cap.d.ts

@@ -83,6 +83,20 @@ export declare const ssoBridgeCapability: {
     readonly mode: "singleton";
     readonly internal: true;
     readonly 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.
+         */
         readonly signBridgeToken: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             claims: z.ZodObject<{
                 userId: z.ZodString;

package/dist/capabilities/storage-evictable.cap.d.ts

@@ -29,6 +29,13 @@ export declare const storageEvictableCapability: {
     readonly mode: "collection";
     readonly internal: true;
     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 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. */
         readonly getEvictableUsage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             locationId: z.ZodString;

package/dist/capabilities/storage-provider.cap.d.ts

@@ -112,6 +112,21 @@ export declare const storageProviderCapability: {
     readonly mode: "collection";
     readonly internal: true;
     readonly 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. */
         readonly getProviderInfo: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodDiscriminatedUnion<[z.ZodObject<{
             providerId: z.ZodString;

package/dist/capabilities/user-passkeys.cap.d.ts

@@ -81,6 +81,24 @@ export declare const userPasskeysCapability: {
             success: z.ZodLiteral<true>;
             credentialId: z.ZodString;
         }, z.core.$strip>, "mutation">;
+        /**
+         * 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.
+         */
         readonly beginAuthentication: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             userId: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{

package/dist/capabilities/vector-store.cap.d.ts

@@ -164,6 +164,14 @@ export declare const VectorStatsResultSchema: z.ZodObject<{
     bytes: z.ZodOptional<z.ZodNumber>;
     exact: z.ZodBoolean;
 }, z.core.$strip>;
+/**
+ * `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.*`.
+ */
 export declare const vectorStoreCapability: {
     readonly name: "vector-store";
     readonly scope: "system";

package/dist/capabilities/viewer-ui.cap.d.ts

@@ -13,6 +13,21 @@ export declare const viewerUiCapability: {
     readonly mode: "singleton";
     readonly internal: true;
     readonly methods: {
+        /**
+         * `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.
+         */
         readonly getStaticDir: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
             staticDir: z.ZodString;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;

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
@@ -9522,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
@@ -9869,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"
@@ -9878,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"
@@ -9887,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
@@ -14666,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
@@ -19679,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,
 			/**
@@ -19691,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
@@ -19845,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
@@ -19855,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
@@ -19962,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
@@ -20337,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). */
@@ -20348,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. */
@@ -20361,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({
@@ -20541,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",
@@ -20548,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

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { t as EventCategory } from "./event-category-CIa_iT6b.mjs";
-import { $ as DecodedFrameSchema, A as event, B as ReadinessRegistry, C as DeviceFeature, Ct as isEvent, D as DEFAULT_RUNTIME_STATE_DURABILITY, Dt as collectHydratedFieldValues, E as adminUiCapability, Et as collectHydratedFieldEntries, F as systemMethod, G as BrokerStatsSchema, H as emitDownForOwnedCaps, I as CAP_NODE_PIN_CONTEXT_KEY, J as CamProfileSchema, K as BrokerStatusSchema, L as nodePin, M as isDeviceConfigCap, N as method, O as DEVICE_SETTINGS_CONTRIBUTION_METHODS, Ot as hydrateSchema, P as resolveCapMount, Q as DecodedAudioChunkSchema, R as readNodePin, S as ChargingStatus, St as emitReadiness, T as DeviceType, Tt as WELL_KNOWN_TAB_MAP, U as readinessKey, V as ReadinessTimeoutError, W as scopeKey, X as CamStreamResolutionSchema, Y as CamStreamKindSchema, Z as CameraStreamSchema, _ as createMirrorSource, _t as DisposerChain, a as asJsonObject, at as ProfileSlotStatusSchema, b as deviceOpsCapability, bt as createDurableState, c as parseJsonArray, ct as SubscribeAudioChunksInputSchema, d as BOOT_RECOVERY_BACKOFF_MS, dt as SubscribeFramesResultSchema, et as EncodedPacketSchema, f as DEVICE_SCOPED_CAPS, ft as makeProfileBrokerId, g as createLazyTrpcSource, gt as DATAPLANE_SECRET_HEADER, h as createEventBusSliceSource, ht as selectAssignedProfileSlots, i as asJsonArray, it as ProfileSlotSchema, j as expandCapMethods, k as DEVICE_STATUS_METHOD, kt as resolveHydratedFieldValue, l as parseJsonObject, lt as SubscribeAudioChunksResultSchema, m as createDeviceProxy, mt as parseProfileBrokerId, n as sleepCancellable, nt as FrameHandleSchema, o as asNumber, ot as StreamSourceEntrySchema, p as isDeviceScopedCap, pt as makeSourceBrokerId, q as CAM_PROFILE_ORDER, r as asBoolean, rt as ProfileRtspEntrySchema, s as asString, st as StreamSourceSchema, t as sleep, tt as FrameHandleFormatSchema, u as parseJsonUnknown, ut as SubscribeFramesInputSchema, v as createSliceHandle, vt as BaseAddon, w as DeviceRole, wt as WELL_KNOWN_TABS, x as viewerUiCapability, xt as createEvent, y as RawStateResultSchema, yt as normalizeAddonInitResult, z as toNodeId } from "./sleep-BLxqGLY0.mjs";
+import { $ as DecodedFrameSchema, A as event, B as ReadinessRegistry, C as DeviceFeature, Ct as isEvent, D as DEFAULT_RUNTIME_STATE_DURABILITY, Dt as collectHydratedFieldValues, E as adminUiCapability, Et as collectHydratedFieldEntries, F as systemMethod, G as BrokerStatsSchema, H as emitDownForOwnedCaps, I as CAP_NODE_PIN_CONTEXT_KEY, J as CamProfileSchema, K as BrokerStatusSchema, L as nodePin, M as isDeviceConfigCap, N as method, O as DEVICE_SETTINGS_CONTRIBUTION_METHODS, Ot as hydrateSchema, P as resolveCapMount, Q as DecodedAudioChunkSchema, R as readNodePin, S as ChargingStatus, St as emitReadiness, T as DeviceType, Tt as WELL_KNOWN_TAB_MAP, U as readinessKey, V as ReadinessTimeoutError, W as scopeKey, X as CamStreamResolutionSchema, Y as CamStreamKindSchema, Z as CameraStreamSchema, _ as createMirrorSource, _t as DisposerChain, a as asJsonObject, at as ProfileSlotStatusSchema, b as deviceOpsCapability, bt as createDurableState, c as parseJsonArray, ct as SubscribeAudioChunksInputSchema, d as BOOT_RECOVERY_BACKOFF_MS, dt as SubscribeFramesResultSchema, et as EncodedPacketSchema, f as DEVICE_SCOPED_CAPS, ft as makeProfileBrokerId, g as createLazyTrpcSource, gt as DATAPLANE_SECRET_HEADER, h as createEventBusSliceSource, ht as selectAssignedProfileSlots, i as asJsonArray, it as ProfileSlotSchema, j as expandCapMethods, k as DEVICE_STATUS_METHOD, kt as resolveHydratedFieldValue, l as parseJsonObject, lt as SubscribeAudioChunksResultSchema, m as createDeviceProxy, mt as parseProfileBrokerId, n as sleepCancellable, nt as FrameHandleSchema, o as asNumber, ot as StreamSourceEntrySchema, p as isDeviceScopedCap, pt as makeSourceBrokerId, q as CAM_PROFILE_ORDER, r as asBoolean, rt as ProfileRtspEntrySchema, s as asString, st as StreamSourceSchema, t as sleep, tt as FrameHandleFormatSchema, u as parseJsonUnknown, ut as SubscribeFramesInputSchema, v as createSliceHandle, vt as BaseAddon, w as DeviceRole, wt as WELL_KNOWN_TABS, x as viewerUiCapability, xt as createEvent, y as RawStateResultSchema, yt as normalizeAddonInitResult, z as toNodeId } from "./sleep-DCBRhx0s.mjs";
 import { a as buildAudioArgs, c as buildVideoArgs, d as logBannerArgs, f as pickVideoEncoder, i as audioPlanFromEncodeProfile, l as invocationFromEncodeProfile, n as Fmp4BoxSplitter, o as buildFfmpegArgs, r as AUDIO_PRESETS, s as buildInputArgs, t as canonicalHash, u as isSoftwareDecode } from "./canonical-hash-rO1sRmEK.mjs";
 import { EventSourceType } from "./enums.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
@@ -4348,7 +4348,18 @@ var addonPagesSourceCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { listPages: method(z.void(), 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: method(z.void(), z.array(AddonPageDeclarationSchema).readonly(), { auth: "admin" }) }
 };
 //#endregion
 //#region src/capabilities/addon-routes.cap.ts
@@ -4651,7 +4662,20 @@ var addonWidgetsSourceCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { listWidgets: method(z.void(), 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: method(z.void(), z.array(WidgetMetadataSchema).readonly(), { auth: "admin" }) }
 };
 //#endregion
 //#region src/capabilities/addon-widgets.cap.ts
@@ -7100,7 +7124,17 @@ var customModelRegistryCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { listModels: method(z.void(), 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: method(z.void(), z.array(CustomModelDescriptorSchema).readonly(), { auth: "admin" }) }
 };
 //#endregion
 //#region src/capabilities/settings-store.cap.ts
@@ -9521,13 +9555,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(z.object({
 			crop: z.instanceof(Uint8Array),
 			width: z.number(),
 			height: z.number()
-		}), EmbeddingResultSchema),
-		encodeText: method(z.object({ text: z.string() }), EmbeddingResultSchema),
-		getInfo: method(z.void(), EmbeddingInfoSchema)
+		}), EmbeddingResultSchema, { auth: "admin" }),
+		encodeText: method(z.object({ text: z.string() }), EmbeddingResultSchema, { auth: "admin" }),
+		getInfo: method(z.void(), EmbeddingInfoSchema, { auth: "admin" })
 	}
 };
 //#endregion
@@ -9868,7 +9909,23 @@ var llmRuntimeCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
-		complete: 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: method(LlmRuntimeCompleteInputSchema, LlmGenerateResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		ensureStarted: method(z.object({ runtime: ManagedRuntimeConfigSchema }), LlmRuntimeStatusSchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -9877,7 +9934,7 @@ var llmRuntimeCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		status: method(z.object({}), LlmRuntimeStatusSchema),
+		status: method(z.object({}), LlmRuntimeStatusSchema, { auth: "admin" }),
 		installModel: method(z.object({ model: ManagedModelRefSchema }), z.void(), {
 			kind: "mutation",
 			auth: "admin"
@@ -9886,8 +9943,8 @@ var llmRuntimeCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		listLocalModels: method(z.object({}), z.array(LlmNodeModelSchema)),
-		getDiskUsage: method(z.object({}), LlmRuntimeDiskUsageSchema)
+		listLocalModels: method(z.object({}), z.array(LlmNodeModelSchema), { auth: "admin" }),
+		getDiskUsage: method(z.object({}), LlmRuntimeDiskUsageSchema, { auth: "admin" })
 	}
 };
 //#endregion
@@ -14665,7 +14722,17 @@ var oauthIntegrationCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { getDescriptor: method(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: method(z.void(), OauthIntegrationDescriptorSchema, { auth: "admin" }) }
 };
 //#endregion
 //#region src/capabilities/pipeline-analytics.cap.ts
@@ -19678,6 +19745,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(z.object({
 			claims: SsoBridgeClaimsSchema,
 			/**
@@ -19690,8 +19771,8 @@ var ssoBridgeCapability = {
 			* linking rather than produce an eternal token.
 			*/
 			ttlSec: z.union([z.number().int().positive(), z.literal("never")]).optional()
-		}), z.object({ token: z.string() })),
-		verifyBridgeToken: method(z.object({ token: z.string() }), SsoBridgeClaimsSchema.nullable())
+		}), z.object({ token: z.string() }), { auth: "admin" }),
+		verifyBridgeToken: method(z.object({ token: z.string() }), SsoBridgeClaimsSchema.nullable(), { auth: "admin" })
 	}
 };
 //#endregion
@@ -19844,8 +19925,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(z.object({ locationId: z.string() }), EvictableUsageSchema),
+		getEvictableUsage: method(z.object({ locationId: 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
@@ -19854,7 +19942,10 @@ var storageEvictableCapability = {
 		evict: method(z.object({
 			locationId: z.string(),
 			targetBytes: z.number().int().positive()
-		}), EvictResultSchema, { kind: "mutation" })
+		}), EvictResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 //#endregion
@@ -19961,43 +20052,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(z.void(), ProviderInfoSchema),
+		getProviderInfo: method(z.void(), ProviderInfoSchema, { auth: "admin" }),
 		/** Validate config + probe connectivity. Called on add and on edit. */
 		testLocation: method(z.object({ config: z.record(z.string(), z.unknown()) }), TestLocationResultSchema, { auth: "admin" }),
 		resolve: method(z.object({
 			location: StorageLocationSchema,
 			relativePath: z.string()
-		}), z.string()),
+		}), z.string(), { auth: "admin" }),
 		write: method(z.object({
 			location: StorageLocationSchema,
 			relativePath: z.string(),
 			data: z.instanceof(Uint8Array)
-		}), z.void(), { kind: "mutation" }),
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		read: method(z.object({
 			location: StorageLocationSchema,
 			relativePath: z.string()
-		}), z.instanceof(Uint8Array)),
+		}), z.instanceof(Uint8Array), { auth: "admin" }),
 		exists: method(z.object({
 			location: StorageLocationSchema,
 			relativePath: z.string()
-		}), z.boolean()),
+		}), z.boolean(), { auth: "admin" }),
 		list: method(z.object({
 			location: StorageLocationSchema,
 			prefix: z.string().optional()
-		}), z.array(z.string()).readonly()),
+		}), z.array(z.string()).readonly(), { auth: "admin" }),
 		delete: method(z.object({
 			location: StorageLocationSchema,
 			relativePath: z.string()
-		}), z.void(), { kind: "mutation" }),
-		getAvailableSpace: method(z.object({ location: StorageLocationSchema }), z.number().nullable()),
-		beginUpload: method(BeginUploadInputSchema, BeginUploadResultSchema, { kind: "mutation" }),
-		writeChunk: method(WriteChunkInputSchema, z.void(), { kind: "mutation" }),
-		finalizeUpload: method(FinalizeUploadInputSchema, z.void(), { kind: "mutation" }),
-		abortUpload: method(AbortUploadInputSchema, z.void(), { kind: "mutation" }),
-		beginDownload: method(BeginDownloadInputSchema, BeginDownloadResultSchema, { kind: "mutation" }),
-		readChunk: method(ReadChunkInputSchema, z.instanceof(Uint8Array)),
-		endDownload: method(EndDownloadInputSchema, z.void(), { kind: "mutation" })
+		}), z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getAvailableSpace: method(z.object({ location: StorageLocationSchema }), z.number().nullable(), { auth: "admin" }),
+		beginUpload: method(BeginUploadInputSchema, BeginUploadResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		writeChunk: method(WriteChunkInputSchema, z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		finalizeUpload: method(FinalizeUploadInputSchema, z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		abortUpload: method(AbortUploadInputSchema, z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		beginDownload: method(BeginDownloadInputSchema, BeginDownloadResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		readChunk: method(ReadChunkInputSchema, z.instanceof(Uint8Array), { auth: "admin" }),
+		endDownload: method(EndDownloadInputSchema, z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 //#endregion
@@ -20336,9 +20466,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(z.object({ userId: z.string().optional() }), z.object({ optionsJSON: z.record(z.string(), z.unknown()) }), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		finishAuthentication: method(z.object({
 			/** Required — the user the assertion belongs to (verified). */
@@ -20347,11 +20496,13 @@ var userPasskeysCapability = {
 			response: z.record(z.string(), z.unknown())
 		}), z.object({ verified: z.boolean() }), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		beginDiscoverableAuthentication: method(z.object({}), z.object({ optionsJSON: z.record(z.string(), z.unknown()) }), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		finishDiscoverableAuthentication: method(z.object({ 
 		/** AuthenticationResponseJSON from the browser. */
@@ -20360,7 +20511,8 @@ response: z.record(z.string(), z.unknown()) }), z.object({
 			userId: z.string().nullable()
 		}), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		listPasskeys: method(z.object({ userId: z.string() }), z.array(PasskeySummarySchema), { auth: "admin" }),
 		removePasskey: method(z.object({
@@ -20540,6 +20692,14 @@ var VectorStatsResultSchema = z.object({
 	/** False when the backend ranks approximately. */
 	exact: 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",
@@ -20547,14 +20707,26 @@ var vectorStoreCapability = {
 	internal: true,
 	methods: {
 		/** Idempotent. Re-declaring with a different `dim` is an error, not a wipe. */
-		declareIndex: method(VectorDeclareIndexInputSchema, z.void(), { kind: "mutation" }),
-		upsert: method(VectorUpsertInputSchema, VectorUpsertResultSchema, { kind: "mutation" }),
-		query: method(VectorQueryInputSchema, VectorQueryResultSchema),
+		declareIndex: method(VectorDeclareIndexInputSchema, z.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" })
 	}
 };
 //#endregion

package/dist/{sleep-BLxqGLY0.mjs → sleep-DCBRhx0s.mjs}

@@ -2171,8 +2171,17 @@ var adminUiCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
-		getStaticDir: method(z.void(), StaticDirOutputSchema$1),
-		getVersion: method(z.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(z.void(), StaticDirOutputSchema$1, { auth: "admin" }),
+		getVersion: method(z.void(), VersionOutputSchema$1, { auth: "admin" })
 	}
 };
 //#endregion
@@ -2518,8 +2527,23 @@ var viewerUiCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
-		getStaticDir: method(z.void(), StaticDirOutputSchema),
-		getVersion: method(z.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(z.void(), StaticDirOutputSchema, { auth: "admin" }),
+		getVersion: method(z.void(), VersionOutputSchema, { auth: "admin" })
 	}
 };
 //#endregion

package/dist/{sleep-CUuoW-kk.js → sleep-OOwhyQIx.js}

@@ -2171,8 +2171,17 @@ var adminUiCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
-		getStaticDir: method(zod.z.void(), StaticDirOutputSchema$1),
-		getVersion: method(zod.z.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(zod.z.void(), StaticDirOutputSchema$1, { auth: "admin" }),
+		getVersion: method(zod.z.void(), VersionOutputSchema$1, { auth: "admin" })
 	}
 };
 //#endregion
@@ -2518,8 +2527,23 @@ var viewerUiCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
-		getStaticDir: method(zod.z.void(), StaticDirOutputSchema),
-		getVersion: method(zod.z.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(zod.z.void(), StaticDirOutputSchema, { auth: "admin" }),
+		getVersion: method(zod.z.void(), VersionOutputSchema, { auth: "admin" })
 	}
 };
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.2.107",
+  "version": "1.2.108",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",