@camstack/system 1.2.390 → 1.2.391

package/dist/kernel/moleculer/children-batch-loader.d.ts

@@ -1,46 +1,98 @@
-import { IScopedLogger } from '@camstack/types';
 /**
- * The child fields the accessory reconcile reads. Deliberately narrower than
- * `DeviceInfo`: the loader is a transport, and a transport that pins the whole
- * projection would have to change every time an unrelated field does.
- */
+* "Who are my children?" asked by a thousand devices, answered in a handful of
+* calls.
+*
+* ## The number
+*
+* Every `BaseDevice` inherits a `getAccessoryChildren()` that returns `[]`, so
+* the accessory reconcile in `device-cap-proxy.ts` runs its orphan-prune step
+* for EVERY registered device — including the leaf accessories that can never
+* own one. Each pass asked `device-manager.getChildren` for its own id.
+* Measured on the live hub 2026-08-27, 120-second boot window, 1 017 devices:
+* **1 024 calls returning 919 rows in total**. A thousand round-trips, and a
+* thousand indexed scans behind them, to move less than one row each.
+*
+* ## Why a loader and not a caller that loops
+*
+* There is no loop to unroll. Reconcile is per-device by construction: it runs
+* inside `register()`, and again whenever a late feature-probe writes the
+* slice. The repetition is a THOUSAND INDEPENDENT CALLERS, not one caller
+* asking a thousand times — so the collapse has to happen between them.
+*
+* ## Why the batch is self-clocking, with no window to tune
+*
+* At most ONE batch call is in flight. Anything that arrives while it is in
+* flight lands in the next batch, dispatched the moment the current one
+* settles. That makes the batch size adapt to the arrival rate on its own:
+*
+*  - Idle: the first caller flushes on the next macrotask. No added wait, and
+*    no timer to pick a value for and be wrong about.
+*  - Boot: `BaseDeviceProvider.onRestoreDevices` issues every top-level
+*    `create()` at once and `runBounded(specs, 12)` spawns accessory children
+*    twelve wide, so reconciles arrive in bursts — measured as 2 372 device
+*    log lines in one 5-second bucket at boot+16s, against 62 at boot+142s.
+*    Every arrival inside one round-trip collapses into the next call.
+*  - Worst case: arrivals slower than a round-trip give batches of one, which
+*    is exactly today's cost. The loader can never be worse than what it
+*    replaces.
+*
+* A fixed debounce window would have to be guessed against that distribution,
+* and would tax the idle case to pay for the busy one.
+*
+* ## Degrading, rather than breaking, against an older hub
+*
+* `getChildrenBatch` is a NEW method: a hub that predates it rejects the call
+* (it does not silently strip the input and answer a different question, which
+* is what adding a `parentDeviceIds` FIELD to `getChildren` would have done).
+* Every waiter in a failed batch is then answered by the per-parent
+* `getChildren` it would have used anyway, so the reconcile is never denied
+* its answer. A rejection that names the method as unknown latches the
+* fallback permanently — re-probing a method the hub will never have, once per
+* batch for a whole boot, is the storm this exists to remove.
+*/
+import type { IScopedLogger } from "@camstack/types";
+/**
+* The child fields the accessory reconcile reads. Deliberately narrower than
+* `DeviceInfo`: the loader is a transport, and a transport that pins the whole
+* projection would have to change every time an unrelated field does.
+*/
 export interface ReconcileChildRow {
-    readonly id: number;
-    readonly stableId: string;
-    readonly name: string;
-    readonly linkDeviceId?: number | null;
+	readonly id: number;
+	readonly stableId: string;
+	readonly name: string;
+	readonly linkDeviceId?: number | null;
 }
 /**
- * Narrow an untyped cap answer to the fields the reconcile reads.
- *
- * `callDeviceManager` is an untyped boundary, and the answer may come from a
- * hub of a different vintage. A row that does not carry an id, a stableId and
- * a name is not a child this code can prune ON, so it is dropped rather than
- * cast into shape — the prune step DELETES, and a half-parsed row is the input
- * that would make it delete the wrong thing.
- */
+* Narrow an untyped cap answer to the fields the reconcile reads.
+*
+* `callDeviceManager` is an untyped boundary, and the answer may come from a
+* hub of a different vintage. A row that does not carry an id, a stableId and
+* a name is not a child this code can prune ON, so it is dropped rather than
+* cast into shape — the prune step DELETES, and a half-parsed row is the input
+* that would make it delete the wrong thing.
+*/
 export declare function parseChildRows(value: unknown): readonly ReconcileChildRow[] | null;
 /**
- * Narrow a `getChildrenBatch` answer: a record keyed by parent id as a string.
- *
- * An EMPTY record is a valid answer — "none of these parents has children" —
- * and so is what a hub that answers the call but knows none of the parents
- * would send. Both mean "nothing to prune", which is the safe direction. Only
- * a shape that is not a record at all is `null`, and the loader treats that as
- * a failed batch and re-asks per parent.
- */
+* Narrow a `getChildrenBatch` answer: a record keyed by parent id as a string.
+*
+* An EMPTY record is a valid answer — "none of these parents has children" —
+* and so is what a hub that answers the call but knows none of the parents
+* would send. Both mean "nothing to prune", which is the safe direction. Only
+* a shape that is not a record at all is `null`, and the loader treats that as
+* a failed batch and re-asks per parent.
+*/
 export declare function parseChildrenByParent(value: unknown): ReadonlyMap<number, readonly ReconcileChildRow[]> | null;
 export interface ChildrenBatchLoaderOptions {
-    /** One `device-manager.getChildrenBatch` call. Rejects like any RPC. */
-    readonly fetchBatch: (parentDeviceIds: readonly number[]) => Promise<ReadonlyMap<number, readonly ReconcileChildRow[]>>;
-    /** One `device-manager.getChildren` call — the fallback, and the old path. */
-    readonly fetchOne: (parentDeviceId: number) => Promise<readonly ReconcileChildRow[]>;
-    readonly logger: IScopedLogger;
-    /** Test seam. Production takes {@link DEVICE_CHILDREN_BATCH_MAX}. */
-    readonly maxBatch?: number;
+	/** One `device-manager.getChildrenBatch` call. Rejects like any RPC. */
+	readonly fetchBatch: (parentDeviceIds: readonly number[]) => Promise<ReadonlyMap<number, readonly ReconcileChildRow[]>>;
+	/** One `device-manager.getChildren` call — the fallback, and the old path. */
+	readonly fetchOne: (parentDeviceId: number) => Promise<readonly ReconcileChildRow[]>;
+	readonly logger: IScopedLogger;
+	/** Test seam. Production takes {@link DEVICE_CHILDREN_BATCH_MAX}. */
+	readonly maxBatch?: number;
 }
 export interface ChildrenBatchLoader {
-    /** The direct children of one parent, coalesced with every other in-flight ask. */
-    load(parentDeviceId: number): Promise<readonly ReconcileChildRow[]>;
+	/** The direct children of one parent, coalesced with every other in-flight ask. */
+	load(parentDeviceId: number): Promise<readonly ReconcileChildRow[]>;
 }
 export declare function createChildrenBatchLoader(opts: ChildrenBatchLoaderOptions): ChildrenBatchLoader;

