@camstack/system 1.2.389 → 1.2.391

package/dist/kernel/transport/socket-channel.d.ts

@@ -1,116 +1,116 @@
-import { Socket } from 'node:net';
-import { CapActionChannelObserver } from './cap-action-census.js';
-import { EventHandler, LocalChannel, RequestHandler } from './local-transport.js';
-import { SocketTrafficSample } from './socket-traffic.js';
+import type { Socket } from "node:net";
+import type { CapActionChannelObserver } from "./cap-action-census.js";
+import { type EventHandler, type LocalChannel, type RequestHandler } from "./local-transport.js";
+import { type SocketTrafficSample } from "./socket-traffic.js";
 /**
- * Default bound on one UDS request, when the caller names none.
- *
- * Chosen to match `REMOTE_CALL_TIMEOUT_MS` in `cap-route-resolver.ts`: the SAME
- * cap method already dies at 60 s when it resolves to a remote node, so
- * applying the same bound locally makes the two planes consistent rather than
- * newly restrictive. Callers with a legitimately longer method (the cap
- * layer's declared `timeoutMs`, e.g. `applyServerUpdate` at 16 min) pass it
- * explicitly.
- */
-export declare const DEFAULT_UDS_REQUEST_TIMEOUT_MS = 60000;
+* Default bound on one UDS request, when the caller names none.
+*
+* Chosen to match `REMOTE_CALL_TIMEOUT_MS` in `cap-route-resolver.ts`: the SAME
+* cap method already dies at 60 s when it resolves to a remote node, so
+* applying the same bound locally makes the two planes consistent rather than
+* newly restrictive. Callers with a legitimately longer method (the cap
+* layer's declared `timeoutMs`, e.g. `applyServerUpdate` at 16 min) pass it
+* explicitly.
+*/
+export declare const DEFAULT_UDS_REQUEST_TIMEOUT_MS = 6e4;
 /** Per-request options for {@link SocketChannel.request}. */
 export interface SocketRequestOptions {
-    /** Bound in ms; `0` or negative disables the timer entirely. */
-    readonly timeoutMs?: number;
-    /** Opaque bytes carried beside the body — see `LocalRequestOptions.payload`. */
-    readonly payload?: Uint8Array;
+	/** Bound in ms; `0` or negative disables the timer entirely. */
+	readonly timeoutMs?: number;
+	/** Opaque bytes carried beside the body — see `LocalRequestOptions.payload`. */
+	readonly payload?: Uint8Array;
 }
 export declare class SocketChannel implements LocalChannel {
-    private readonly socket;
-    private nextId;
-    private readonly pending;
-    private readonly decoder;
-    private requestHandler;
-    private eventHandler;
-    private closeHandler;
-    private closed;
-    private closeFired;
-    /** Frames written to the peer, cumulative, split by kind. See
-     *  {@link readTraffic} and `transport/socket-traffic.ts`. */
-    private readonly txCounters;
-    /** Frames read from the peer, cumulative, split by kind. */
-    private readonly rxCounters;
-    /** See {@link CapActionChannelObserver}. Absent = no per-action census. */
-    private actionObserver;
-    constructor(socket: Socket);
-    /**
-     * Send a request and wait for the peer's response.
-     *
-     * Bounded. Without a timer this settles on exactly two events — a matching
-     * `res` frame, or the socket's `close` (which drains `pending`) — so a peer
-     * that receives the request and then neither answers nor closes leaves the
-     * caller pending forever. That is a wedged handler, or a half-open socket
-     * after a child died without a clean teardown, and it is how camera 615 spent
-     * 30+ minutes with every inference permit held by a call that was never
-     * coming back.
-     */
-    request(body: unknown, opts?: SocketRequestOptions): Promise<unknown>;
-    emit(body: unknown): void;
-    /**
-     * Wire the per-action census. Only one observer is active at a time; an
-     * unwired channel records nothing at all (never zeros).
-     */
-    observeActions(observer: CapActionChannelObserver): void;
-    /**
-     * The label for one envelope, or `undefined` when there is nothing to
-     * record. Wrapped: a broken labeller must never fail the call it watches —
-     * the same discipline `LocalChildRegistry.recordCapUsage` applies, and for
-     * the same reason.
-     */
-    private labelSafely;
-    /** Settle one request/response pair on the census. Never throws. */
-    private recordAction;
-    /** Replace the request handler. Only one handler is active at a time. */
-    onRequest(handler: RequestHandler): void;
-    /** Replace the event handler. Only one handler is active at a time. */
-    onEvent(handler: EventHandler): void;
-    /** Replace the close handler. Only one handler is active at a time. */
-    onClose(handler: () => void): void;
-    close(): void;
-    /**
-     * This channel's cumulative traffic, both directions, split by frame kind.
-     *
-     * Cumulative for the life of the channel: the reporting layer subtracts the
-     * previous reading, because the question is a RATE ("which peer receives the
-     * 22 500 writes/s") and not a total since boot.
-     */
-    readTraffic(): SocketTrafficSample;
-    /**
-     * Bytes handed to the socket that the kernel has not taken yet — the
-     * `Writable` buffer plus the write in flight. Read LIVE, never cached: this
-     * is the number that says whether the peer is draining what we write, and
-     * it is read on every heartbeat probe (D446). An unref'd socket keeps it
-     * exactly like a ref'd one, which is why it is read here and not summed
-     * over `_getActiveHandles()`.
-     */
-    queuedBytes(): number;
-    /**
-     * Write one frame. With a payload the head and the tail are two `write`
-     * calls under `cork()` — the kernel sees one `writev`, and the payload bytes
-     * are never copied into the head. A forwarded payload is a view into the
-     * frame it arrived on, and that frame's buffer is never mutated, so handing
-     * the view to the socket is safe.
-     *
-     * Returns the on-the-wire bytes it charged — the same number the per-kind
-     * counter got, so the per-action census can never disagree with the per-peer
-     * one. `0` when the channel is closed and nothing was written.
-     */
-    private send;
-    private onData;
-    /**
-     * `wireBytes` is the frame's on-the-wire length, counted HERE rather than in
-     * `onData` on purpose: a peer that sends a frame this decoder can parse but
-     * whose shape is not a `Frame` throws on `frame.k`, and inside this async
-     * method that stays the rejected promise it has always been. Reading `.k`
-     * one frame earlier, synchronously in the socket's `data` handler, would
-     * turn the same malformed frame into an uncaught exception on the transport
-     * — a diagnostic that can crash the process it watches.
-     */
-    private handleFrame;
-    private handleClose;
+	private readonly socket;
+	private nextId;
+	private readonly pending;
+	private readonly decoder;
+	private requestHandler;
+	private eventHandler;
+	private closeHandler;
+	private closed;
+	private closeFired;
+	/** Frames written to the peer, cumulative, split by kind. See
+	*  {@link readTraffic} and `transport/socket-traffic.ts`. */
+	private readonly txCounters;
+	/** Frames read from the peer, cumulative, split by kind. */
+	private readonly rxCounters;
+	/** See {@link CapActionChannelObserver}. Absent = no per-action census. */
+	private actionObserver;
+	constructor(socket: Socket);
+	/**
+	* Send a request and wait for the peer's response.
+	*
+	* Bounded. Without a timer this settles on exactly two events — a matching
+	* `res` frame, or the socket's `close` (which drains `pending`) — so a peer
+	* that receives the request and then neither answers nor closes leaves the
+	* caller pending forever. That is a wedged handler, or a half-open socket
+	* after a child died without a clean teardown, and it is how camera 615 spent
+	* 30+ minutes with every inference permit held by a call that was never
+	* coming back.
+	*/
+	request(body: unknown, opts?: SocketRequestOptions): Promise<unknown>;
+	emit(body: unknown): void;
+	/**
+	* Wire the per-action census. Only one observer is active at a time; an
+	* unwired channel records nothing at all (never zeros).
+	*/
+	observeActions(observer: CapActionChannelObserver): void;
+	/**
+	* The label for one envelope, or `undefined` when there is nothing to
+	* record. Wrapped: a broken labeller must never fail the call it watches —
+	* the same discipline `LocalChildRegistry.recordCapUsage` applies, and for
+	* the same reason.
+	*/
+	private labelSafely;
+	/** Settle one request/response pair on the census. Never throws. */
+	private recordAction;
+	/** Replace the request handler. Only one handler is active at a time. */
+	onRequest(handler: RequestHandler): void;
+	/** Replace the event handler. Only one handler is active at a time. */
+	onEvent(handler: EventHandler): void;
+	/** Replace the close handler. Only one handler is active at a time. */
+	onClose(handler: () => void): void;
+	close(): void;
+	/**
+	* This channel's cumulative traffic, both directions, split by frame kind.
+	*
+	* Cumulative for the life of the channel: the reporting layer subtracts the
+	* previous reading, because the question is a RATE ("which peer receives the
+	* 22 500 writes/s") and not a total since boot.
+	*/
+	readTraffic(): SocketTrafficSample;
+	/**
+	* Bytes handed to the socket that the kernel has not taken yet — the
+	* `Writable` buffer plus the write in flight. Read LIVE, never cached: this
+	* is the number that says whether the peer is draining what we write, and
+	* it is read on every heartbeat probe (D446). An unref'd socket keeps it
+	* exactly like a ref'd one, which is why it is read here and not summed
+	* over `_getActiveHandles()`.
+	*/
+	queuedBytes(): number;
+	/**
+	* Write one frame. With a payload the head and the tail are two `write`
+	* calls under `cork()` — the kernel sees one `writev`, and the payload bytes
+	* are never copied into the head. A forwarded payload is a view into the
+	* frame it arrived on, and that frame's buffer is never mutated, so handing
+	* the view to the socket is safe.
+	*
+	* Returns the on-the-wire bytes it charged — the same number the per-kind
+	* counter got, so the per-action census can never disagree with the per-peer
+	* one. `0` when the channel is closed and nothing was written.
+	*/
+	private send;
+	private onData;
+	/**
+	* `wireBytes` is the frame's on-the-wire length, counted HERE rather than in
+	* `onData` on purpose: a peer that sends a frame this decoder can parse but
+	* whose shape is not a `Frame` throws on `frame.k`, and inside this async
+	* method that stays the rejected promise it has always been. Reading `.k`
+	* one frame earlier, synchronously in the socket's `data` handler, would
+	* turn the same malformed frame into an uncaught exception on the transport
+	* — a diagnostic that can crash the process it watches.
+	*/
+	private handleFrame;
+	private handleClose;
 }

package/dist/kernel/transport/socket-traffic.d.ts

@@ -1,112 +1,112 @@
 /**
- * socket-traffic — per-channel byte and message counters, split by frame kind.
- *
- * ## The question this exists to answer
- *
- * hub-main runs ~22 000 socket reads/s and ~22 500 writes/s at a **0.33 KB
- * mean** (measured 2026-08-29 from `/proc/<pid>/io` with every regular-file
- * descriptor's offset subtracted, so the bytes are socket bytes and not file
- * bytes). That is ~44 000 syscalls/s on the process that mediates every
- * cross-runner call, and **nothing could attribute a single one of them**. The
- * event fan-out plane WAS measurable — `LocalChildRegistry` has counted
- * `sent`/`suppressed` per child since the gate was built — and once surfaced it
- * accounted for **4 %**. The other 96 % had no instrument at all.
- *
- * `/proc` cannot close this: it reports one `rchar`/`wchar` pair for the whole
- * process, and per-socket counters do not exist there. The correlation that was
- * available — 78–82 % of hub-main's outbound bytes moving with
- * `hub/pipeline-analytics` — is derived from that runner's own `rchar`, which
- * also counts page-cache file reads on a runner that owns a vector store. It is
- * a correlation and it has never been an attribution.
- *
- * So the counters have to sit where the frames are: in the channel, on both
- * sides, split by kind.
- *
- * ## Why split by KIND, and why these three
- *
- * A total answers nothing that was not already known. The three wire kinds are
- * three different mechanisms with three different fixes:
- *
- *  - `req` — a cap call this process is making or serving. Scales with work.
- *  - `res` — its answer. Where a payload can be large (a msgpack `Uint8Array`
- *    of GOP bytes is a `res`), so this is the field the "message-RATE, not
- *    media" conclusion is falsified against: if `res` bytes dominate at a large
- *    mean, the traffic is media and D9/D18 must be re-opened.
- *  - `evt` — one-way fan-out. Scales with the number of runners rather than
- *    with anything an operator asked for; an IDLE addon still reads 82
- *    messages/s of it.
- *
- * Bytes AND messages, per kind, because the mean is the whole argument: 0.33 KB
- * across 22 000 reads/s is a rate problem, and the same bytes in 300 messages
- * would be a media problem.
- *
- * ## Why these objects are MUTATED
- *
- * A deliberate, measured exception to the immutability default. The write
- * happens on a path that runs ~44 000 times a second; allocating a replacement
- * object per frame would make the instrument the largest allocator it is trying
- * to measure. The counters are therefore plain mutable numbers, written only by
- * {@link recordSocketFrame} and read only through {@link sampleSocketDirection},
- * which copies. Same discipline `LocalChildRegistry` already applies to
- * `childEventStats`.
- *
- * Cumulative for the life of the channel. A cumulative number on a heartbeat
- * answers "how much since boot", which nobody asked; the reporting layer
- * (`kernel/socket-plane-report.ts`) subtracts the previous reading and reports
- * the window, exactly as the fan-out counters and the loop-delay histogram do.
- */
+* socket-traffic — per-channel byte and message counters, split by frame kind.
+*
+* ## The question this exists to answer
+*
+* hub-main runs ~22 000 socket reads/s and ~22 500 writes/s at a **0.33 KB
+* mean** (measured 2026-08-29 from `/proc/<pid>/io` with every regular-file
+* descriptor's offset subtracted, so the bytes are socket bytes and not file
+* bytes). That is ~44 000 syscalls/s on the process that mediates every
+* cross-runner call, and **nothing could attribute a single one of them**. The
+* event fan-out plane WAS measurable — `LocalChildRegistry` has counted
+* `sent`/`suppressed` per child since the gate was built — and once surfaced it
+* accounted for **4 %**. The other 96 % had no instrument at all.
+*
+* `/proc` cannot close this: it reports one `rchar`/`wchar` pair for the whole
+* process, and per-socket counters do not exist there. The correlation that was
+* available — 78–82 % of hub-main's outbound bytes moving with
+* `hub/pipeline-analytics` — is derived from that runner's own `rchar`, which
+* also counts page-cache file reads on a runner that owns a vector store. It is
+* a correlation and it has never been an attribution.
+*
+* So the counters have to sit where the frames are: in the channel, on both
+* sides, split by kind.
+*
+* ## Why split by KIND, and why these three
+*
+* A total answers nothing that was not already known. The three wire kinds are
+* three different mechanisms with three different fixes:
+*
+*  - `req` — a cap call this process is making or serving. Scales with work.
+*  - `res` — its answer. Where a payload can be large (a msgpack `Uint8Array`
+*    of GOP bytes is a `res`), so this is the field the "message-RATE, not
+*    media" conclusion is falsified against: if `res` bytes dominate at a large
+*    mean, the traffic is media and D9/D18 must be re-opened.
+*  - `evt` — one-way fan-out. Scales with the number of runners rather than
+*    with anything an operator asked for; an IDLE addon still reads 82
+*    messages/s of it.
+*
+* Bytes AND messages, per kind, because the mean is the whole argument: 0.33 KB
+* across 22 000 reads/s is a rate problem, and the same bytes in 300 messages
+* would be a media problem.
+*
+* ## Why these objects are MUTATED
+*
+* A deliberate, measured exception to the immutability default. The write
+* happens on a path that runs ~44 000 times a second; allocating a replacement
+* object per frame would make the instrument the largest allocator it is trying
+* to measure. The counters are therefore plain mutable numbers, written only by
+* {@link recordSocketFrame} and read only through {@link sampleSocketDirection},
+* which copies. Same discipline `LocalChildRegistry` already applies to
+* `childEventStats`.
+*
+* Cumulative for the life of the channel. A cumulative number on a heartbeat
+* answers "how much since boot", which nobody asked; the reporting layer
+* (`kernel/socket-plane-report.ts`) subtracts the previous reading and reports
+* the window, exactly as the fan-out counters and the loop-delay histogram do.
+*/
 /** The three wire kinds of {@link import('./local-transport.js').Frame}. */
-export type SocketMessageKind = 'req' | 'res' | 'evt';
+export type SocketMessageKind = "req" | "res" | "evt";
 /**
- * One direction of one channel, cumulative. Mutable by design — see the module
- * docblock; nothing outside {@link recordSocketFrame} may write these.
- *
- * `bytes` is the ON-THE-WIRE size: the 4-byte length prefix plus the MsgPack
- * body, i.e. exactly what `socket.write` was handed and exactly what the peer's
- * `rchar` will have counted. Anything else would not reconcile against `/proc`,
- * and reconciling against `/proc` is the only reason to trust either number.
- */
+* One direction of one channel, cumulative. Mutable by design — see the module
+* docblock; nothing outside {@link recordSocketFrame} may write these.
+*
+* `bytes` is the ON-THE-WIRE size: the 4-byte length prefix plus the MsgPack
+* body, i.e. exactly what `socket.write` was handed and exactly what the peer's
+* `rchar` will have counted. Anything else would not reconcile against `/proc`,
+* and reconciling against `/proc` is the only reason to trust either number.
+*/
 export interface SocketDirectionCounters {
-    reqMessages: number;
-    reqBytes: number;
-    resMessages: number;
-    resBytes: number;
-    evtMessages: number;
-    evtBytes: number;
+	reqMessages: number;
+	reqBytes: number;
+	resMessages: number;
+	resBytes: number;
+	evtMessages: number;
+	evtBytes: number;
 }
 /** An immutable reading of {@link SocketDirectionCounters}. */
 export interface SocketDirectionSample {
-    readonly reqMessages: number;
-    readonly reqBytes: number;
-    readonly resMessages: number;
-    readonly resBytes: number;
-    readonly evtMessages: number;
-    readonly evtBytes: number;
+	readonly reqMessages: number;
+	readonly reqBytes: number;
+	readonly resMessages: number;
+	readonly resBytes: number;
+	readonly evtMessages: number;
+	readonly evtBytes: number;
 }
 /** Both directions of one channel. */
 export interface SocketTrafficSample {
-    /** Frames this process WROTE to the peer. */
-    readonly tx: SocketDirectionSample;
-    /** Frames this process READ from the peer. */
-    readonly rx: SocketDirectionSample;
+	/** Frames this process WROTE to the peer. */
+	readonly tx: SocketDirectionSample;
+	/** Frames this process READ from the peer. */
+	readonly rx: SocketDirectionSample;
 }
 export declare function createSocketDirectionCounters(): SocketDirectionCounters;
 /**
- * The hot-path write. Two additions and at most two string comparisons against
- * interned literals — no allocation, no branch on anything the caller has to
- * compute, and nothing that can throw.
- *
- * Measured on Node 24.17, 20 M iterations, three runs: **2.37–2.41 ns/call**
- * against an empty loop. Its neighbours on the same path, measured in the same
- * run: `encodeFrame` on a 0.33 KB body 1948–1975 ns, `FrameDecoder.push`
- * 1156–1166 ns, `process.memoryUsage()` 920–945 ns. The counter is **0.12 % of
- * `encodeFrame`** — and `encodeFrame` is followed by a syscall.
- *
- * Together with the decoder's per-frame size write (0.06–0.13 ns, see
- * `frame-codec.ts`) the whole instrument adds **~2.5 ns per frame**: at 44 000
- * frames/s that is 107–111 µs/s, i.e. **0.011 % of one core**. An instrument
- * that changes what it measures is not an instrument, and this one cannot.
- */
+* The hot-path write. Two additions and at most two string comparisons against
+* interned literals — no allocation, no branch on anything the caller has to
+* compute, and nothing that can throw.
+*
+* Measured on Node 24.17, 20 M iterations, three runs: **2.37–2.41 ns/call**
+* against an empty loop. Its neighbours on the same path, measured in the same
+* run: `encodeFrame` on a 0.33 KB body 1948–1975 ns, `FrameDecoder.push`
+* 1156–1166 ns, `process.memoryUsage()` 920–945 ns. The counter is **0.12 % of
+* `encodeFrame`** — and `encodeFrame` is followed by a syscall.
+*
+* Together with the decoder's per-frame size write (0.06–0.13 ns, see
+* `frame-codec.ts`) the whole instrument adds **~2.5 ns per frame**: at 44 000
+* frames/s that is 107–111 µs/s, i.e. **0.011 % of one core**. An instrument
+* that changes what it measures is not an instrument, and this one cannot.
+*/
 export declare function recordSocketFrame(counters: SocketDirectionCounters, kind: SocketMessageKind, bytes: number): void;
 /** Copy out. Called once per heartbeat line, never on the frame path. */
 export declare function sampleSocketDirection(counters: SocketDirectionCounters): SocketDirectionSample;

