@camstack/server 1.1.11 → 1.1.13

package/dist/api/core/cap-providers.js

@@ -787,6 +787,19 @@ function buildIntegrationsProvider(ar, eb, loggingService, capabilityRegistry) {
                 const supportsLocationImport = kind === 'device-adoption'
                     ? (d?.supportsLocationImport ?? m.supportsLocationImport ?? false)
                     : false;
+                // Integration wizard `mode` (LOCKED MODEL — supersedes `instanceMode`
+                // for wizard routing). Explicit manifest `mode` wins; otherwise derive:
+                //   1. broker cap AND a brokerKind → 'broker' (HA/MQTT shared session)
+                //   2. device-adoption (and NOT broker) → 'account'
+                //   3. device-provider only / old `instanceMode: unique` → 'standalone'
+                const explicitMode = d?.mode ?? m.mode;
+                const declaresBroker = capNames.includes('broker');
+                const mode = explicitMode ??
+                    (declaresBroker && brokerKind
+                        ? 'broker'
+                        : kind === 'device-adoption'
+                            ? 'account'
+                            : 'standalone');
                 return {
                     addonId: m.id,
                     name: m.name ?? m.id,
@@ -794,6 +807,7 @@ function buildIntegrationsProvider(ar, eb, loggingService, capabilityRegistry) {
                     iconUrl: icon ? `/api/addon-assets/${m.id}/${icon}` : null,
                     color,
                     instanceMode,
+                    mode,
                     discoveryMode,
                     kind,
                     brokerKind,

package/dist/api/trpc/cap-mount-helpers.js

@@ -1,10 +1,4 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireSingleton = requireSingleton;
-exports.requireDeviceScoped = requireDeviceScoped;
-exports.concatCollection = concatCollection;
-exports.firstSupported = firstSupported;
-exports.anySupports = anySupports;
 /**
  * Small helpers for wiring capability routers to the `CapabilityRegistry`
  * in `trpc.router.ts`. These functions don't generate code — they just
@@ -25,6 +19,12 @@ exports.anySupports = anySupports;
  * provider responsible for a given `streamId`) are NOT covered here —
  * they have app-specific routing logic that belongs in the mount.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireSingleton = requireSingleton;
+exports.requireDeviceScoped = requireDeviceScoped;
+exports.concatCollection = concatCollection;
+exports.firstSupported = firstSupported;
+exports.anySupports = anySupports;
 const server_1 = require("@trpc/server");
 /**
  * Fetch the currently active singleton provider for a capability.
@@ -34,27 +34,6 @@ const server_1 = require("@trpc/server");
 function requireSingleton(registry, capName) {
     return registry?.getSingleton(capName) ?? null;
 }
-/**
- * Build a per-device dispatcher that satisfies the singleton-provider
- * shape but resolves the actual implementation lazily via
- * `registry.getNativeProvider(capName, deviceId)` on every method call.
- *
- * Use for device-scoped caps that have NO system-level wrapper (PTZ,
- * reboot, doorbell, brightness, motion-trigger, switch, …) — drivers
- * register per-device native providers via
- * `DeviceContext.registerNativeCap`, and this helper bridges the cap-
- * router's "fetch a singleton then call methods on it" flow into a
- * "resolve native by deviceId per call" flow.
- *
- * Method input MUST carry `deviceId: number`. Methods without that
- * field (auto-injected `getStatus({deviceId})` for caps with a status
- * block, every business method that follows the cap-definition
- * convention) work transparently.
- *
- * Throws PRECONDITION_FAILED with a device-specific message when no
- * native provider exists for the requested deviceId — much friendlier
- * than the singleton fallthrough's "no provider" generic error.
- */
 function requireDeviceScoped(registry, capName) {
     if (!registry)
         return null;

package/dist/api/trpc/cap-router-runtime.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * Server-side glue for the runtime cap-router builder (BIG PLAN 2).
+ *
+ * `@camstack/system` `buildCapRouters(primitives, services)` owns the
+ * per-cap router CONSTRUCTION (procedure shapes + node routing), but it
+ * holds no tRPC primitives and no backend services. This module supplies
+ * both:
+ *
+ *   - `primitives` — the `t`-half: `trpcRouter`, the auth procedures, and
+ *     `iterableSubscription`, taken from `trpc.middleware`.
+ *   - `services`   — the provider-resolution half: `getLocalProvider`
+ *     (mirrors the codegen `generate-cap-mounts.ts` decision per mount
+ *     kind), the cross-node `remoteProxy`, and the canonical tRPC error
+ *     raisers (the server owns `TRPCError`).
+ *
+ * The result is spread into the AppRouter BEFORE the hand-written core
+ * routers + the `custom`-mount overrides (snapshot-provider, webrtc-
+ * session), so override-by-spread precedence is preserved exactly as it
+ * was with the old static `mountAllCaps()` spread.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCapRouterPrimitives = createCapRouterPrimitives;
+exports.createCapRouterServices = createCapRouterServices;
+exports.buildRuntimeCapRouters = buildRuntimeCapRouters;
+const system_1 = require("@camstack/system");
+const types_1 = require("@camstack/types");
+const server_1 = require("@trpc/server");
+const cap_mount_helpers_js_1 = require("./cap-mount-helpers.js");
+const trpc_middleware_js_1 = require("./trpc.middleware.js");
+/**
+ * Pre-computed set of capName → array-output method names for collection
+ * caps, derived once from the cap defs at module init. Mirrors
+ * `generate-cap-mounts.ts` `isArrayOutputSchema` so the runtime collection
+ * resolver fans the SAME methods the codegen used to.
+ */
+const COLLECTION_ARRAY_METHODS = computeArrayMethods();
+function computeArrayMethods() {
+    const out = new Map();
+    for (const def of types_1.ALL_CAPABILITY_DEFINITIONS) {
+        if (def.mode !== 'collection')
+            continue;
+        const names = [];
+        for (const [name, schema] of Object.entries(def.methods)) {
+            const m = schema;
+            if (m.kind === 'subscription')
+                continue;
+            if (isArrayOutputSchema(m.output))
+                names.push(name);
+        }
+        if (names.length > 0)
+            out.set(def.name, names);
+    }
+    return out;
+}
+/**
+ * Structural "is this Zod schema an array output" check — bottoms out at
+ * `ZodArray` through the canonical Zod 4 wrappers. Identical logic to
+ * `scripts/generate-cap-mounts.ts`.
+ */
+function isArrayOutputSchema(schema) {
+    let cur = schema;
+    for (let depth = 0; depth < 8 && cur != null; depth += 1) {
+        const def = cur._def;
+        const ctor = cur.constructor?.name;
+        if (ctor === 'ZodArray' || def?.type === 'array')
+            return true;
+        const wraps = ctor === 'ZodReadonly' ||
+            def?.type === 'readonly' ||
+            ctor === 'ZodOptional' ||
+            def?.type === 'optional' ||
+            ctor === 'ZodNullable' ||
+            def?.type === 'nullable' ||
+            ctor === 'ZodDefault' ||
+            def?.type === 'default';
+        if (!wraps || def?.innerType == null)
+            return false;
+        cur = def.innerType;
+    }
+    return false;
+}
+/**
+ * Resolve a collection cap's provider exactly as the codegen-emitted
+ * mount did:
+ *   - `addonId` set → that addon's provider directly (bypasses the
+ *     enabled/disabled filter — an explicit addonId must always hit that
+ *     exact provider).
+ *   - else, for caps with array-output methods → an AGGREGATE provider
+ *     whose array methods are `concatCollection`-fanned across every
+ *     ENABLED provider; non-array methods fall through to the first.
+ *   - else → the first enabled provider.
+ */
+function resolveCollectionProvider(reg, capName, addonId) {
+    if (!reg)
+        return null;
+    if (addonId !== undefined) {
+        return reg.getProviderByAddonId(capName, addonId);
+    }
+    const entries = reg.getCollectionEntries(capName);
+    if (entries.length === 0)
+        return null;
+    const providers = entries.map(([, p]) => p);
+    const first = providers[0];
+    if (first === undefined)
+        return null;
+    const arrayMethods = COLLECTION_ARRAY_METHODS.get(capName);
+    if (!arrayMethods || arrayMethods.length === 0)
+        return first;
+    const aggregate = { ...first };
+    for (const method of arrayMethods) {
+        aggregate[method] = concatArrayMethod(providers, method);
+    }
+    return aggregate;
+}
+/**
+ * Fan an array-returning method across every provider and flatten the
+ * results — the runtime equivalent of `concatCollection` for the
+ * structural `ResolvedProvider` shape (which a string method key can't
+ * satisfy `concatCollection`'s `ArrayReturningMethodKey<T>` constraint).
+ * Behaviour matches `concatCollection`: non-function / non-array results
+ * contribute nothing.
+ */
+function concatArrayMethod(providers, method) {
+    return async (input) => {
+        const results = await Promise.all(providers.map(async (p) => {
+            const fn = p[method];
+            if (typeof fn !== 'function')
+                return [];
+            const out = await fn(input);
+            return Array.isArray(out) ? out : [];
+        }));
+        return results.flat();
+    };
+}
+/** Build the `primitives` half of `buildCapRouters(primitives, services)`. */
+function createCapRouterPrimitives() {
+    const procedures = {
+        public: trpc_middleware_js_1.publicProcedure,
+        protected: trpc_middleware_js_1.protectedProcedure,
+        admin: trpc_middleware_js_1.adminProcedure,
+    };
+    return {
+        // Documented type boundary: the builder hands a record of REAL tRPC
+        // procedures typed structurally as `unknown` (it can't see the
+        // server's procedure types). `trpcRouter` (`t.router`) expects
+        // `CreateRouterOptions`; the runtime values satisfy it. Narrow at this
+        // single seam so the rest of the builder stays free of `@trpc/server`
+        // internal types — mirrors the existing `remoteCapProxy` cast pattern.
+        router: (procs) => (0, trpc_middleware_js_1.trpcRouter)(procs),
+        procedures,
+        iterableSubscription: trpc_middleware_js_1.iterableSubscription,
+    };
+}
+/** Build the `services` half of `buildCapRouters(primitives, services)`. */
+function createCapRouterServices(deps) {
+    const reg = deps.capabilityRegistry;
+    const remoteProxy = (capName, nodeId) => deps.moleculer.createCapabilityProxy(capName, nodeId);
+    const getLocalProvider = (capName, mountKind, ctx, addonId) => {
+        switch (mountKind) {
+            case 'service-backed': {
+                const factory = deps.serviceProviders[capName];
+                return factory ? factory(ctx) : null;
+            }
+            case 'device-native':
+                return (0, cap_mount_helpers_js_1.requireDeviceScoped)(reg, capName);
+            case 'collection':
+                return resolveCollectionProvider(reg, capName, addonId);
+            // singleton / per-node / hub-only resolve the active singleton.
+            default:
+                return reg?.getSingleton(capName) ?? null;
+        }
+    };
+    return {
+        getLocalProvider,
+        remoteProxy,
+        noProvider: (capName, nodeId) => {
+            if (nodeId !== undefined && nodeId !== 'hub') {
+                throw new server_1.TRPCError({
+                    code: 'PRECONDITION_FAILED',
+                    message: `Capability "${capName}" not available on node "${nodeId}"`,
+                });
+            }
+            throw new server_1.TRPCError({
+                code: 'PRECONDITION_FAILED',
+                message: `Capability "${capName}" provider not available`,
+            });
+        },
+        noNodeRouting: (capName) => {
+            throw new server_1.TRPCError({
+                code: 'BAD_REQUEST',
+                message: `Node routing not available for "${capName}"`,
+            });
+        },
+        badRequest: (message) => {
+            throw new server_1.TRPCError({ code: 'BAD_REQUEST', message });
+        },
+    };
+}
+/**
+ * Build the runtime cap-router map (the dynamic value). Returns
+ * `Record<string, unknown>` — the caller assigns it to the static
+ * `ReturnType<typeof mountAllCaps>` type at the single documented
+ * boundary so the AppRouter TYPE stays codegen-derived while the VALUE is
+ * built at runtime from `ALL_CAPABILITY_DEFINITIONS`.
+ */
+function buildRuntimeCapRouters(deps) {
+    return (0, system_1.buildCapRouters)(createCapRouterPrimitives(), createCapRouterServices(deps));
+}

package/dist/api/trpc/generated-cap-routers.js

@@ -1669,6 +1669,24 @@ function createCapRouter_climateControl(getProvider, createRemoteProxy) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
             return p.setTargetHumidity(methodInput);
         }),
+        setSwingVertical: trpc_middleware_js_1.adminProcedure
+            .input(types_28.climateControlCapability.methods.setSwingVertical.input.loose())
+            .output(types_28.climateControlCapability.methods.setSwingVertical.output)
+            .mutation(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('climate-control', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.setSwingVertical(methodInput);
+        }),
+        setSwingHorizontal: trpc_middleware_js_1.adminProcedure
+            .input(types_28.climateControlCapability.methods.setSwingHorizontal.input.loose())
+            .output(types_28.climateControlCapability.methods.setSwingHorizontal.output)
+            .mutation(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('climate-control', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.setSwingHorizontal(methodInput);
+        }),
     });
 }
 function createCapRouter_color(getProvider, createRemoteProxy) {

package/dist/api/trpc/trpc.router.js

@@ -3,24 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enrichInputWithUserAgent = enrichInputWithUserAgent;
 exports.wrapWebrtcSessionProviderWithRelay = wrapWebrtcSessionProviderWithRelay;
 exports.buildAppRouter = buildAppRouter;
-const trpc_middleware_1 = require("./trpc.middleware");
-const generated_cap_routers_1 = require("./generated-cap-routers");
-const generated_cap_mounts_js_1 = require("./generated-cap-mounts.js");
-const cap_providers_js_1 = require("../core/cap-providers.js");
-const auth_router_js_1 = require("../core/auth.router.js");
 const addon_settings_router_js_1 = require("../core/addon-settings.router.js");
-const settings_backend_router_js_1 = require("../core/settings-backend.router.js");
+const auth_router_js_1 = require("../core/auth.router.js");
+const cap_providers_js_1 = require("../core/cap-providers.js");
+const capabilities_router_js_1 = require("../core/capabilities.router.js");
 const event_bus_proxy_router_js_1 = require("../core/event-bus-proxy.router.js");
-const repl_router_js_1 = require("../core/repl.router.js");
-const notifications_router_js_1 = require("../core/notifications.router.js");
-const logs_router_js_1 = require("../core/logs.router.js");
-const system_events_router_js_1 = require("../core/system-events.router.js");
+const hwaccel_router_js_1 = require("../core/hwaccel.router.js");
 const live_events_router_js_1 = require("../core/live-events.router.js");
-const capabilities_router_js_1 = require("../core/capabilities.router.js");
+const logs_router_js_1 = require("../core/logs.router.js");
+const notifications_router_js_1 = require("../core/notifications.router.js");
+const repl_router_js_1 = require("../core/repl.router.js");
+const settings_backend_router_js_1 = require("../core/settings-backend.router.js");
 const stream_probe_router_js_1 = require("../core/stream-probe.router.js");
-const hwaccel_router_js_1 = require("../core/hwaccel.router.js");
+const system_events_router_js_1 = require("../core/system-events.router.js");
 const cap_mount_helpers_js_1 = require("./cap-mount-helpers.js");
+const cap_router_runtime_js_1 = require("./cap-router-runtime.js");
 const client_ip_js_1 = require("./client-ip.js");
+const generated_cap_routers_1 = require("./generated-cap-routers");
+const trpc_middleware_1 = require("./trpc.middleware");
 /**
  * Merge the server-read User-Agent into a signaling call's
  * `consumerAttribution`, building a NEW input object (immutable — never
@@ -66,31 +66,73 @@ function wrapWebrtcSessionProviderWithRelay(provider, ctx) {
     };
 }
 /**
- * Build the AppRouter. Mounts every codegen'd cap router via the auto-
- * mount entrypoint and overrides the handful that need service-backed
- * providers or custom collection dispatch. Non-cap (core) routers ride
- * alongside in the same root object.
+ * Build the service-backed provider factory map (BIG PLAN 2). Caps marked
+ * `mount: { kind: 'service-backed' }` have NO addon-registered provider —
+ * the provider is composed from backend services. The runtime builder
+ * resolves them through this map (keyed by cap NAME) instead of the
+ * registry, keeping backend composition in `@camstack/server` (the
+ * self-sufficiency invariant — `@camstack/system` never touches a backend
+ * service). Each factory receives the per-request tRPC `ctx`.
+ */
+function buildServiceProviders(services) {
+    const wrap = (fn) => (ctx) => fn(ctx);
+    return {
+        'network-quality': wrap(() => (0, cap_providers_js_1.buildNetworkQualityProvider)(services.networkQualityService)),
+        system: wrap(() => (0, cap_providers_js_1.buildSystemProvider)(services.featureService, services.capabilityRegistry)),
+        toast: wrap((ctx) => (0, cap_providers_js_1.buildToastProvider)(services.toastService, ctx)),
+        integrations: wrap(() => (0, cap_providers_js_1.buildIntegrationsProvider)(services.addonRegistry, services.eventBus, services.loggingService, services.capabilityRegistry)),
+        nodes: wrap(() => (0, cap_providers_js_1.buildNodesProvider)(services.agentRegistry, services.moleculer, services.addonRegistry)),
+        addons: wrap((ctx) => (0, cap_providers_js_1.buildAddonsProvider)(services.addonRegistry, services.addonPackageService, services.loggingService, services.moleculer, services.configService, ctx)),
+    };
+}
+/**
+ * Build the AppRouter capability track (BIG PLAN 2).
  *
- * Override-by-spread: spread `mountAllCaps(services)` first, then the
- * overrides AFTER — the later property wins. The drift guard in
- * `scripts/codegen.ts` ensures every codegen'd `createCapRouter_X` is
- * present in the auto-mount inventory (or explicitly in the legacy
- * skip-list), so the override list below NEVER needs to add a new entry
- * just to mount a new cap — only to swap in a custom provider.
+ * The per-cap router CONSTRUCTION now lives in `@camstack/system`
+ * (`buildCapRouters`), driven at runtime by `ALL_CAPABILITY_DEFINITIONS`
+ * + the declarative `mount` hint on each cap def. A capability update
+ * therefore ships via the framework plugin (`@camstack/types` +
+ * `@camstack/system`) with NO `@camstack/server` rebuild — the value is
+ * dynamic.
+ *
+ * The AppRouter TYPE stays codegen-derived: the dynamic value is assigned
+ * to `ReturnType<typeof mountAllCaps>` (the generated per-cap router type
+ * map) at the single documented type boundary below, so the SDK keeps
+ * full procedure inference and `generate-api-types.ts` resolves the same
+ * expanded type as before.
+ *
+ * Override-by-spread is preserved: spread the dynamic caps first, then the
+ * hand-written core routers + the two `custom`-mount overrides
+ * (snapshot-provider's probe fan-out, webrtc-session's relay enrichment),
+ * which the generic builder intentionally leaves unmounted for the server
+ * to fill.
  */
 function buildCapabilityRouters(services) {
+    // ── Dynamic cap routers (value) → static cap-router map (type). ──────
+    // The runtime builder returns `Record<string, unknown>`; assigning it to
+    // `ReturnType<typeof mountAllCaps>` is the documented type boundary that
+    // keeps the AppRouter type codegen-derived while the value is built from
+    // the cap defs at runtime. `mountAllCaps` is imported for its TYPE only
+    // (`import type`) — its value is never called; the codegen
+    // `generated-cap-mounts.ts` / `generated-cap-routers.ts` remain the TYPE
+    // source of record.
+    const dynamicCaps = (0, cap_router_runtime_js_1.buildRuntimeCapRouters)({
+        capabilityRegistry: services.capabilityRegistry,
+        moleculer: services.moleculer,
+        serviceProviders: buildServiceProviders(services),
+    });
     return {
-        // ── Auto-mount: every codegen'd cap router with a canonical
-        //    provider shape. Everything below this line OVERRIDES the
-        //    auto-mount entry for caps with service-backed providers,
-        //    custom collection routing, or a hub-only `null` remote proxy.
-        ...(0, generated_cap_mounts_js_1.mountAllCaps)(services),
+        // ── Runtime-built cap routers: every cap whose mount is
+        //    `singleton` / `collection` / `device-native` / `service-backed`
+        //    / `hub-only`. `custom` + `skip` caps are NOT here — `skip` is
+        //    never mounted; `custom` is filled by the overrides below. ──────
+        ...dynamicCaps,
         // ── Non-cap (core) routers — hand-written, single-impl ──────────
         notifications: (0, notifications_router_js_1.createNotificationsRouter)(services.notificationService),
         // Raw DB proxy for forked workers to read/write addon store.
         // Workers use ctx.api.addonSettingsRaw.getGlobal.query({...}).
-        // NOT the three-level settings gateway — that's the codegen'd
-        // `addonSettings` cap router (mounted via auto-mount above).
+        // NOT the three-level settings gateway — that's the
+        // `addonSettings` cap router (mounted dynamically above).
         addonSettingsRaw: (0, addon_settings_router_js_1.createAddonSettingsRouter)(services.configService),
         settingsBackend: (0, settings_backend_router_js_1.createSettingsBackendRouter)(() => services.addonRegistry.getSettingsBackend()),
         eventBusProxy: (0, event_bus_proxy_router_js_1.createEventBusProxyRouter)(services.eventBus),
@@ -106,46 +148,11 @@ function buildCapabilityRouters(services) {
         // which hardware backend each agent will use.
         hwaccel: (0, hwaccel_router_js_1.createHwAccelRouter)(services.moleculer?.broker ?? null),
         auth: (0, auth_router_js_1.createAuthRouter)(services.authService, services.capabilityRegistry),
-        // ── Cap overrides: service-backed providers ─────────────────────
-        // These caps don't have an addon registering a provider in the
-        // CapabilityRegistry — the provider is built on-demand from
-        // backend services. `mountAllCaps` would return `null` for them
-        // (registry lookup miss), so we re-mount with `buildXProvider`.
-        networkQuality: (0, generated_cap_routers_1.createCapRouter_networkQuality)((_ctx) => (0, cap_providers_js_1.buildNetworkQualityProvider)(services.networkQualityService)),
-        system: (0, generated_cap_routers_1.createCapRouter_system)((_ctx) => (0, cap_providers_js_1.buildSystemProvider)(services.featureService, services.capabilityRegistry)),
-        toast: (0, generated_cap_routers_1.createCapRouter_toast)((ctx) => (0, cap_providers_js_1.buildToastProvider)(services.toastService, ctx)),
-        integrations: (0, generated_cap_routers_1.createCapRouter_integrations)((_ctx) => (0, cap_providers_js_1.buildIntegrationsProvider)(services.addonRegistry, services.eventBus, services.loggingService, services.capabilityRegistry)),
-        nodes: (0, generated_cap_routers_1.createCapRouter_nodes)((_ctx) => (0, cap_providers_js_1.buildNodesProvider)(services.agentRegistry, services.moleculer, services.addonRegistry)),
-        addons: (0, generated_cap_routers_1.createCapRouter_addons)((ctx) => (0, cap_providers_js_1.buildAddonsProvider)(services.addonRegistry, services.addonPackageService, services.loggingService, services.moleculer, services.configService, ctx)),
-        // ── Cap overrides: cross-node remote-proxy cast ─────────────────
-        // These caps' providers have manual interface types that pre-date
-        // `InferProvider<typeof xCap>` — structurally identical, nominally
-        // distinct. Casting at the override site is cheaper than reworking
-        // the provider declarations. Auto-mount can't infer the cast.
-        pipelineExecutor: (0, generated_cap_routers_1.createCapRouter_pipelineExecutor)((_ctx) => (0, cap_mount_helpers_js_1.requireSingleton)(services.capabilityRegistry, 'pipeline-executor'), (capName, nodeId) => services.moleculer.createCapabilityProxy(capName, nodeId)),
-        pipelineRunner: (0, generated_cap_routers_1.createCapRouter_pipelineRunner)((_ctx) => (0, cap_mount_helpers_js_1.requireSingleton)(services.capabilityRegistry, 'pipeline-runner'), (capName, nodeId) => services.moleculer.createCapabilityProxy(capName, nodeId)),
-        pipelineOrchestrator: (0, generated_cap_routers_1.createCapRouter_pipelineOrchestrator)((_ctx) => (0, cap_mount_helpers_js_1.requireSingleton)(services.capabilityRegistry, 'pipeline-orchestrator'), (capName, nodeId) => services.moleculer.createCapabilityProxy(capName, nodeId)),
-        audioAnalyzer: (0, generated_cap_routers_1.createCapRouter_audioAnalyzer)((_ctx) => (0, cap_mount_helpers_js_1.requireSingleton)(services.capabilityRegistry, 'audio-analyzer'), (capName, nodeId) => services.moleculer.createCapabilityProxy(capName, nodeId)),
-        audioCodec: (0, generated_cap_routers_1.createCapRouter_audioCodec)((_ctx) => (0, cap_mount_helpers_js_1.requireSingleton)(services.capabilityRegistry, 'audio-codec'), (capName, nodeId) => services.moleculer.createCapabilityProxy(capName, nodeId)),
-        decoder: (0, generated_cap_routers_1.createCapRouter_decoder)((_ctx) => (0, cap_mount_helpers_js_1.requireSingleton)(services.capabilityRegistry, 'decoder'), (capName, nodeId) => services.moleculer.createCapabilityProxy(capName, nodeId)),
-        modelConvert: (0, generated_cap_routers_1.createCapRouter_modelConvert)((_ctx) => (0, cap_mount_helpers_js_1.requireSingleton)(services.capabilityRegistry, 'model-convert'), (capName, nodeId) => services.moleculer.createCapabilityProxy(capName, nodeId)),
-        platformProbe: (0, generated_cap_routers_1.createCapRouter_platformProbe)((_ctx) => (0, cap_mount_helpers_js_1.requireSingleton)(services.capabilityRegistry, 'platform-probe'), (capName, nodeId) => services.moleculer.createCapabilityProxy(capName, nodeId)),
-        // ── Cap overrides: hub-only, no remote fallback ─────────────────
-        // The cap is intentionally single-node; agents are not directly
-        // addressable. Auto-mount would still set up a proxy factory; we
-        // explicitly return `null` to short-circuit any cross-node attempt.
-        localNetwork: (0, generated_cap_routers_1.createCapRouter_localNetwork)((_ctx) => (0, cap_mount_helpers_js_1.requireSingleton)(services.capabilityRegistry, 'local-network'), (_capName, _nodeId) => null),
-        // ── Cap overrides: collection dispatch (contribution / probe) ──
-        // `turn-provider.getTurnServers` is now handled generically by the
-        // auto-mount: it's an array-output method on a `collection` cap, so
-        // `mountAllCaps` fans it across every enabled provider via
-        // `concatCollection` when no `addonId` is supplied. No hand-written
-        // override needed.
-        //
+        // ── Cap overrides: `mount: { kind: 'custom' }` ──────────────────
         // `snapshot-provider.supportsDevice` is an OR across providers;
         // `getSnapshot` picks the first one that claims the device. The
-        // generic first-provider resolver from the auto-mount can't model
-        // this — we hand-write the probe + fan-out logic.
+        // generic builder's first-provider/concat collection resolver can't
+        // model this — we hand-write the probe + fan-out logic.
         snapshotProvider: (0, generated_cap_routers_1.createCapRouter_snapshotProvider)((_ctx) => {
             const reg = services.capabilityRegistry;
             if (!reg)
@@ -157,29 +164,25 @@ function buildCapabilityRouters(services) {
             const getSnapshot = (0, cap_mount_helpers_js_1.firstSupported)(providers, 'supportsDevice', 'getSnapshot');
             return { supportsDevice, getSnapshot };
         }),
-        // ── Cap override: server-detected remote → relay-only ────────────
-        // The broker (a forked addon) can't see the HTTP request, so it
-        // can't tell a LAN viewer from a remote one. We override only the
-        // `getProvider` accessor to return a per-request provider whose
-        // `createSession` carries a server-computed `relayOnly` flag derived
-        // from the client IP in `ctx.req`. Remote (CGNAT/4G) viewers force
-        // TURN-relay-only ICE; LAN viewers keep the direct host/srflx path.
-        // All other methods delegate straight through, and the cross-node
-        // remote-proxy routing is preserved (forked/agent-hosted brokers).
+        // `webrtc-session` — server-detected remote → relay-only. The broker
+        // (a forked addon) can't see the HTTP request, so it can't tell a LAN
+        // viewer from a remote one. We override `getProvider` to return a
+        // per-request provider whose `createSession` carries a server-computed
+        // `relayOnly` flag derived from the client IP in `ctx.req`. Remote
+        // (CGNAT/4G) viewers force TURN-relay-only ICE; LAN viewers keep the
+        // direct host/srflx path. All other methods delegate straight through,
+        // and the cross-node remote-proxy routing is preserved (forked/agent-
+        // hosted brokers).
         webrtcSession: (0, generated_cap_routers_1.createCapRouter_webrtcSession)((ctx) => {
             const provider = services.capabilityRegistry?.getSingleton('webrtc-session') ?? null;
             return provider ? wrapWebrtcSessionProviderWithRelay(provider, ctx) : null;
         }, (capName, nodeId) => services.moleculer.createCapabilityProxy(capName, nodeId)),
-        // NOT MOUNTED — legacy provider shapes (positional args / sync
-        // returns) that don't match the codegen routers' {input}-object +
-        // Promise<T> contract. Tracked by `LEGACY_SHAPE_SKIP` in
-        // `generated-cap-mounts.ts` until the provider refactor (task #195):
-        //   - addon-routes        (IAddonRouteProvider: getRoutes sync)
-        //   - auth-provider       (IAuthProvider: positional credentials)
-        //   - log-destination     (ILogDestination: positional + extra lifecycle)
-        //   - restreamer          (IRestreamer: registerDevice positional)
-        //   - streaming-engine    (IStreamingEngine: registerStream positional)
-        //   - webrtc              (IWebRtcProvider: missing hasAdaptiveBitrate)
+        // NOT MOUNTED — `mount: { kind: 'skip' }` legacy provider shapes
+        // (positional args / sync returns) that don't match the codegen
+        // routers' {input}-object + Promise<T> contract. The runtime builder
+        // skips them via `resolveCapMount` (task #195):
+        //   - addon-routes / auth-provider / log-destination
+        //   - restreamer / streaming-engine / webrtc
     };
 }
 function buildAppRouter(services) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "1.1.11",
+  "version": "1.1.13",
   "private": false,
   "files": [
     "dist",