package/dist/kernel/moleculer/cluster-secret.d.ts

@@ -9,35 +9,35 @@ export declare const CLUSTER_SECRET_REJECTED_EXIT_CODE = 78;
 /** SHA-256 hex digest of a cluster secret. Never transmit or log the raw secret. */
 export declare function hashClusterSecret(secret: string): string;
 /**
- * True if a registration carrying `presentedHash` is allowed against a
- * receiver whose own secret hashes to `expectedHash`.
- * - `expectedHash` undefined → the gate is OFF; everything is allowed.
- * - otherwise `presentedHash` must be present and equal (constant-time).
- */
+* True if a registration carrying `presentedHash` is allowed against a
+* receiver whose own secret hashes to `expectedHash`.
+* - `expectedHash` undefined → the gate is OFF; everything is allowed.
+* - otherwise `presentedHash` must be present and equal (constant-time).
+*/
 export declare function clusterSecretMatches(expectedHash: string | undefined, presentedHash: string | undefined): boolean;
 /** Recognises a cluster-secret rejection, including after a Moleculer RPC round-trip. */
 export declare function isClusterSecretMismatchError(err: unknown): boolean;
 /** Moleculer error `type` of a registration refused because the hub cannot read its own secret yet. */
 export declare const CLUSTER_SECRET_UNAVAILABLE_TYPE = "CLUSTER_SECRET_UNAVAILABLE";
 /**
- * What the hub knows about its own cluster secret:
- *  - `off`: none is set — every node may register (the behaviour of a hub
- *    that never had a secret);
- *  - `on`: set — a node must present the matching hash;
- *  - `unknown`: one is set (the marker exists) but the keychain cannot answer
- *    yet — registrations are refused with a RETRYABLE error until it does.
- *    Fail closed: a locked keychain never opens the gate.
- */
+* What the hub knows about its own cluster secret:
+*  - `off`: none is set — every node may register (the behaviour of a hub
+*    that never had a secret);
+*  - `on`: set — a node must present the matching hash;
+*  - `unknown`: one is set (the marker exists) but the keychain cannot answer
+*    yet — registrations are refused with a RETRYABLE error until it does.
+*    Fail closed: a locked keychain never opens the gate.
+*/
 export type ClusterSecretGate = {
-    readonly kind: 'off';
+	readonly kind: "off";
 } | {
-    readonly kind: 'on';
-    readonly hash: string;
+	readonly kind: "on";
+	readonly hash: string;
 } | {
-    readonly kind: 'unknown';
-    readonly reason: string;
+	readonly kind: "unknown";
+	readonly reason: string;
 };
