@camstack/system 1.2.390 → 1.2.391

package/dist/kernel/moleculer/cap-usage-registry.d.ts

@@ -1,171 +1,126 @@
 /**
- * In-memory observation of tRPC cap calls between addons — the store behind
- * `nodes.getCapUsageGraph`.
- *
- * Storage: `Map<callerAddonId, Map<providerAddonId, Map<capName, RollingWindow>>>`.
- * `RollingWindow` is a fixed-size ring of 1-second buckets — default 300
- * buckets = 5 minutes retention. Queries narrower than the retention window
- * filter buckets at read time.
- *
- * ── The ring ages, and that is not free decoration ─────────────────────────
- * Buckets are indexed `second % retention`, so a bucket written at second S is
- * hit again at S + retention·k forever. Until 2026-08-30 nothing ever zeroed
- * them: the `lastCallAtMs` guard hid it while a triple was fully idle, but ONE
- * fresh call re-armed the entire stale ring. A triple that made 1000 calls and
- * then one call five minutes later reported **1001 calls/min instead of 1**.
- * An over-counted edge is worse than the empty graph this instrument shipped
- * with — silence invites doubt, a confident wrong number sends the next
- * investigation at the wrong addon.
- *
- * The fix is clear-forward: on each record, zero the buckets the ring has
- * ADVANCED over since the previous write, and never read past the last written
- * second. Amortised O(1) — a busy triple clears 0–1 buckets per call, and an
- * idle one clears at most `retention` once, when it wakes.
- *
- * ── Cardinality is bounded, because this map lives on hub-main ─────────────
- * The previous docblock claimed "~22 MB worst case … under 200 KB at ~10 active
- * triples". Both numbers were written for a smaller machine and the second was
- * an assumption, not a bound: the key space is caller × provider × cap, and on
- * the live hub that is 64 addons × 64 runners × ~150 caps. Nothing capped it.
- *
- * Today a ring is one `Uint32Array(retention)` — 1.2 KB of ArrayBuffer at the
- * default — plus the three Map entries that reach it. MEASURED (`heapUsed` +
- * `arrayBuffers`, node 24, `--expose-gc`): **1.7 KB per triple**, so ≈1.0 MB at
- * the realistic hub figure (64 callers × a handful of caps each, ≈600 triples)
- * and **6.3 MB at the {@link DEFAULT_MAX_TRIPLES} ceiling**. `recordCall` costs
- * ≈46 ns (1e6 calls in 46 ms) — at the 39 717 calls/min that started this
- * investigation, ≈30 µs of hub-main per second.
- *
- * Reclamation is what keeps it at the low end: a triple whose ring has entirely
- * aged out is dead data and is dropped on the next admission sweep. The hard
- * cap only exists so that a pathological key space (a caller id derived from
- * something unbounded) cannot take hub-main's heap with it — and when it bites,
- * {@link CapUsageRegistry.getStats} says how often, because an instrument that
- * truncates silently is the defect this whole file exists to fix (D237).
- */
-/**
- * Provider placeholder for a call the PARENT routed rather than short-
- * circuiting to a sibling runner: hub-in-process (`settings-store`,
- * `device-manager`, the `$core-caps` bridge), or a remote node. At the layer
- * that records — the parent's `cap-call-out` handler — the sibling id IS the
- * provider and everything else has not been resolved yet.
- *
- * It is a NAMED unknown, not a dropped observation, for the reason D237 was
- * written: the caller is always known, and "who is hammering `settings-store`"
- * is the question this graph exists to answer. Sibling to
- * `UNRESOLVED_PROVIDER_ADDON_ID` in `trpc-links.ts`, which names the same kind
- * of unknown one layer up.
- */
+* Provider placeholder for a call the PARENT routed rather than short-
+* circuiting to a sibling runner: hub-in-process (`settings-store`,
+* `device-manager`, the `$core-caps` bridge), or a remote node. At the layer
+* that records — the parent's `cap-call-out` handler — the sibling id IS the
+* provider and everything else has not been resolved yet.
+*
+* It is a NAMED unknown, not a dropped observation, for the reason D237 was
+* written: the caller is always known, and "who is hammering `settings-store`"
+* is the question this graph exists to answer. Sibling to
+* `UNRESOLVED_PROVIDER_ADDON_ID` in `trpc-links.ts`, which names the same kind
+* of unknown one layer up.
+*/
 export declare const PARENT_ROUTED_PROVIDER_ADDON_ID = "(unresolved: parent-routed)";
 export interface CapUsageCallRecord {
-    readonly callerAddonId: string;
-    readonly providerAddonId: string;
-    readonly capName: string;
-    readonly methodName: string;
-    readonly atMs: number;
+	readonly callerAddonId: string;
+	readonly providerAddonId: string;
+	readonly capName: string;
+	readonly methodName: string;
+	readonly atMs: number;
 }
 /**
- * One observed caller → provider → cap edge.
- *
- * There is deliberately no `methodName`: the ring is keyed by CAPABILITY, so
- * `deviceManager.getAllBindings` (the whole fleet) and
- * `deviceManager.getBindings` (one camera) collapse into the same edge. The
- * method IS recorded on the way in ({@link CapUsageCallRecord.methodName}) and
- * discarded here. Splitting the key by method would multiply cardinality by the
- * per-cap method count — worth doing, but it is a schema change to
- * `nodes.getCapUsageGraph`, not a quiet widening of a map on hub-main.
- */
+* One observed caller → provider → cap edge.
+*
+* There is deliberately no `methodName`: the ring is keyed by CAPABILITY, so
+* `deviceManager.getAllBindings` (the whole fleet) and
+* `deviceManager.getBindings` (one camera) collapse into the same edge. The
+* method IS recorded on the way in ({@link CapUsageCallRecord.methodName}) and
+* discarded here. Splitting the key by method would multiply cardinality by the
+* per-cap method count — worth doing, but it is a schema change to
+* `nodes.getCapUsageGraph`, not a quiet widening of a map on hub-main.
+*/
 export interface CapUsageEdge {
-    readonly callerAddonId: string;
-    readonly providerAddonId: string;
-    readonly capName: string;
-    readonly callsPerMin: number;
-    readonly lastCallAtMs: number;
+	readonly callerAddonId: string;
+	readonly providerAddonId: string;
+	readonly capName: string;
+	readonly callsPerMin: number;
+	readonly lastCallAtMs: number;
 }
 export interface CapUsageRegistryOptions {
-    /** Max retention in seconds (ring length). Default 300. */
-    readonly retentionSeconds?: number;
-    /**
-     * Ceiling on live `(caller, provider, cap)` triples. Default
-     * {@link DEFAULT_MAX_TRIPLES}. Reaching it drops NEW triples (counted in
-     * {@link CapUsageStats.droppedTriples}); triples already being watched keep
-     * counting exactly.
-     */
-    readonly maxTriples?: number;
+	/** Max retention in seconds (ring length). Default 300. */
+	readonly retentionSeconds?: number;
+	/**
+	* Ceiling on live `(caller, provider, cap)` triples. Default
+	* {@link DEFAULT_MAX_TRIPLES}. Reaching it drops NEW triples (counted in
+	* {@link CapUsageStats.droppedTriples}); triples already being watched keep
+	* counting exactly.
+	*/
+	readonly maxTriples?: number;
 }
 /** What the registry knows about its own coverage. Never a guess. */
 export interface CapUsageStats {
-    /** Live `(caller, provider, cap)` triples held right now. */
-    readonly triples: number;
-    /** Ceiling in force. */
-    readonly maxTriples: number;
-    /**
-     * New triples refused since process start because the ceiling was full.
-     * Non-zero means the graph is INCOMPLETE — some caller→cap edge exists and
-     * is not shown. Nothing else in this file can be incomplete without saying so.
-     */
-    readonly droppedTriples: number;
+	/** Live `(caller, provider, cap)` triples held right now. */
+	readonly triples: number;
+	/** Ceiling in force. */
+	readonly maxTriples: number;
+	/**
+	* New triples refused since process start because the ceiling was full.
+	* Non-zero means the graph is INCOMPLETE — some caller→cap edge exists and
+	* is not shown. Nothing else in this file can be incomplete without saying so.
+	*/
+	readonly droppedTriples: number;
 }
 export declare class CapUsageRegistry {
-    private readonly retentionSeconds;
-    private readonly maxTriples;
-    private readonly map;
-    private triples;
-    private droppedTriples;
-    constructor(opts?: CapUsageRegistryOptions);
-    /**
-     * Record one observed cap call.
-     *
-     * On the hot path: this runs once per cross-process cap call on hub-main's
-     * event loop, which is the cluster's only queue (D181). Three Map lookups, an
-     * integer increment, and — only when the wall clock has moved on — a bounded
-     * clear. No allocation once a triple exists, and it NEVER throws into the
-     * call it observes.
-     */
-    recordCall(rec: CapUsageCallRecord): void;
-    getGraph(opts: {
-        windowSeconds: number;
-        nowMs: number;
-    }): readonly CapUsageEdge[];
-    /** See {@link CapUsageStats}. Cheap — three counters, no scan. */
-    getStats(): CapUsageStats;
-    /** Test / diagnostic helper — drops all recorded calls. */
-    clear(): void;
-    /**
-     * Sum the buckets covering `(nowSec - windowSeconds, nowSec]`.
-     *
-     * The scan starts at `lastSec`, never at `nowSec`. `recordCall` clears the
-     * buckets the ring has advanced OVER, which by definition stops at the last
-     * write: the buckets for the seconds since then still hold whatever the
-     * previous pass left in them, and reading `nowSec` down would count it. A
-     * triple that went quiet for a couple of minutes and then made one call would
-     * report the burst it made five minutes earlier.
-     *
-     * No lower bound is needed beyond the window itself: every bucket at or below
-     * `lastSec - retention` was cleared by the advance that reached `lastSec`, so
-     * it reads zero anyway. The loop is bounded by `windowSeconds ≤ retention`.
-     */
-    private sumWindow;
-    /**
-     * The ring for this triple, creating it if the ceiling allows. `null` means
-     * the observation is dropped — counted, never silent (see
-     * {@link CapUsageStats.droppedTriples}).
-     */
-    private windowFor;
-    /**
-     * Drop every triple whose whole ring has aged out — its last call is older
-     * than the retention window, so it can contribute to no query. O(triples),
-     * and only reachable when the ceiling is full, so it is amortised away by the
-     * admissions it enables.
-     */
-    private reclaimExpired;
+	private readonly retentionSeconds;
+	private readonly maxTriples;
+	private readonly map;
+	private triples;
+	private droppedTriples;
+	constructor(opts?: CapUsageRegistryOptions);
+	/**
+	* Record one observed cap call.
+	*
+	* On the hot path: this runs once per cross-process cap call on hub-main's
+	* event loop, which is the cluster's only queue (D181). Three Map lookups, an
+	* integer increment, and — only when the wall clock has moved on — a bounded
+	* clear. No allocation once a triple exists, and it NEVER throws into the
+	* call it observes.
+	*/
+	recordCall(rec: CapUsageCallRecord): void;
+	getGraph(opts: {
+		windowSeconds: number;
+		nowMs: number;
+	}): readonly CapUsageEdge[];
+	/** See {@link CapUsageStats}. Cheap — three counters, no scan. */
+	getStats(): CapUsageStats;
+	/** Test / diagnostic helper — drops all recorded calls. */
+	clear(): void;
+	/**
+	* Sum the buckets covering `(nowSec - windowSeconds, nowSec]`.
+	*
+	* The scan starts at `lastSec`, never at `nowSec`. `recordCall` clears the
+	* buckets the ring has advanced OVER, which by definition stops at the last
+	* write: the buckets for the seconds since then still hold whatever the
+	* previous pass left in them, and reading `nowSec` down would count it. A
+	* triple that went quiet for a couple of minutes and then made one call would
+	* report the burst it made five minutes earlier.
+	*
+	* No lower bound is needed beyond the window itself: every bucket at or below
+	* `lastSec - retention` was cleared by the advance that reached `lastSec`, so
+	* it reads zero anyway. The loop is bounded by `windowSeconds ≤ retention`.
+	*/
+	private sumWindow;
+	/**
+	* The ring for this triple, creating it if the ceiling allows. `null` means
+	* the observation is dropped — counted, never silent (see
+	* {@link CapUsageStats.droppedTriples}).
+	*/
+	private windowFor;
+	/**
+	* Drop every triple whose whole ring has aged out — its last call is older
+	* than the retention window, so it can contribute to no query. O(triples),
+	* and only reachable when the ceiling is full, so it is amortised away by the
+	* admissions it enables.
+	*/
+	private reclaimExpired;
 }
 /**
- * The registry for THIS process. Deliberately per-process: the reader
- * (`nodes.getCapUsageGraph` → `cap-providers.ts`) runs on hub-main, so only
- * writes made on hub-main are ever visible. See the blind-spot list on
- * `LocalChildRegistryOptions.capUsageObserver` for what that excludes.
- */
+* The registry for THIS process. Deliberately per-process: the reader
+* (`nodes.getCapUsageGraph` → `cap-providers.ts`) runs on hub-main, so only
+* writes made on hub-main are ever visible. See the blind-spot list on
+* `LocalChildRegistryOptions.capUsageObserver` for what that excludes.
+*/
 export declare function getCapUsageRegistry(): CapUsageRegistry;
 /** Test helper — clears the singleton (kept module-private elsewhere). */
 export declare function __resetCapUsageRegistryForTests(): void;

