@camstack/system 1.2.390 → 1.2.391

package/dist/kernel/transport/cap-action-census.d.ts

@@ -1,218 +1,218 @@
 /**
- * cap-action-census — which cap METHOD moves the bytes, and how much of each
- * one this parent forwarded without ever reading it.
- *
- * ## Why `socket-traffic.ts` keeps no method, and why this is a separate file
- *
- * Read `socket-traffic.ts` before changing anything here. It does not omit the
- * method by oversight; three separate properties of that file forbid it, and
- * this module exists because each can be answered somewhere else rather than
- * relaxed:
- *
- * 1. **The channel does not know one.** `SocketChannel` sees a {@link
- *    import('./local-transport.js').Frame} — `{ k, id, body }` — and `body` is
- *    `unknown` by contract. The cap envelope lives one layer up, in
- *    `child-cap-protocol.ts`. A counter inside the channel that reached into
- *    `body.capName` would make the transport depend on the protocol it
- *    carries. So the LABEL is supplied from above ({@link capActionLabel}) and
- *    only the BYTES come from the wire.
- *
- * 2. **A `res` frame carries no method at all** — only its correlation `id`.
- *    And the responses are the whole question: measured 2026-09-11, hub-main
- *    wrote 144–262 MB/min to `hub/pipeline-analytics` on 1 966–2 411 responses
- *    (a 73–108 kB mean) against 2 kB of requests. Charging those bytes to a
- *    method is therefore not a counter at all, it is a CORRELATION: the label
- *    is taken off the `req`, held against its id, and settled when the `res`
- *    for that id is written. `socket-traffic.ts` is a two-addition hot path
- *    with no state per message; this is state per in-flight request, and the
- *    two do not belong in one file.
- *
- * 3. **Cardinality.** `recordSocketFrame` costs 2.37–2.41 ns and allocates
- *    nothing, on a path that runs ~44 000 times a second. Its docblock's rule
- *    — "an instrument that changes what it measures is not an instrument" — is
- *    the binding constraint, and a naive per-method map breaks it twice: a Map
- *    lookup and a counter object per method NAME, where the names arrive off
- *    the wire and are therefore unbounded in principle.
- *
- * ## What was chosen for the cardinality, and why not a sample
- *
- * **Full per-method counters in memory, bounded per peer; top-N only at REPORT
- * time.** The constraint that is real is the LINE's width (D446: Loki reads
- * these prefixes), not the map's size — and those are different limits:
- *
- *  - *Measured shape.* The cap-usage graph already keeps `(caller, provider,
- *    cap, method)` and, queried on this hub on 2026-09-11, holds **53 rows for
- *    the whole cluster** — 14 of them for `pipeline-analytics`, whose top three
- *    caps are 2 077 of its 2 141 calls/min. A peer uses a handful of methods,
- *    not hundreds. ~39 peers × a few dozen labels is a few hundred counter
- *    objects, each allocated ONCE and then only incremented. That is not an
- *    explosion; it is smaller than the `childEventStats` map next to it.
- *  - *The unbounded case is still refused*, because "measured today" is not a
- *    guarantee: {@link MAX_CAP_ACTIONS_PER_PEER} caps the distinct labels per
- *    peer and everything past it is charged to ONE
- *    {@link CAP_ACTION_OVERFLOW_LABEL} bucket. The bytes are never dropped —
- *    they stop being *named*, which is a different and visible failure.
- *  - *A sampled window was rejected.* The flow this exists to name is few,
- *    enormous responses: 1 966 responses carrying 144 MB. A 1-in-N sample of a
- *    distribution whose top item fires ~30 times a minute answers "probably"
- *    to a question that has an exact answer for the price of an integer add.
- *    And a sample that misses a method would report it as zero bytes, which is
- *    exactly the `null`-vs-`0` confusion D393 exists to forbid.
- *  - *A byte THRESHOLD was rejected for the same reason in reverse*: a
- *    threshold decides what to keep before it knows the window's shape, so the
- *    method that only matters during an episode is the one it discards. Rank
- *    at report time, when the totals are known.
- *
- * ## What a reader may conclude, and what it may not
- *
- * {@link CapActionWindow.labelledBytes} against `totalBytes` is the census's
- * own coverage, and it is on the line. Bytes this parent moved that carry no
- * cap envelope (`register`, `addon-call`, log and event frames) are charged to
- * {@link CAP_ACTION_UNLABELLED} rather than omitted: an instrument that
- * silently drops what it cannot classify reports a clean attribution of a
- * fraction it never names. A window whose `labelledBytes` is a small part of
- * `totalBytes` has NOT attributed the plane, and says so.
- *
- * ## Mutation, as in `socket-traffic.ts`
- *
- * Same deliberate exception, for the same measured reason: the counters are
- * plain mutable numbers written only by {@link CapActionCensus.record} and
- * friends, and read only through {@link CapActionCensus.read}, which COPIES.
- * The copy is not a nicety — the reporting layer subtracts the previous
- * reading, and a `read()` that handed back the live maps would advance the
- * baseline together with the counters and report every window as empty.
- */
+* cap-action-census — which cap METHOD moves the bytes, and how much of each
+* one this parent forwarded without ever reading it.
+*
+* ## Why `socket-traffic.ts` keeps no method, and why this is a separate file
+*
+* Read `socket-traffic.ts` before changing anything here. It does not omit the
+* method by oversight; three separate properties of that file forbid it, and
+* this module exists because each can be answered somewhere else rather than
+* relaxed:
+*
+* 1. **The channel does not know one.** `SocketChannel` sees a {@link
+*    import('./local-transport.js').Frame} — `{ k, id, body }` — and `body` is
+*    `unknown` by contract. The cap envelope lives one layer up, in
+*    `child-cap-protocol.ts`. A counter inside the channel that reached into
+*    `body.capName` would make the transport depend on the protocol it
+*    carries. So the LABEL is supplied from above ({@link capActionLabel}) and
+*    only the BYTES come from the wire.
+*
+* 2. **A `res` frame carries no method at all** — only its correlation `id`.
+*    And the responses are the whole question: measured 2026-09-11, hub-main
+*    wrote 144–262 MB/min to `hub/pipeline-analytics` on 1 966–2 411 responses
+*    (a 73–108 kB mean) against 2 kB of requests. Charging those bytes to a
+*    method is therefore not a counter at all, it is a CORRELATION: the label
+*    is taken off the `req`, held against its id, and settled when the `res`
+*    for that id is written. `socket-traffic.ts` is a two-addition hot path
+*    with no state per message; this is state per in-flight request, and the
+*    two do not belong in one file.
+*
+* 3. **Cardinality.** `recordSocketFrame` costs 2.37–2.41 ns and allocates
+*    nothing, on a path that runs ~44 000 times a second. Its docblock's rule
+*    — "an instrument that changes what it measures is not an instrument" — is
+*    the binding constraint, and a naive per-method map breaks it twice: a Map
+*    lookup and a counter object per method NAME, where the names arrive off
+*    the wire and are therefore unbounded in principle.
+*
+* ## What was chosen for the cardinality, and why not a sample
+*
+* **Full per-method counters in memory, bounded per peer; top-N only at REPORT
+* time.** The constraint that is real is the LINE's width (D446: Loki reads
+* these prefixes), not the map's size — and those are different limits:
+*
+*  - *Measured shape.* The cap-usage graph already keeps `(caller, provider,
+*    cap, method)` and, queried on this hub on 2026-09-11, holds **53 rows for
+*    the whole cluster** — 14 of them for `pipeline-analytics`, whose top three
+*    caps are 2 077 of its 2 141 calls/min. A peer uses a handful of methods,
+*    not hundreds. ~39 peers × a few dozen labels is a few hundred counter
+*    objects, each allocated ONCE and then only incremented. That is not an
+*    explosion; it is smaller than the `childEventStats` map next to it.
+*  - *The unbounded case is still refused*, because "measured today" is not a
+*    guarantee: {@link MAX_CAP_ACTIONS_PER_PEER} caps the distinct labels per
+*    peer and everything past it is charged to ONE
+*    {@link CAP_ACTION_OVERFLOW_LABEL} bucket. The bytes are never dropped —
+*    they stop being *named*, which is a different and visible failure.
+*  - *A sampled window was rejected.* The flow this exists to name is few,
+*    enormous responses: 1 966 responses carrying 144 MB. A 1-in-N sample of a
+*    distribution whose top item fires ~30 times a minute answers "probably"
+*    to a question that has an exact answer for the price of an integer add.
+*    And a sample that misses a method would report it as zero bytes, which is
+*    exactly the `null`-vs-`0` confusion D393 exists to forbid.
+*  - *A byte THRESHOLD was rejected for the same reason in reverse*: a
+*    threshold decides what to keep before it knows the window's shape, so the
+*    method that only matters during an episode is the one it discards. Rank
+*    at report time, when the totals are known.
+*
+* ## What a reader may conclude, and what it may not
+*
+* {@link CapActionWindow.labelledBytes} against `totalBytes` is the census's
+* own coverage, and it is on the line. Bytes this parent moved that carry no
+* cap envelope (`register`, `addon-call`, log and event frames) are charged to
+* {@link CAP_ACTION_UNLABELLED} rather than omitted: an instrument that
+* silently drops what it cannot classify reports a clean attribution of a
+* fraction it never names. A window whose `labelledBytes` is a small part of
+* `totalBytes` has NOT attributed the plane, and says so.
+*
+* ## Mutation, as in `socket-traffic.ts`
+*
+* Same deliberate exception, for the same measured reason: the counters are
+* plain mutable numbers written only by {@link CapActionCensus.record} and
+* friends, and read only through {@link CapActionCensus.read}, which COPIES.
+* The copy is not a nicety — the reporting layer subtracts the previous
+* reading, and a `read()` that handed back the live maps would advance the
+* baseline together with the counters and report every window as empty.
+*/
 /**
- * The channel's half of the census — see `socket-channel.ts` for the seam.
- *
- * The channel owns the BYTES and the request↔response correlation and NOTHING
- * else: it sees `{ k, id, body }` with `body: unknown`, and a `res` frame
- * carries no method at all. So the layer that understands the protocol supplies
- * {@link CapActionChannelObserver.label}, and the channel calls it once per
- * `req` frame, holds the answer against the frame's id, and settles it with
- * {@link CapActionChannelObserver.record} when the matching `res` is written or
- * read. A `null` label is still recorded — those bytes crossed, and a census
- * that drops what it cannot name reports a clean attribution of a fraction it
- * never mentions.
- *
- * Declared HERE rather than in the channel so `local-transport.ts` can name it
- * on {@link import('./local-transport.js').LocalChannel} without importing the
- * implementation that satisfies it.
- */
+* The channel's half of the census — see `socket-channel.ts` for the seam.
+*
+* The channel owns the BYTES and the request↔response correlation and NOTHING
+* else: it sees `{ k, id, body }` with `body: unknown`, and a `res` frame
+* carries no method at all. So the layer that understands the protocol supplies
+* {@link CapActionChannelObserver.label}, and the channel calls it once per
+* `req` frame, holds the answer against the frame's id, and settles it with
+* {@link CapActionChannelObserver.record} when the matching `res` is written or
+* read. A `null` label is still recorded — those bytes crossed, and a census
+* that drops what it cannot name reports a clean attribution of a fraction it
+* never mentions.
+*
+* Declared HERE rather than in the channel so `local-transport.ts` can name it
+* on {@link import('./local-transport.js').LocalChannel} without importing the
+* implementation that satisfies it.
+*/
 export interface CapActionChannelObserver {
-    /** `<cap>.<method>`, or `null` for a frame that carries no cap envelope. */
-    label(body: unknown): string | null;
-    /** One completed request/response pair, its on-the-wire bytes both ways. */
-    record(label: string | null, reqBytes: number, resBytes: number): void;
+	/** `<cap>.<method>`, or `null` for a frame that carries no cap envelope. */
+	label(body: unknown): string | null;
+	/** One completed request/response pair, its on-the-wire bytes both ways. */
+	record(label: string | null, reqBytes: number, resBytes: number): void;
 }
 /** One action's cumulative cost on one peer's channel. Mutable by design. */
 export interface CapActionCounters {
-    /** Completed request/response pairs. */
-    calls: number;
-    /** On-the-wire bytes of the requests, prefix and payload included. */
-    reqBytes: number;
-    /** On-the-wire bytes of the answers. */
-    resBytes: number;
-    /** Of `calls`, how many this parent forwarded without reading (D448). */
-    raw: number;
-    /** Of `calls`, how many it materialised the args of. */
-    decoded: number;
+	/** Completed request/response pairs. */
+	calls: number;
+	/** On-the-wire bytes of the requests, prefix and payload included. */
+	reqBytes: number;
+	/** On-the-wire bytes of the answers. */
+	resBytes: number;
+	/** Of `calls`, how many this parent forwarded without reading (D448). */
+	raw: number;
+	/** Of `calls`, how many it materialised the args of. */
+	decoded: number;
 }
 /** An immutable reading of one action. */
 export interface CapActionSample {
-    readonly calls: number;
-    readonly reqBytes: number;
-    readonly resBytes: number;
-    readonly raw: number;
-    readonly decoded: number;
+	readonly calls: number;
+	readonly reqBytes: number;
+	readonly resBytes: number;
+	readonly raw: number;
+	readonly decoded: number;
 }
 /** One complete reading: peer → action → counters. */
 export type CapActionReading = ReadonlyMap<string, ReadonlyMap<string, CapActionSample>>;
 /** A process that has never read the census. */
 export declare const EMPTY_CAP_ACTION_READING: CapActionReading;
 /**
- * Bytes that crossed on a frame carrying no cap envelope.
- *
- * Named rather than omitted so the census's coverage is readable off its own
- * output: `register`, `addon-call`, log frames and the event fan-out all land
- * here. A census that reported only what it could name would look like a
- * complete attribution of whatever share it happened to cover.
- */
+* Bytes that crossed on a frame carrying no cap envelope.
+*
+* Named rather than omitted so the census's coverage is readable off its own
+* output: `register`, `addon-call`, log frames and the event fan-out all land
+* here. A census that reported only what it could name would look like a
+* complete attribution of whatever share it happened to cover.
+*/
 export declare const CAP_ACTION_UNLABELLED = "(unlabelled)";
 /** Bytes of actions past {@link MAX_CAP_ACTIONS_PER_PEER} on one peer. */
 export declare const CAP_ACTION_OVERFLOW_LABEL = "(overflow)";
 /**
- * Distinct named actions kept per peer before the overflow bucket takes over.
- *
- * Sixty-four against a measured worst case of 14 (`pipeline-analytics`, the
- * heaviest peer on this hub, 2026-09-11) — four times the observed shape, so a
- * peer has to change character before it overflows, and a bound that is never
- * reached in practice still forbids the unbounded growth a wire-supplied key
- * makes possible in principle.
- */
+* Distinct named actions kept per peer before the overflow bucket takes over.
+*
+* Sixty-four against a measured worst case of 14 (`pipeline-analytics`, the
+* heaviest peer on this hub, 2026-09-11) — four times the observed shape, so a
+* peer has to change character before it overflows, and a bound that is never
+* reached in practice still forbids the unbounded growth a wire-supplied key
+* makes possible in principle.
+*/
 export declare const MAX_CAP_ACTIONS_PER_PEER = 64;
 /**
- * `<cap>.<method>` for a cap envelope, `null` for anything else.
- *
- * Both directions are labelled by the same function: a child's `cap-call-out`
- * and the parent's `cap-call` carry `capName` + `method` in the same two keys,
- * so one predicate covers the whole plane. Anything else — a `register`, an
- * `addon-call`, a log or an event — is deliberately unlabelled; see
- * {@link CAP_ACTION_UNLABELLED} for where its bytes go.
- *
- * Cost: two property reads, two `typeof`s and one concatenation of two short
- * strings, called once per `req` frame (not per frame). Against the
- * `encodeFrame` it sits beside — 1 948–1 975 ns on a 0.33 kB body — it is
- * noise, and unlike `recordSocketFrame` it is not on the `evt` path at all.
- */
+* `<cap>.<method>` for a cap envelope, `null` for anything else.
+*
+* Both directions are labelled by the same function: a child's `cap-call-out`
+* and the parent's `cap-call` carry `capName` + `method` in the same two keys,
+* so one predicate covers the whole plane. Anything else — a `register`, an
+* `addon-call`, a log or an event — is deliberately unlabelled; see
+* {@link CAP_ACTION_UNLABELLED} for where its bytes go.
+*
+* Cost: two property reads, two `typeof`s and one concatenation of two short
+* strings, called once per `req` frame (not per frame). Against the
+* `encodeFrame` it sits beside — 1 948–1 975 ns on a 0.33 kB body — it is
+* noise, and unlike `recordSocketFrame` it is not on the `evt` path at all.
+*/
 export declare function capActionLabel(body: unknown): string | null;
 /** Which half of D448's census one call fell on. */