-export type ClusterSecretVerdict = 'allow' | 'mismatch' | 'unavailable';
+export type ClusterSecretVerdict = "allow" | "mismatch" | "unavailable";
 export declare function checkClusterSecret(gate: ClusterSecretGate, presentedHash: string | undefined): ClusterSecretVerdict;
 /** Register the hub's gate. Called by `system-config`, which owns the field. */
 export declare function setProcessClusterSecretGate(gate: ClusterSecretGate): void;

package/dist/kernel/moleculer/core-cap-service.d.ts

@@ -1,65 +1,65 @@
-import { ServiceSchema } from 'moleculer';
+import type { ServiceSchema } from "moleculer";
 /**
- * Who issued a `$core-caps` action. Both fields are `null` when Moleculer did
- * not carry the information — never blank, so an absent origin reads as absent
- * rather than as a formatting defect.
- */
+* Who issued a `$core-caps` action. Both fields are `null` when Moleculer did
+* not carry the information — never blank, so an absent origin reads as absent
+* rather than as a formatting defect.
+*/
 export interface CoreCapCallOrigin {
-    readonly nodeId: string | null;
-    readonly caller: string | null;
+	readonly nodeId: string | null;
+	readonly caller: string | null;
 }
 /**
- * Default Moleculer service name for the hub core-capability bridge.
- *
- * `$`-prefixed so it never collides with an addon id (addon services
- * take their name from `declaration.id`). It is still a regular,
- * discoverable service — `findServiceCandidates` in `trpc-links.ts`
- * scans every entry returned by `registry.getServiceList()`.
- */
+* Default Moleculer service name for the hub core-capability bridge.
+*
+* `$`-prefixed so it never collides with an addon id (addon services
+* take their name from `declaration.id`). It is still a regular,
+* discoverable service — `findServiceCandidates` in `trpc-links.ts`
+* scans every entry returned by `registry.getServiceList()`.
+*/
 export declare const CORE_CAP_SERVICE_NAME = "$core-caps";
 /**
- * A single hub core-capability procedure, ready to expose as a
- * Moleculer action.
- *
- * `actionName` must be the kebab-cased `<capName>.<method>` pair the
- * worker-side `brokerTransportLink` resolves: it parses `op.path`,
- * kebab-cases the namespace and looks for a service action ending in
- * `.<capName>.<method>` (see `findServiceCandidates`). Mounting the
- * action as `system.info` makes Moleculer register it as
- * `$core-caps.system.info`, which matches that suffix lookup.
- */
+* A single hub core-capability procedure, ready to expose as a
+* Moleculer action.
+*
+* `actionName` must be the kebab-cased `<capName>.<method>` pair the
+* worker-side `brokerTransportLink` resolves: it parses `op.path`,
+* kebab-cases the namespace and looks for a service action ending in
+* `.<capName>.<method>` (see `findServiceCandidates`). Mounting the
+* action as `system.info` makes Moleculer register it as
+* `$core-caps.system.info`, which matches that suffix lookup.
+*/
 export interface CoreCapAction {
-    /** Kebab-cased `<capName>.<method>` — e.g. `system.info`, `addon-settings-raw.getGlobal`. */
-    readonly actionName: string;
-    /**
-     * Invoke the underlying tRPC procedure with a trusted mesh context.
-     *
-     * `origin` is diagnostics only — the transport census uses it to name the
-     * caller of an in-process call, which has no request and therefore no other
-     * identity. No implementation may gate on it.
-     */
-    readonly invoke: (input: unknown, origin: CoreCapCallOrigin) => Promise<unknown> | unknown;
+	/** Kebab-cased `<capName>.<method>` — e.g. `system.info`, `addon-settings-raw.getGlobal`. */
+	readonly actionName: string;
+	/**
+	* Invoke the underlying tRPC procedure with a trusted mesh context.
+	*
+	* `origin` is diagnostics only — the transport census uses it to name the
+	* caller of an in-process call, which has no request and therefore no other
+	* identity. No implementation may gate on it.
+	*/
+	readonly invoke: (input: unknown, origin: CoreCapCallOrigin) => Promise<unknown> | unknown;
 }
 export interface CoreCapServiceOptions {
-    /** Moleculer service name. Defaults to {@link CORE_CAP_SERVICE_NAME}. */
-    readonly serviceName?: string;
-    readonly actions: readonly CoreCapAction[];
+	/** Moleculer service name. Defaults to {@link CORE_CAP_SERVICE_NAME}. */
+	readonly serviceName?: string;
+	readonly actions: readonly CoreCapAction[];
 }
 /**
- * Wrap the hub's core (non-addon) tRPC procedures as a single Moleculer
- * service so forked addons and remote agents can reach them through
- * `ctx.api.<coreCap>.<method>`.
- *
- * Core routers (`system`, `addons`, `capabilities`, `nodes`, …) are
- * mounted only as the hub's tRPC routers — no addon registers a
- * provider for them, so `addon-service-factory` never gives them a
- * Moleculer service. Without this bridge a forked addon's
- * `ctx.api.<coreCap>` falls through `localProviderLink` into
- * `brokerTransportLink`, whose load-balanced discovery wait has no
- * deadline, and hangs forever.
- *
- * Mirrors `createAddonService`: each action deserializes typed arrays
- * and normalizes Moleculer's `{}` (empty params) back to `undefined`
- * so void-input procedures don't receive a spurious empty object.
- */
+* Wrap the hub's core (non-addon) tRPC procedures as a single Moleculer
+* service so forked addons and remote agents can reach them through
+* `ctx.api.<coreCap>.<method>`.
+*
+* Core routers (`system`, `addons`, `capabilities`, `nodes`, …) are
+* mounted only as the hub's tRPC routers — no addon registers a
+* provider for them, so `addon-service-factory` never gives them a
+* Moleculer service. Without this bridge a forked addon's
+* `ctx.api.<coreCap>` falls through `localProviderLink` into
+* `brokerTransportLink`, whose load-balanced discovery wait has no
+* deadline, and hangs forever.
+*
+* Mirrors `createAddonService`: each action deserializes typed arrays
+* and normalizes Moleculer's `{}` (empty params) back to `undefined`
+* so void-input procedures don't receive a spurious empty object.
+*/
 export declare function createCoreCapService(options: CoreCapServiceOptions): ServiceSchema;