package/dist/kernel/moleculer/capabilities-access.d.ts

@@ -1,21 +1,21 @@
-import { ServiceBroker } from 'moleculer';
-import { BrokerRegistries } from './provider-registry.js';
+import type { ServiceBroker } from "moleculer";
+import type { BrokerRegistries } from "./provider-registry.js";
 /**
- * Build `ctx.capabilities` for a worker context.
- *
- * Broker mode (hub / agent / in-process addons): merges the local registry
- * (providers from THIS process) with cross-process discovery via the
- * Moleculer service registry — remote providers are returned as Proxy
- * objects that forward method calls back through `broker.call(...)`.
- * Synchronous on the read side because Moleculer's service registry is a
- * local in-memory mirror of cluster state (updated via gossip).
- *
- * UDS mode (broker-less forked child, Phase F1+F2): `broker` is `undefined`,
- * so `ctx.capabilities` is LOCAL-ONLY — it sees only providers registered in
- * THIS process. This matches the canonical contract (CLAUDE.md: "`ctx.capabilities`
- * is the LOCAL CapabilityRegistry of the calling addon's group runner"). For
- * cross-process access a UDS child uses `ctx.api`, which routes over UDS to
- * the parent's `onUnownedCall`.
- */
-declare function buildCapabilitiesAccess(broker: ServiceBroker | undefined, localRegs: BrokerRegistries): import('@camstack/types').CapabilitiesAccess;
+* Build `ctx.capabilities` for a worker context.
+*
+* Broker mode (hub / agent / in-process addons): merges the local registry
+* (providers from THIS process) with cross-process discovery via the
+* Moleculer service registry — remote providers are returned as Proxy
+* objects that forward method calls back through `broker.call(...)`.
+* Synchronous on the read side because Moleculer's service registry is a
+* local in-memory mirror of cluster state (updated via gossip).
+*
+* UDS mode (broker-less forked child, Phase F1+F2): `broker` is `undefined`,
+* so `ctx.capabilities` is LOCAL-ONLY — it sees only providers registered in
+* THIS process. This matches the canonical contract (CLAUDE.md: "`ctx.capabilities`
+* is the LOCAL CapabilityRegistry of the calling addon's group runner"). For
+* cross-process access a UDS child uses `ctx.api`, which routes over UDS to
+* the parent's `onUnownedCall`.
+*/
+declare function buildCapabilitiesAccess(broker: ServiceBroker | undefined, localRegs: BrokerRegistries): import("@camstack/types").CapabilitiesAccess;
 export { buildCapabilitiesAccess };

package/dist/kernel/moleculer/child-addon-call-dispatch.d.ts

@@ -1,53 +1,53 @@
-import { AddonCallInput } from '../transport/child-cap-protocol.js';
-import { CustomActionRegistry } from '../custom-action-registry.js';
-import { ICamstackAddon, AddonDataPlaneEndpoint } from '@camstack/types';
+import type { AddonCallInput } from "../transport/child-cap-protocol.js";
+import type { CustomActionRegistry } from "../custom-action-registry.js";
+import type { ICamstackAddon, AddonDataPlaneEndpoint } from "@camstack/types";
 /**
- * Serializable HTTP route descriptor sent from a forked child to the hub over
- * UDS. The `handler` function on the live `IAddonHttpRoute` is intentionally
- * OMITTED — MsgPack (the UDS frame codec) cannot encode a function, and the
- * hub re-binds dispatch through the `addon-routes` cap's `invoke` method
- * anyway. Mirrors the `addonRoutesCapability.getRoutes` output schema.
- */
+* Serializable HTTP route descriptor sent from a forked child to the hub over
+* UDS. The `handler` function on the live `IAddonHttpRoute` is intentionally
+* OMITTED — MsgPack (the UDS frame codec) cannot encode a function, and the
+* hub re-binds dispatch through the `addon-routes` cap's `invoke` method
+* anyway. Mirrors the `addonRoutesCapability.getRoutes` output schema.
+*/
 export interface SerializableRouteDescriptor {
-    readonly method: string;
-    readonly path: string;
-    readonly access?: string;
-    readonly description?: string;
-    readonly rateLimit?: string;
+	readonly method: string;
+	readonly path: string;
+	readonly access?: string;
+	readonly description?: string;
+	readonly rateLimit?: string;
 }
 /**
- * Resolved `addon-routes` provider lookup — the live provider object the addon
- * registered (`buildAddonRouteProvider(...)`). Returning `null`/`undefined`
- * means the addon registered no routes.
- */
+* Resolved `addon-routes` provider lookup — the live provider object the addon
+* registered (`buildAddonRouteProvider(...)`). Returning `null`/`undefined`
+* means the addon registered no routes.
+*/
 export type RouteProviderLookup = (addonId: string) => object | null | undefined;
 /** Injected lookups the addon-call dispatcher uses to resolve addon-level surfaces. */
 export interface ChildAddonCallDispatchDeps {
-    /** Resolve the live `addon-routes` provider an addon registered, by addon id. */
-    getRouteProvider: RouteProviderLookup;
-    /** The runner-wide custom-action registry (populated during the init loop). */
-    customActions: CustomActionRegistry;
-    /** Resolve the loaded addon instance by id — used for the `settings` surface. */
-    getAddonInstance: (addonId: string) => ICamstackAddon | null;
-    /** Resolve an addon's live HTTP data-plane endpoints (published by its
-     *  `ctx.dataPlane` facility). Empty when the addon serves no data-plane. */
-    getDataPlanes: (addonId: string) => readonly AddonDataPlaneEndpoint[];
-    /**
-     * Swap the secret VIEWS a form sent as action input for their values,
-     * through the owner addon's own `ctx.secrets` (D789). Absent → the input is
-     * parsed as it arrived.
-     */
-    resolveSecretViews?: (addonId: string, args: unknown) => Promise<unknown>;
+	/** Resolve the live `addon-routes` provider an addon registered, by addon id. */
+	getRouteProvider: RouteProviderLookup;
+	/** The runner-wide custom-action registry (populated during the init loop). */
+	customActions: CustomActionRegistry;
+	/** Resolve the loaded addon instance by id — used for the `settings` surface. */
+	getAddonInstance: (addonId: string) => ICamstackAddon | null;
+	/** Resolve an addon's live HTTP data-plane endpoints (published by its
+	*  `ctx.dataPlane` facility). Empty when the addon serves no data-plane. */
+	getDataPlanes: (addonId: string) => readonly AddonDataPlaneEndpoint[];
+	/**
+	* Swap the secret VIEWS a form sent as action input for their values,
+	* through the owner addon's own `ctx.secrets` (D789). Absent → the input is
+	* parsed as it arrived.
+	*/
+	resolveSecretViews?: (addonId: string, args: unknown) => Promise<unknown>;
 }
 /**
- * Creates the addon-level dispatcher the addon-runner wires to
- * `LocalChildClient.onAddonCall`. Routes a {@link AddonCallInput} to one of the
- * exhaustive {@link AddonCallTarget} surfaces (routes / custom / settings) —
- * everything the per-addon Moleculer broker used to carry before the UDS
- * migration removed it. The `target` switch is exhaustive (`never` check): a
- * new surface added to the protocol union that isn't dispatched here is a
- * COMPILE ERROR — the guard that makes a "missed link" impossible.
- *
- * Pure module — no Moleculer, no broker, no addon-runner dependency.
- */
+* Creates the addon-level dispatcher the addon-runner wires to
+* `LocalChildClient.onAddonCall`. Routes a {@link AddonCallInput} to one of the
+* exhaustive {@link AddonCallTarget} surfaces (routes / custom / settings) —
+* everything the per-addon Moleculer broker used to carry before the UDS
+* migration removed it. The `target` switch is exhaustive (`never` check): a
+* new surface added to the protocol union that isn't dispatched here is a
+* COMPILE ERROR — the guard that makes a "missed link" impossible.
+*
+* Pure module — no Moleculer, no broker, no addon-runner dependency.
+*/
 export declare function createChildAddonCallDispatch(deps: ChildAddonCallDispatchDeps): (call: AddonCallInput) => Promise<unknown>;

package/dist/kernel/moleculer/child-cap-descriptors.d.ts

@@ -1,34 +1,34 @@
-import { ChildCapDescriptor } from '../transport/child-cap-protocol.js';
+import type { ChildCapDescriptor } from "../transport/child-cap-protocol.js";
 /** One hosted addon's contribution to the runner UNION manifest. */
 export interface RunnerManifestEntry {
-    readonly addonId: string;
-    readonly capabilities: readonly string[];
+	readonly addonId: string;
+	readonly capabilities: readonly string[];
 }
 /** One native-cap snapshot row — a device-scoped cap and the devices it covers. */
 export interface NativeCapSnapshotEntry {
-    readonly capName: string;
-    readonly addonId: string;
-    readonly deviceIds: readonly number[];
+	readonly capName: string;
+	readonly addonId: string;
+	readonly deviceIds: readonly number[];
 }
 /**
- * Builds the {@link ChildCapDescriptor} array that the UDS child transport
- * sends to the parent on registration.
- *
- * - Singleton caps come from the runner UNION manifest (all caps registered by
- *   every addon in this runner). One descriptor per unique (addonId, capName)
- *   pair, mode `'singleton'` and no `deviceId`. The `addonId` stamp lets the
- *   parent's manifest builder register each hosted addon's caps under the
- *   REAL addon id — a GROUPED runner (`execution.group`) hosts several addons,
- *   and deduplicating by capName alone would collapse two co-located providers
- *   of the same collection cap (e.g. `network-access` from cloudflare-tunnel
- *   AND tailscale-ingress) into one descriptor registered under a synthetic
- *   `addonId = childId` (the group name) — the "@camstack/addon-net-access"
- *   admin-UI bug.
- * - Device-scoped caps come from the native-cap snapshot — one descriptor per
- *   (capName, deviceId) pair, mode `'collection'`, stamped with the owning
- *   addon's id.
- *
- * Pure module — extracted from `addon-runner.ts` (whose `main()` runs at
- * import time) so it is unit-testable.
- */
+* Builds the {@link ChildCapDescriptor} array that the UDS child transport
+* sends to the parent on registration.
+*
+* - Singleton caps come from the runner UNION manifest (all caps registered by
+*   every addon in this runner). One descriptor per unique (addonId, capName)
+*   pair, mode `'singleton'` and no `deviceId`. The `addonId` stamp lets the
+*   parent's manifest builder register each hosted addon's caps under the
+*   REAL addon id — a GROUPED runner (`execution.group`) hosts several addons,
+*   and deduplicating by capName alone would collapse two co-located providers
+*   of the same collection cap (e.g. `network-access` from cloudflare-tunnel
+*   AND tailscale-ingress) into one descriptor registered under a synthetic
+*   `addonId = childId` (the group name) — the "@camstack/addon-net-access"
+*   admin-UI bug.
+* - Device-scoped caps come from the native-cap snapshot — one descriptor per
+*   (capName, deviceId) pair, mode `'collection'`, stamped with the owning
+*   addon's id.
+*
+* Pure module — extracted from `addon-runner.ts` (whose `main()` runs at
+* import time) so it is unit-testable.
+*/
 export declare function buildChildCapDescriptors(manifest: readonly RunnerManifestEntry[], nativeCapSnapshot: readonly NativeCapSnapshotEntry[]): ChildCapDescriptor[];

package/dist/kernel/moleculer/child-cap-dispatch.d.ts

@@ -1,59 +1,59 @@
-import { CapCallInput } from '../transport/child-cap-protocol.js';
+import type { CapCallInput } from "../transport/child-cap-protocol.js";
 /**
- * Injected lookups that the dispatcher uses to resolve cap providers. A provider
- * is an opaque object whose methods are resolved structurally (via {@link isCapMethod})
- * at the UDS dispatch boundary. Returning `null`/`undefined` signals "no provider
- * registered".
- */
+* Injected lookups that the dispatcher uses to resolve cap providers. A provider
+* is an opaque object whose methods are resolved structurally (via {@link isCapMethod})
+* at the UDS dispatch boundary. Returning `null`/`undefined` signals "no provider
+* registered".
+*/
 export interface ChildCapDispatchDeps {
-    /**
-     * Resolve a singleton/system-scoped provider by cap name. `addonId` is a
-     * PROVIDER-SELECTION hint for grouped runners where multiple co-located
-     * addons register the SAME cap (e.g. two `network-access` providers in the
-     * `net-access` group): when it matches a hosted addon's provider, return
-     * that one; otherwise fall back to the cap's sole/first provider (an
-     * `addonId` that names no hosted provider is method DATA, not routing —
-     * e.g. `addons.restartAddon({ addonId })`).
-     */
-    getSingletonProvider(capName: string, addonId?: string): object | null | undefined;
-    /** Resolve a device-scoped provider by cap name and device id. */
-    getDeviceProvider(capName: string, deviceId: number): object | null | undefined;
-    /**
-     * Predicate: is `(capName, method)` a COLLECTION cap's array-returning
-     * method? Such methods aggregate a UNION across every registered provider,
-     * so a provider that doesn't implement one must contribute `[]` (graceful
-     * skip) — the dispatcher returns `[]` instead of throwing "method not found".
-     * The hub-side `concatCollection` / `concatArrayMethod` does this skip
-     * locally, but a hub→child UDS proxy fabricates a callable for every property
-     * so the absence is only observable HERE, on the child that owns the real
-     * (possibly partial) provider. For singleton caps and non-array methods a
-     * missing method is a genuine bug and still throws.
-     */
-    isCollectionListMethod(capName: string, method: string): boolean;
-    /**
-     * Predicate: is `(capName, method)` declared `optionalMethod`?
-     *
-     * The absence of such a method is a FACT about that provider, never a bug —
-     * `videoclips.getPlaybackOptions` at the recorder's `analytics` source is a
-     * time WINDOW with no file behind it. The hub's `callSource` already has the
-     * named refusal, but its `typeof fn !== 'function'` check is VACUOUS across
-     * a process boundary: the UDS proxy fabricates a callable for every
-     * property, so the check passes, the call crosses, and the absence is only
-     * observable here. Without this the honest answer arrived as
-     * `INTERNAL_SERVER_ERROR` — the same signature as a method somebody forgot.
-     */
-    isProviderOptionalMethod(capName: string, method: string): boolean;
+	/**
+	* Resolve a singleton/system-scoped provider by cap name. `addonId` is a
+	* PROVIDER-SELECTION hint for grouped runners where multiple co-located
+	* addons register the SAME cap (e.g. two `network-access` providers in the
+	* `net-access` group): when it matches a hosted addon's provider, return
+	* that one; otherwise fall back to the cap's sole/first provider (an
+	* `addonId` that names no hosted provider is method DATA, not routing —
+	* e.g. `addons.restartAddon({ addonId })`).
+	*/
+	getSingletonProvider(capName: string, addonId?: string): object | null | undefined;
+	/** Resolve a device-scoped provider by cap name and device id. */
+	getDeviceProvider(capName: string, deviceId: number): object | null | undefined;
+	/**
+	* Predicate: is `(capName, method)` a COLLECTION cap's array-returning
+	* method? Such methods aggregate a UNION across every registered provider,
+	* so a provider that doesn't implement one must contribute `[]` (graceful
+	* skip) — the dispatcher returns `[]` instead of throwing "method not found".
+	* The hub-side `concatCollection` / `concatArrayMethod` does this skip
+	* locally, but a hub→child UDS proxy fabricates a callable for every property
+	* so the absence is only observable HERE, on the child that owns the real
+	* (possibly partial) provider. For singleton caps and non-array methods a
+	* missing method is a genuine bug and still throws.
+	*/
+	isCollectionListMethod(capName: string, method: string): boolean;
+	/**
+	* Predicate: is `(capName, method)` declared `optionalMethod`?
+	*
+	* The absence of such a method is a FACT about that provider, never a bug —
+	* `videoclips.getPlaybackOptions` at the recorder's `analytics` source is a
+	* time WINDOW with no file behind it. The hub's `callSource` already has the
+	* named refusal, but its `typeof fn !== 'function'` check is VACUOUS across
+	* a process boundary: the UDS proxy fabricates a callable for every
+	* property, so the check passes, the call crosses, and the absence is only
+	* observable here. Without this the honest answer arrived as
+	* `INTERNAL_SERVER_ERROR` — the same signature as a method somebody forgot.
+	*/
+	isProviderOptionalMethod(capName: string, method: string): boolean;
 }
 /**
- * Prefix the hub matches to turn a child-side "declared optional, not served"
- * into a `NOT_IMPLEMENTED`. A prefix rather than an error subclass because the
- * error crosses a UDS boundary as a plain message.
- */
+* Prefix the hub matches to turn a child-side "declared optional, not served"
+* into a `NOT_IMPLEMENTED`. A prefix rather than an error subclass because the
+* error crosses a UDS boundary as a plain message.
+*/
 export declare const CAP_METHOD_NOT_IMPLEMENTED = "CAP_METHOD_NOT_IMPLEMENTED";
 /**
- * Creates a unified dispatcher that routes a {@link CapCallInput} to either a
- * device-scoped or singleton provider, then invokes the requested method.
- *
- * Pure module — no Moleculer, no broker, no addon-runner dependency.
- */
+* Creates a unified dispatcher that routes a {@link CapCallInput} to either a
+* device-scoped or singleton provider, then invokes the requested method.
+*
+* Pure module — no Moleculer, no broker, no addon-runner dependency.
+*/
 export declare function createChildCapDispatch(deps: ChildCapDispatchDeps): (call: CapCallInput) => Promise<unknown>;