package/dist/kernel/transport/uds-event-bridge.d.ts

@@ -1,58 +1,85 @@
-import { IEventBus, SystemEvent } from '@camstack/types';
 /**
- * Minimal surface the bridge requires from `LocalChildRegistry`.
- * Structurally typed so tests can provide a fake without any casts.
- *
- * CONTRACT: `broadcastEventToChildren` is SUBSCRIPTION-FILTERED. The registry
- * fans an event only to children whose declared category-pattern set matches
- * `event.category` (mirror of each child's local `SharedBusState.handlers`
- * keys). A child that never declared a set (legacy/undeclared) fails OPEN and
- * receives everything. There is no kill-switch any more (the
- * `CAMSTACK_UDS_EVENT_FANOUT` modes were removed on 2026-10-06). The bridge itself
- * needs no per-event logic change — both fan-out call sites here go through the
- * filtered `broadcastEventToChildren`. `sendEventToChild` (targeted push) is
- * NOT filtered — an explicit single-child send expresses intent.
- */
+* Parent-side UDS ↔ Moleculer event bridge (C2).
+*
+* Wires the `LocalChildRegistry`'s child-event stream into the parent's own
+* event bus + the cross-node Moleculer cluster, and forwards cluster / parent-
+* local events back to every UDS child — with NO echo and NO duplicate delivery.
+*
+* ## Echo / duplication prevention (id-dedupe set)
+*
+* When a child emits event E:
+*  1. The bridge fans E to siblings immediately via
+*     `registry.broadcastEventToChildren(E, parentNodeId, childId)`.
+*  2. The bridge records E.id in `recentlyFannedIds` and emits the CLEAN
+*     (unmarked) event to the parent bus so parent-local subscribers and the
+*     cluster receive it. The cluster broadcast carries the clean event — no
+*     extra fields travel to remote nodes.
+*  3. The bridge's own parent-bus subscriber fires synchronously inside
+*     `parentBus.emit` (deliverShared is synchronous). Because `recentlyFannedIds`
+*     was populated in step 2 BEFORE `parentBus.emit` returns, the id is in the
+*     set when the loopback check runs — no re-fan occurs.
+*  4. For any event whose id is NOT in `recentlyFannedIds` (remote cluster event,
+*     parent-process-local event) the subscriber fans it to all children.
+*
+* The set is bounded at MAX_RECENT entries (FIFO eviction of the oldest).
+* Normal event rates are well below this limit; the cap prevents unbounded growth
+* if the bridge is left live for a long time with no dispose.
+*/
+import type { IEventBus, SystemEvent } from "@camstack/types";
+/**
+* Minimal surface the bridge requires from `LocalChildRegistry`.
+* Structurally typed so tests can provide a fake without any casts.
+*
+* CONTRACT: `broadcastEventToChildren` is SUBSCRIPTION-FILTERED. The registry
+* fans an event only to children whose declared category-pattern set matches
+* `event.category` (mirror of each child's local `SharedBusState.handlers`
+* keys). A child that never declared a set (legacy/undeclared) fails OPEN and
+* receives everything. There is no kill-switch any more (the
+* `CAMSTACK_UDS_EVENT_FANOUT` modes were removed on 2026-10-06). The bridge itself
+* needs no per-event logic change — both fan-out call sites here go through the
+* filtered `broadcastEventToChildren`. `sendEventToChild` (targeted push) is
+* NOT filtered — an explicit single-child send expresses intent.
+*/
 export interface ChildEventBroadcaster {
-    /**
-     * Register the (single) child-event handler, or pass `null` to clear it.
-     * A new handler replaces the prior one; `null` removes it entirely.
-     */
-    onChildEvent(handler: ((childId: string, event: SystemEvent) => void) | null): void;
-    sendEventToChild(childId: string, event: SystemEvent, sourceNodeId: string): void;
-    broadcastEventToChildren(event: SystemEvent, sourceNodeId: string, exceptChildId?: string): void;
+	/**
+	* Register the (single) child-event handler, or pass `null` to clear it.
+	* A new handler replaces the prior one; `null` removes it entirely.
+	*/
+	onChildEvent(handler: ((childId: string, event: SystemEvent) => void) | null): void;
+	sendEventToChild(childId: string, event: SystemEvent, sourceNodeId: string): void;
+	broadcastEventToChildren(event: SystemEvent, sourceNodeId: string, exceptChildId?: string): void;
 }
 /**
- * Dependencies for the UDS event bridge.
- */
+* Dependencies for the UDS event bridge.
+*/
 export interface UdsEventBridgeDeps {
-    /** The parent-side child registry. Only the event-related surface is required. */
-    readonly registry: ChildEventBroadcaster;
-    /** The parent process's event bus (backed by `getBrokerEventBus(broker)`). */
-    readonly parentBus: IEventBus;
-    /** This process's Moleculer node ID (e.g. `'hub'` or `'agent-a1b2c3'`). */
-    readonly parentNodeId: string;
-    /**
-     * D2: subscribe the bridge's cluster/parent-local → children RELAY handler to
-     * the parent bus WITHOUT registering it in the node's local-interest surface
-     * (`subscribePassthrough` from `@camstack/system`). The bridge is a conduit to
-     * forked children, not a terminal local consumer — counting its wildcard `*`
-     * subscription would make every cross-node category appear "wanted" and defeat
-     * the inbound gate. When omitted (tests / legacy callers) the bridge falls
-     * back to `parentBus.subscribe({}, …)`, which is functionally correct but
-     * counts toward local interest — acceptable only where the D2 gate is not
-     * under test.
-     */
-    readonly subscribePassthrough?: (handler: (event: SystemEvent) => void) => () => void;
+	/** The parent-side child registry. Only the event-related surface is required. */
+	readonly registry: ChildEventBroadcaster;
+	/** The parent process's event bus (backed by `getBrokerEventBus(broker)`). */
+	readonly parentBus: IEventBus;
+	/** This process's Moleculer node ID (e.g. `'hub'` or `'agent-a1b2c3'`). */
+	readonly parentNodeId: string;
+	/**
+	* D2: subscribe the bridge's cluster/parent-local → children RELAY handler to
+	* the parent bus WITHOUT registering it in the node's local-interest surface
+	* (`subscribePassthrough` from `@camstack/system`). The bridge is a conduit to
+	* forked children, not a terminal local consumer — counting its wildcard `*`
+	* subscription would make every cross-node category appear "wanted" and defeat
+	* the inbound gate. When omitted (tests / legacy callers) the bridge falls
+	* back to `parentBus.subscribe({}, …)`, which is functionally correct but
+	* counts toward local interest — acceptable only where the D2 gate is not
+	* under test.
+	*/
+	readonly subscribePassthrough?: (handler: (event: SystemEvent) => void) => () => void;
 }
 /**
- * Create the parent-side UDS ↔ Moleculer event bridge.
- *
- * Call this once after the parent's `LocalChildRegistry` and `IEventBus` are
- * both ready. The bridge is inert-but-correct while no children are connected
- * (UDS child events never arrive, cluster events are fan-outed to zero children).
- *
- * @returns A disposer function that unsubscribes the bridge from the parent bus
- *          and clears the child-event handler. Call it on process shutdown.
- */
+* Create the parent-side UDS ↔ Moleculer event bridge.
+*
+* Call this once after the parent's `LocalChildRegistry` and `IEventBus` are
+* both ready. The bridge is inert-but-correct while no children are connected
+* (UDS child events never arrive, cluster events are fan-outed to zero children).
+*
+* @returns A disposer function that unsubscribes the bridge from the parent bus
+*          and clears the child-event handler. Call it on process shutdown.
+*/
 export declare function createUdsEventBridge(deps: UdsEventBridgeDeps): () => void;