package/dist/kernel/moleculer/crash-supervisor.d.ts

@@ -1,50 +1,50 @@
 /**
- * Per-runner crash circuit-breaker.
- *
- * Replaces the old infinite-respawn loop in `process-service.ts`'s
- * `spawnRunner` exit handler. A runner that exits unexpectedly is
- * respawned with exponential backoff while the crash count inside a
- * sliding time window stays under `maxCrashes`. Once the window fills
- * up the breaker trips: respawning STOPS and the caller marks the
- * addon `failed`.
- *
- * State is per-runner (keyed on `runnerId`) and crash timestamps older
- * than `windowMs` age out — a runner that crashed once an hour ago and
- * then crashes again starts a fresh streak.
- */
+* Per-runner crash circuit-breaker.
+*
+* Replaces the old infinite-respawn loop in `process-service.ts`'s
+* `spawnRunner` exit handler. A runner that exits unexpectedly is
+* respawned with exponential backoff while the crash count inside a
+* sliding time window stays under `maxCrashes`. Once the window fills
+* up the breaker trips: respawning STOPS and the caller marks the
+* addon `failed`.
+*
+* State is per-runner (keyed on `runnerId`) and crash timestamps older
+* than `windowMs` age out — a runner that crashed once an hour ago and
+* then crashes again starts a fresh streak.
+*/
 /** Tunables for `CrashSupervisor`. */
 export interface CrashSupervisorOptions {
-    /** CRASH_WINDOW_MS — crashes older than this age out of the count. */
-    readonly windowMs: number;
-    /** Crashes within the window before the breaker trips to `failed`. */
-    readonly maxCrashes: number;
-    /** Backoff cap — the exponential backoff never exceeds this. */
-    readonly maxBackoffMs: number;
+	/** CRASH_WINDOW_MS — crashes older than this age out of the count. */
+	readonly windowMs: number;
+	/** Crashes within the window before the breaker trips to `failed`. */
+	readonly maxCrashes: number;
+	/** Backoff cap — the exponential backoff never exceeds this. */
+	readonly maxBackoffMs: number;
 }
 /**
- * Outcome of recording a crash. Discriminated on `action`:
- *   - `respawn` — under the threshold, schedule another spawn after `backoffMs`.
- *   - `failed`  — breaker tripped, do NOT respawn; mark the addon `failed`.
- */
+* Outcome of recording a crash. Discriminated on `action`:
+*   - `respawn` — under the threshold, schedule another spawn after `backoffMs`.
+*   - `failed`  — breaker tripped, do NOT respawn; mark the addon `failed`.
+*/
 export type CrashDecision = {
-    readonly action: 'respawn';
-    readonly backoffMs: number;
-    readonly crashesInWindow: number;
+	readonly action: "respawn";
+	readonly backoffMs: number;
+	readonly crashesInWindow: number;
 } | {
-    readonly action: 'failed';
-    readonly crashesInWindow: number;
+	readonly action: "failed";
+	readonly crashesInWindow: number;
 };
 /** Per-runner crash circuit-breaker. Replaces the old infinite-respawn loop. */
 export declare class CrashSupervisor {
-    private readonly opts;
-    /** runnerId → crash timestamps (ms epoch), pruned to the active window. */
-    private readonly crashes;
-    constructor(opts: CrashSupervisorOptions);
-    /**
-     * Record a crash for `runnerId` and decide what to do. `now` is
-     * injectable for deterministic tests; production calls omit it.
-     */
-    recordCrash(runnerId: string, now?: number): CrashDecision;
-    /** Clear crash history after a clean run / manual restart. */
-    reset(runnerId: string): void;
+	private readonly opts;
+	/** runnerId → crash timestamps (ms epoch), pruned to the active window. */
+	private readonly crashes;
+	constructor(opts: CrashSupervisorOptions);
+	/**
+	* Record a crash for `runnerId` and decide what to do. `now` is
+	* injectable for deterministic tests; production calls omit it.
+	*/
+	recordCrash(runnerId: string, now?: number): CrashDecision;
+	/** Clear crash history after a clean run / manual restart. */
+	reset(runnerId: string): void;
 }