-export type CapActionForwardKind = 'raw' | 'decoded';
+export type CapActionForwardKind = "raw" | "decoded";
 /** The census as its writers see it. */
 export interface CapActionCensus {
-    /** One completed request/response pair on `peerId`, charged to `action`. */
-    record(peerId: string, action: string, reqBytes: number, resBytes: number): void;
-    /** How `action`'s most recent call was routed — see {@link CapActionForwardKind}. */
-    recordForward(peerId: string, action: string, kind: CapActionForwardKind): void;
-    /** Bytes on a frame that carried no cap envelope. */
-    recordUnlabelled(peerId: string, bytes: number): void;
-    /** Drop a peer's counters when its channel closes for good. */
-    forget(peerId: string): void;
-    /** A COPY of the counters — see the module docblock on why it must be one. */
-    read(): CapActionReading;
+	/** One completed request/response pair on `peerId`, charged to `action`. */
+	record(peerId: string, action: string, reqBytes: number, resBytes: number): void;
+	/** How `action`'s most recent call was routed — see {@link CapActionForwardKind}. */
+	recordForward(peerId: string, action: string, kind: CapActionForwardKind): void;
+	/** Bytes on a frame that carried no cap envelope. */
+	recordUnlabelled(peerId: string, bytes: number): void;
+	/** Drop a peer's counters when its channel closes for good. */
+	forget(peerId: string): void;
+	/** A COPY of the counters — see the module docblock on why it must be one. */
+	read(): CapActionReading;
 }
 export declare function createCapActionCensus(): CapActionCensus;
 /** One (peer, action) pair over the window since the previous reading. */
 export interface CapActionDelta {
-    readonly peerId: string;
-    readonly action: string;
-    readonly calls: number;
-    readonly reqBytes: number;
-    readonly resBytes: number;
-    readonly raw: number;
-    readonly decoded: number;
+	readonly peerId: string;
+	readonly action: string;
+	readonly calls: number;
+	readonly reqBytes: number;
+	readonly resBytes: number;
+	readonly raw: number;
+	readonly decoded: number;
 }
 /** The census over one heartbeat window. */
 export interface CapActionWindow {
-    /**
-     * Heaviest first by `reqBytes + resBytes`, at most the requested N.
-     *
-     * By BYTES and never by calls, for the reason D454 records: the flow this
-     * exists to name is few, enormous responses, and a ranking by count cannot
-     * see it by construction.
-     */
-    readonly top: readonly CapActionDelta[];
-    /** Bytes the census could put a cap method on, this window. */
-    readonly labelledBytes: number;
-    /** Every byte it saw, named or not. `labelled/total` is its own coverage. */
-    readonly totalBytes: number;
+	/**
+	* Heaviest first by `reqBytes + resBytes`, at most the requested N.
+	*
+	* By BYTES and never by calls, for the reason D454 records: the flow this
+	* exists to name is few, enormous responses, and a ranking by count cannot
+	* see it by construction.
+	*/
+	readonly top: readonly CapActionDelta[];
+	/** Bytes the census could put a cap method on, this window. */
+	readonly labelledBytes: number;
+	/** Every byte it saw, named or not. `labelled/total` is its own coverage. */
+	readonly totalBytes: number;
 }
 /**
- * Subtract the previous reading from the current one.
- *
- * A peer whose runner RESPAWNED reconnects under the same id with counters
- * that went backwards. Clamped at 0, exactly as `diffSocketPlane` clamps for
- * the same reason: its traffic in that window is genuinely unknown, and a
- * negative number on a rate reads as a broken meter.
- */
+* Subtract the previous reading from the current one.
+*
+* A peer whose runner RESPAWNED reconnects under the same id with counters
+* that went backwards. Clamped at 0, exactly as `diffSocketPlane` clamps for
+* the same reason: its traffic in that window is genuinely unknown, and a
+* negative number on a rate reads as a broken meter.
+*/
 export declare function diffCapActionCensus(before: CapActionReading, current: CapActionReading, topN: number): CapActionWindow;