package/dist/kernel/moleculer/device-cap-proxy.d.ts

@@ -1,70 +1,70 @@
-import { AddonApi, CapabilityDefinition, DeviceManagerApi, IDevice, IEventBus, IKernelStreamProbe, InferProvider, IScopedLogger } from '@camstack/types';
-import { deviceOpsCapability } from '@camstack/types/addon';
-import { ServiceBroker } from 'moleculer';
-import { CapabilityRegistry } from '../capability-registry.js';
-import { DeviceRegistry } from '../device-registry.js';
-export { NATIVE_PROVIDER_SERVICE_INFIX } from '../transport/cap-action-name.js';
+import type { AddonApi, CapabilityDefinition, DeviceManagerApi, IDevice, IEventBus, IKernelStreamProbe, InferProvider, IScopedLogger } from "@camstack/types";
+import { deviceOpsCapability } from "@camstack/types/addon";
+import type { ServiceBroker } from "moleculer";
+import type { CapabilityRegistry } from "../capability-registry.js";
+import type { DeviceRegistry } from "../device-registry.js";
+export { NATIVE_PROVIDER_SERVICE_INFIX } from "../transport/cap-action-name.js";
 export interface WorkerDeviceManagerOptions {
-    readonly api: AddonApi;
-    readonly addonId: string;
-    readonly nodeId: string;
-    readonly logger: IScopedLogger;
-    readonly eventBus: IEventBus;
-    readonly registry: DeviceRegistry;
-    readonly capabilityRegistry?: CapabilityRegistry;
-    readonly broker?: ServiceBroker;
-    /**
-     * UDS-only forked child (Phase F1+F2): no `capabilityRegistry`, no
-     * `broker`. `registerNativeCap` populates the per-process `workerNativeCaps`
-     * map (read by the UDS dispatch in `addon-runner`) but mounts NO Moleculer
-     * `<addon>.native-provider.*` service — the child has no broker.
-     */
-    readonly udsMode?: boolean;
-    readonly streamProbe?: IKernelStreamProbe;
+	readonly api: AddonApi;
+	readonly addonId: string;
+	readonly nodeId: string;
+	readonly logger: IScopedLogger;
+	readonly eventBus: IEventBus;
+	readonly registry: DeviceRegistry;
+	readonly capabilityRegistry?: CapabilityRegistry;
+	readonly broker?: ServiceBroker;
+	/**
+	* UDS-only forked child (Phase F1+F2): no `capabilityRegistry`, no
+	* `broker`. `registerNativeCap` populates the per-process `workerNativeCaps`
+	* map (read by the UDS dispatch in `addon-runner`) but mounts NO Moleculer
+	* `<addon>.native-provider.*` service — the child has no broker.
+	*/
+	readonly udsMode?: boolean;
+	readonly streamProbe?: IKernelStreamProbe;
 }
 /** Subscribe to worker native-cap set changes. Pass null to clear. */
 export declare function setWorkerNativeCapsChangeListener(listener: (() => void) | null): void;
 /**
- * Mount the Moleculer service exposing `<addonId>.native-provider.<capName>`
- * with per-method actions that dispatch to `workerNativeCaps`. Called
- * lazily on first `registerNativeCap` AND proactively at worker boot for
- * always-on caps (e.g. `device-ops`) so the INFO packet sent at TCP
- * connect already advertises the service.
- */
+* Mount the Moleculer service exposing `<addonId>.native-provider.<capName>`
+* with per-method actions that dispatch to `workerNativeCaps`. Called
+* lazily on first `registerNativeCap` AND proactively at worker boot for
+* always-on caps (e.g. `device-ops`) so the INFO packet sent at TCP
+* connect already advertises the service.
+*/
 export declare function mountNativeCapService<TCap extends CapabilityDefinition>(broker: ServiceBroker, addonId: string, cap: TCap): void;
 export declare function getWorkerNativeCap(capName: string, deviceId: number): unknown | null;
 export declare function clearWorkerNativeCapsForDevice(deviceId: number): void;
 export declare function getWorkerNativeCapNames(): readonly string[];
 /**
- * Snapshot of every device-scoped native cap this worker hosts, with the
- * device ids and registering addonId for each. Used by the D3 registration
- * handshake (`process-runner`/`group-runner` → `$hub.registerNode`'s
- * `nativeCaps` field) so the hub's `HubNodeRegistry` learns device-scoped
- * native caps (including addonId) without the pull-based discovery sweep.
- *
- * Groups by `(capName, addonId)` because different addons in the same group
- * may register the same cap for different devices — each such pair becomes
- * its own entry so the hub can build the correct Moleculer proxy target.
- */
+* Snapshot of every device-scoped native cap this worker hosts, with the
+* device ids and registering addonId for each. Used by the D3 registration
+* handshake (`process-runner`/`group-runner` → `$hub.registerNode`'s
+* `nativeCaps` field) so the hub's `HubNodeRegistry` learns device-scoped
+* native caps (including addonId) without the pull-based discovery sweep.
+*
+* Groups by `(capName, addonId)` because different addons in the same group
+* may register the same cap for different devices — each such pair becomes
+* its own entry so the hub can build the correct Moleculer proxy target.
+*/
 export declare function getWorkerNativeCapSnapshot(): ReadonlyArray<{
-    readonly capName: string;
-    readonly addonId: string;
-    readonly deviceIds: readonly number[];
+	readonly capName: string;
+	readonly addonId: string;
+	readonly deviceIds: readonly number[];
 }>;
 export declare function getWorkerNativeCapsForDevice(deviceId: number): readonly string[];
 /**
- * Read-only accessor for UDS dispatch — returns the provider registered for a
- * given (capName, deviceId) pair, or `undefined` when none is registered.
- * Returns the provider as an opaque `object`; `createChildCapDispatch` resolves
- * its methods structurally via a type guard, so no cast is needed.
- */
+* Read-only accessor for UDS dispatch — returns the provider registered for a
+* given (capName, deviceId) pair, or `undefined` when none is registered.
+* Returns the provider as an opaque `object`; `createChildCapDispatch` resolves
+* its methods structurally via a type guard, so no cast is needed.
+*/
 export declare function getWorkerNativeCapProvider(capName: string, deviceId: number): object | undefined;
 /**
- * Hub-side proxy factory. Returns an object whose method access dispatches
- * via `broker.call('<addonId>.native-provider.<capName>.<method>', input)`.
- * Calls are wrapped in exponential-backoff retry to absorb the race between
- * worker `broker.createService` and the hub's Moleculer registry INFO packet.
- */
+* Hub-side proxy factory. Returns an object whose method access dispatches
+* via `broker.call('<addonId>.native-provider.<capName>.<method>', input)`.
+* Calls are wrapped in exponential-backoff retry to absorb the race between
+* worker `broker.createService` and the hub's Moleculer registry INFO packet.
+*/
 export declare function buildNativeCapProxy(broker: ServiceBroker, addonId: string, capName: string, deviceId: number): Record<string, (input: unknown) => Promise<unknown>>;
 export declare function buildDeviceOpsProvider(device: IDevice): InferProvider<typeof deviceOpsCapability>;
 export declare function createBrokerDeviceManagerApi(opts: WorkerDeviceManagerOptions): DeviceManagerApi;