package/dist/kernel/transport/cap-action-name.d.ts

@@ -1,100 +1,100 @@
 /**
- * cap-action-name.ts — single source of truth for Moleculer cap
- * action/service naming conventions.
- *
- * Moleculer service / action naming rules
- * ─────────────────────────────────────────────────────────────────────────────
- * System (manifest) cap:
- *   service  : `${addonId}.${capName}`             (service `name` field)
- *   action   : `${capName}.${method}`              (registered INSIDE the service)
- *   full key : `${addonId}.${capName}.${method}`   (broker.call key)
- *
- * Native (device-scoped) cap:
- *   service  : `${addonId}${NATIVE_PROVIDER_SERVICE_INFIX}.${capName}`
- *   action   : `${method}`                         (registered INSIDE the service)
- *              also aliased as `${capName}.${method}` for bridge discovery
- *   full key : `${addonId}${NATIVE_PROVIDER_SERVICE_INFIX}.${capName}.${method}`
- *
- * Registry-scan helpers:
- *   suffix   : `.${capName}.${method}`  — trailing match against a full action key
- *   bare     : `${capName}.${method}`   — the action key as registered by
- *               addon-service-factory (without the service-name prefix)
- *
- * Parse helper:
- *   parseCapAction(action) → { addonId, capName, method, native }
- *   Inverse of capActionName / capServiceName + ".${method}".
- * ─────────────────────────────────────────────────────────────────────────────
- *
- * All five construction sites that previously built these strings inline now
- * import from here instead:
- *   1. packages/kernel/src/transport/cap-route-resolver.ts (remote dispatch)
- *   2. packages/kernel/src/moleculer/trpc-links.ts (findServiceCandidates + brokerTransportLink)
- *   3. packages/kernel/src/moleculer/addon-service-factory.ts (service action registration)
- *   4. packages/kernel/src/moleculer/device-cap-proxy.ts (native service/proxy)
- *   5. server/backend/src/core/moleculer/moleculer.service.ts (legacy callFn fallback)
- */
+* cap-action-name.ts — single source of truth for Moleculer cap
+* action/service naming conventions.
+*
+* Moleculer service / action naming rules
+* ─────────────────────────────────────────────────────────────────────────────
+* System (manifest) cap:
+*   service  : `${addonId}.${capName}`             (service `name` field)
+*   action   : `${capName}.${method}`              (registered INSIDE the service)
+*   full key : `${addonId}.${capName}.${method}`   (broker.call key)
+*
+* Native (device-scoped) cap:
+*   service  : `${addonId}${NATIVE_PROVIDER_SERVICE_INFIX}.${capName}`
+*   action   : `${method}`                         (registered INSIDE the service)
+*              also aliased as `${capName}.${method}` for bridge discovery
+*   full key : `${addonId}${NATIVE_PROVIDER_SERVICE_INFIX}.${capName}.${method}`
+*
+* Registry-scan helpers:
+*   suffix   : `.${capName}.${method}`  — trailing match against a full action key
+*   bare     : `${capName}.${method}`   — the action key as registered by
+*               addon-service-factory (without the service-name prefix)
+*
+* Parse helper:
+*   parseCapAction(action) → { addonId, capName, method, native }
+*   Inverse of capActionName / capServiceName + ".${method}".
+* ─────────────────────────────────────────────────────────────────────────────
+*
+* All five construction sites that previously built these strings inline now
+* import from here instead:
+*   1. packages/kernel/src/transport/cap-route-resolver.ts (remote dispatch)
+*   2. packages/kernel/src/moleculer/trpc-links.ts (findServiceCandidates + brokerTransportLink)
+*   3. packages/kernel/src/moleculer/addon-service-factory.ts (service action registration)
+*   4. packages/kernel/src/moleculer/device-cap-proxy.ts (native service/proxy)
+*   5. server/backend/src/core/moleculer/moleculer.service.ts (legacy callFn fallback)
+*/
 /**
- * Infix segment that separates the addonId from the capName in the Moleculer
- * service name for device-scoped NATIVE capability providers.
- *
- * Native service name  : `${addonId}${NATIVE_PROVIDER_SERVICE_INFIX}.${capName}`
- * System service name  : `${addonId}.${capName}`  (no infix)
- */
+* Infix segment that separates the addonId from the capName in the Moleculer
+* service name for device-scoped NATIVE capability providers.
+*
+* Native service name  : `${addonId}${NATIVE_PROVIDER_SERVICE_INFIX}.${capName}`
+* System service name  : `${addonId}.${capName}`  (no infix)
+*/
 export declare const NATIVE_PROVIDER_SERVICE_INFIX: ".native-provider";
 /**
- * Build the Moleculer SERVICE name for a cap provider.
- *
- * System cap : `${addonId}.${capName}`
- * Native cap : `${addonId}${NATIVE_PROVIDER_SERVICE_INFIX}.${capName}`
- */
+* Build the Moleculer SERVICE name for a cap provider.
+*
+* System cap : `${addonId}.${capName}`
+* Native cap : `${addonId}${NATIVE_PROVIDER_SERVICE_INFIX}.${capName}`
+*/
 export declare function capServiceName(addonId: string, capName: string, native: boolean): string;
 /**
- * Build the full Moleculer ACTION key (broker.call key) for a cap method.
- *
- * System cap : `${addonId}.${capName}.${method}`
- * Native cap : `${addonId}${NATIVE_PROVIDER_SERVICE_INFIX}.${capName}.${method}`
- */
+* Build the full Moleculer ACTION key (broker.call key) for a cap method.
+*
+* System cap : `${addonId}.${capName}.${method}`
+* Native cap : `${addonId}${NATIVE_PROVIDER_SERVICE_INFIX}.${capName}.${method}`
+*/
 export declare function capActionName(addonId: string, capName: string, method: string, native: boolean): string;
 /**
- * Build the trailing SUFFIX used to scan the Moleculer service registry for
- * any service that exposes a given (capName, method) pair.
- *
- * The suffix `.${capName}.${method}` is compared against full action keys via
- * `action.endsWith(suffix)` in `findServiceCandidates` (trpc-links.ts).
- */
+* Build the trailing SUFFIX used to scan the Moleculer service registry for
+* any service that exposes a given (capName, method) pair.
+*
+* The suffix `.${capName}.${method}` is compared against full action keys via
+* `action.endsWith(suffix)` in `findServiceCandidates` (trpc-links.ts).
+*/
 export declare function capActionSuffix(capName: string, method: string): string;
 /**
- * Build the BARE action name — the key under which addon-service-factory
- * registers the action WITHIN a service (i.e. without the addonId prefix).
- *
- * The full broker key is `${addonId}.${bareAction}` for system caps, but the
- * registry scan checks for `bareAction` directly (`a === bareAction`) to catch
- * the case where the service name itself IS the capName (e.g. stream-broker
- * registering `camera-streams.getRtspEntries`).
- */
+* Build the BARE action name — the key under which addon-service-factory
+* registers the action WITHIN a service (i.e. without the addonId prefix).
+*
+* The full broker key is `${addonId}.${bareAction}` for system caps, but the
+* registry scan checks for `bareAction` directly (`a === bareAction`) to catch
+* the case where the service name itself IS the capName (e.g. stream-broker
+* registering `camera-streams.getRtspEntries`).
+*/
 export declare function capBareAction(capName: string, method: string): string;
 /** Result of parsing a full Moleculer action key. */
 export interface ParsedCapAction {
-    readonly addonId: string;
-    readonly capName: string;
-    readonly method: string;
-    readonly native: boolean;
+	readonly addonId: string;
+	readonly capName: string;
+	readonly method: string;
+	readonly native: boolean;
 }
 /**
- * Parse a full Moleculer action key back into its constituent parts.
- *
- * Handles both forms:
- *   system : `${addonId}.${capName}.${method}`
- *            (splits on first and last dot; 3 segments minimum)
- *   native : `${addonId}${NATIVE_PROVIDER_SERVICE_INFIX}.${capName}.${method}`
- *            (NATIVE_PROVIDER_SERVICE_INFIX = `.native-provider`, so the raw
- *             action has the form `${addonId}.native-provider.${capName}.${method}`)
- *
- * Returns `null` when the action string cannot be parsed into at least 3
- * dot-separated segments.
- *
- * **Parse semantics** — exact inverse of `capActionName`:
- *   capActionName(a, c, m, native)  →  action
- *   parseCapAction(action)          →  { addonId: a, capName: c, method: m, native }
- */
+* Parse a full Moleculer action key back into its constituent parts.
+*
+* Handles both forms:
+*   system : `${addonId}.${capName}.${method}`
+*            (splits on first and last dot; 3 segments minimum)
+*   native : `${addonId}${NATIVE_PROVIDER_SERVICE_INFIX}.${capName}.${method}`
+*            (NATIVE_PROVIDER_SERVICE_INFIX = `.native-provider`, so the raw
+*             action has the form `${addonId}.native-provider.${capName}.${method}`)
+*
+* Returns `null` when the action string cannot be parsed into at least 3
+* dot-separated segments.
+*
+* **Parse semantics** — exact inverse of `capActionName`:
+*   capActionName(a, c, m, native)  →  action
+*   parseCapAction(action)          →  { addonId: a, capName: c, method: m, native }
+*/
 export declare function parseCapAction(action: string): ParsedCapAction | null;