@camstack/system 1.2.389 → 1.2.391

package/dist/kernel/transport/frame-codec.d.ts

@@ -1,122 +1,122 @@
 /** Encode a value as a length-prefixed (4-byte big-endian) MsgPack frame. */
 export declare function encodeFrame(value: unknown): Buffer;
 /**
- * The key under which an opaque payload rides on a frame — see
- * {@link encodeFrameHead}. Short on purpose: it is written once per frame by
- * hand, and it is the one msgpack key on this plane a decoder must never
- * interpret.
- */
+* The key under which an opaque payload rides on a frame — see
+* {@link encodeFrameHead}. Short on purpose: it is written once per frame by
+* hand, and it is the one msgpack key on this plane a decoder must never
+* interpret.
+*/
 export declare const PAYLOAD_KEY = "pl";
 /**
- * Encode the HEAD of a frame that carries an opaque payload: the length
- * prefix, the msgpack envelope with one extra key ({@link PAYLOAD_KEY}), and
- * the `bin 32` header for the payload — everything but the payload bytes
- * themselves, which the caller writes straight after it.
- *
- * ## Why the payload is the frame's TAIL and not a field
- *
- * hub-main routes every sibling↔sibling call. Until this existed it decoded
- * the whole request (args included), built a new message, and re-encoded it
- * — walking a 13.5 KB PCM chunk or a 2 000-row settings answer twice on the
- * one thread that serves every tRPC request, and allocating an `Encoder`
- * buffer that doubles from 2 KiB up to the body's size on every write
- * (D441: ~27 % of hub-main's busy time in msgpack decode, ~6 % in encode,
- * and the churn that fed a 29.5 % GC share).
- *
- * With the payload appended as the LAST key of the map, the receiver's
- * ordinary msgpack decode yields it as a zero-copy VIEW of the frame
- * (`@msgpack/msgpack` decodes `bin` as `subarray`), the router reads only the
- * envelope, and forwarding is: encode a ~60-byte head, write it, write the
- * view. The wire stays plain msgpack — a peer that never heard of payloads
- * decodes `{ …frame, pl: <bytes> }` and can be told, at register, not to be
- * sent one.
- *
- * ## The one hand-written msgpack in this repository
- *
- * `@msgpack/msgpack` has no "encode a map, then append a key" API, so the
- * envelope is encoded normally and its `fixmap` count byte is bumped by one
- * before the key and the `bin 32` header are appended. That patch is only
- * valid for a `fixmap` (≤ 15 keys); a `Frame` has at most four, and anything
- * else is refused rather than silently corrupted.
- */
+* Encode the HEAD of a frame that carries an opaque payload: the length
+* prefix, the msgpack envelope with one extra key ({@link PAYLOAD_KEY}), and
+* the `bin 32` header for the payload — everything but the payload bytes
+* themselves, which the caller writes straight after it.
+*
+* ## Why the payload is the frame's TAIL and not a field
+*
+* hub-main routes every sibling↔sibling call. Until this existed it decoded
+* the whole request (args included), built a new message, and re-encoded it
+* — walking a 13.5 KB PCM chunk or a 2 000-row settings answer twice on the
+* one thread that serves every tRPC request, and allocating an `Encoder`
+* buffer that doubles from 2 KiB up to the body's size on every write
+* (D441: ~27 % of hub-main's busy time in msgpack decode, ~6 % in encode,
+* and the churn that fed a 29.5 % GC share).
+*
+* With the payload appended as the LAST key of the map, the receiver's
+* ordinary msgpack decode yields it as a zero-copy VIEW of the frame
+* (`@msgpack/msgpack` decodes `bin` as `subarray`), the router reads only the
+* envelope, and forwarding is: encode a ~60-byte head, write it, write the
+* view. The wire stays plain msgpack — a peer that never heard of payloads
+* decodes `{ …frame, pl: <bytes> }` and can be told, at register, not to be
+* sent one.
+*
+* ## The one hand-written msgpack in this repository
+*
+* `@msgpack/msgpack` has no "encode a map, then append a key" API, so the
+* envelope is encoded normally and its `fixmap` count byte is bumped by one
+* before the key and the `bin 32` header are appended. That patch is only
+* valid for a `fixmap` (≤ 15 keys); a `Frame` has at most four, and anything
+* else is refused rather than silently corrupted.
+*/
 export declare function encodeFrameHead(frame: Record<string, unknown>, payload: Uint8Array): Buffer;
 /**
- * Serialise a value into the bytes a payload carries. The SAME options as the
- * envelope codec, so `undefined` properties are omitted rather than turned
- * into `null` — a `z.void()` cap output must read back as `undefined` on the
- * far side exactly as it did when it travelled inline.
- */
+* Serialise a value into the bytes a payload carries. The SAME options as the
+* envelope codec, so `undefined` properties are omitted rather than turned
+* into `null` — a `z.void()` cap output must read back as `undefined` on the
+* far side exactly as it did when it travelled inline.
+*/
 export declare function packPayload(value: unknown): Uint8Array;
 /** Inverse of {@link packPayload}. A `bin` inside decodes as a view of `bytes`. */
 export declare function unpackPayload(bytes: Uint8Array): unknown;
 /**
- * Reassembles length-prefixed MsgPack frames from a byte stream.
- *
- * **Why this is a chunk LIST and not a growing Buffer.** The original
- * accumulator did `this.buf = Buffer.concat([this.buf, chunk])` on every
- * socket `data` event. A frame of N bytes delivered in C-byte pieces
- * therefore copied ~N²/2C bytes: a 4 MiB native crop arriving in 64 KiB
- * chunks is ~128 MiB of memcpy plus 64 intermediate Buffer allocations,
- * synchronously, on the thread that also serves every tRPC request. Media
- * transits this router constantly, and hub-main was measured busy 82.2 s out
- * of 120 with 22 uninterrupted blocks ≥1 s.
- *
- * Here the pending chunks are kept as-is and joined ONCE, when a frame is
- * complete — and not even then in the common case, because a frame that
- * arrived whole inside one chunk is sliced out with zero copying. Total work
- * is linear in the bytes received.
- *
- * The wire contract is unchanged: 4-byte big-endian length, then that many
- * MsgPack bytes; a partial frame is buffered; several frames in one chunk are
- * all returned; a frame spanning any number of chunks is reassembled. There
- * is still no upper bound on a declared length — an oversized prefix parks
- * bytes in `chunks` until the peer completes or the socket closes, exactly as
- * before. Bounding it is a transport-protocol change, not a decoder cleanup.
- */
+* Reassembles length-prefixed MsgPack frames from a byte stream.
+*
+* **Why this is a chunk LIST and not a growing Buffer.** The original
+* accumulator did `this.buf = Buffer.concat([this.buf, chunk])` on every
+* socket `data` event. A frame of N bytes delivered in C-byte pieces
+* therefore copied ~N²/2C bytes: a 4 MiB native crop arriving in 64 KiB
+* chunks is ~128 MiB of memcpy plus 64 intermediate Buffer allocations,
+* synchronously, on the thread that also serves every tRPC request. Media
+* transits this router constantly, and hub-main was measured busy 82.2 s out
+* of 120 with 22 uninterrupted blocks ≥1 s.
+*
+* Here the pending chunks are kept as-is and joined ONCE, when a frame is
+* complete — and not even then in the common case, because a frame that
+* arrived whole inside one chunk is sliced out with zero copying. Total work
+* is linear in the bytes received.
+*
+* The wire contract is unchanged: 4-byte big-endian length, then that many
+* MsgPack bytes; a partial frame is buffered; several frames in one chunk are
+* all returned; a frame spanning any number of chunks is reassembled. There
+* is still no upper bound on a declared length — an oversized prefix parks
+* bytes in `chunks` until the peer completes or the socket closes, exactly as
+* before. Bounding it is a transport-protocol change, not a decoder cleanup.
+*/
 export declare class FrameDecoder {
-    /** Unconsumed bytes, oldest first. `chunks[0]` starts at a frame boundary. */
-    private chunks;
-    /** Sum of `chunks[i].byteLength` — tracked so length checks cost nothing. */
-    private buffered;
-    /** Backing store for {@link lastFrameBytes}; see that getter. */
-    private readonly sizes;
-    /**
-     * On-the-wire byte length (4-byte prefix included) of each frame returned by
-     * the most recent {@link push}, index-aligned with the returned array.
-     *
-     * It exists because the frames come back DECODED, and a decoded value has no
-     * memory of how many bytes it cost — so a caller counting received bytes per
-     * message kind (`SocketChannel`, feeding the `[mem]` line's per-peer socket
-     * attribution) could otherwise only charge a whole `data` chunk, which may
-     * hold several frames of different kinds, or half of one.
-     *
-     * **Only the first `frames.length` entries are meaningful**, and the array is
-     * never truncated. That is deliberate and it was measured on Node 24.17:
-     * `sizes.length = 0` + `push` costs **35.1–35.9 ns** per call — V8 shrinks the
-     * backing store and the next call re-grows it — which is 3 % of
-     * `FrameDecoder.push` itself and 15× the counter it feeds. Writing in place
-     * costs **0.06–0.13 ns**. On a path that runs ~22 000 times a second, an
-     * instrument may not be the most expensive thing on the line it measures.
-     *
-     * Read it immediately after the `push` that produced it — it is a window onto
-     * the decoder, not a value. Safe because `push` is only ever driven by a
-     * socket `data` event, which Node never delivers re-entrantly.
-     */
-    get lastFrameBytes(): readonly number[];
-    push(chunk: Buffer): unknown[];
-    /**
-     * Read the frame length without consuming it. The prefix itself can land
-     * across a chunk boundary (a 3-byte first chunk is a real socket event), so
-     * the slow path walks bytes until it has all four.
-     */
-    private readLength;
-    /**
-     * Consume and return exactly `n` contiguous bytes.
-     *
-     * Three cases, cheapest first: the head chunk already holds the whole frame
-     * (no copy at all, just a view); the head chunk holds more than the frame
-     * (a view plus a rebased head); the frame spans chunks (ONE `Buffer.concat`
-     * sized to the frame — the single copy this class is allowed).
-     */
-    private take;
+	/** Unconsumed bytes, oldest first. `chunks[0]` starts at a frame boundary. */
+	private chunks;
+	/** Sum of `chunks[i].byteLength` — tracked so length checks cost nothing. */
+	private buffered;
+	/** Backing store for {@link lastFrameBytes}; see that getter. */
+	private readonly sizes;
+	/**
+	* On-the-wire byte length (4-byte prefix included) of each frame returned by
+	* the most recent {@link push}, index-aligned with the returned array.
+	*
+	* It exists because the frames come back DECODED, and a decoded value has no
+	* memory of how many bytes it cost — so a caller counting received bytes per
+	* message kind (`SocketChannel`, feeding the `[mem]` line's per-peer socket
+	* attribution) could otherwise only charge a whole `data` chunk, which may
+	* hold several frames of different kinds, or half of one.
+	*
+	* **Only the first `frames.length` entries are meaningful**, and the array is
+	* never truncated. That is deliberate and it was measured on Node 24.17:
+	* `sizes.length = 0` + `push` costs **35.1–35.9 ns** per call — V8 shrinks the
+	* backing store and the next call re-grows it — which is 3 % of
+	* `FrameDecoder.push` itself and 15× the counter it feeds. Writing in place
+	* costs **0.06–0.13 ns**. On a path that runs ~22 000 times a second, an
+	* instrument may not be the most expensive thing on the line it measures.
+	*
+	* Read it immediately after the `push` that produced it — it is a window onto
+	* the decoder, not a value. Safe because `push` is only ever driven by a
+	* socket `data` event, which Node never delivers re-entrantly.
+	*/
+	get lastFrameBytes(): readonly number[];
+	push(chunk: Buffer): unknown[];
+	/**
+	* Read the frame length without consuming it. The prefix itself can land
+	* across a chunk boundary (a 3-byte first chunk is a real socket event), so
+	* the slow path walks bytes until it has all four.
+	*/
+	private readLength;
+	/**
+	* Consume and return exactly `n` contiguous bytes.
+	*
+	* Three cases, cheapest first: the head chunk already holds the whole frame
+	* (no copy at all, just a view); the head chunk holds more than the frame
+	* (a view plus a rebased head); the frame spans chunks (ONE `Buffer.concat`
+	* sized to the frame — the single copy this class is allowed).
+	*/
+	private take;
 }

package/dist/kernel/transport/hub-cap-forward.d.ts

@@ -1,74 +1,96 @@
-import { ServiceSchema } from 'moleculer';
-import { CapCallInput } from './child-cap-protocol.js';
+/**
+* `$hub-cap-fwd` — the hub-side Moleculer service that lets a REMOTE agent reach
+* a cap the hub routes (hub-in-process, a hub-local UDS child like `stream-broker`
+* / `settings-store`, or even another agent via the hub's resolver).
+*
+* It is the exact symmetric inverse of `$agent-cap-fwd` (hub→agent forward,
+* `agent-cap-dispatch-service.ts`): where the agent service fans a hub-dispatched
+* call into the agent's own UDS subtree, THIS service fans an agent-originated
+* call into the HUB's routing (`onUnownedCall`). Without it a forked addon on an
+* agent that calls `ctx.api.<hubCap>.<method>` falls to raw Moleculer service
+* discovery for `${cap}.*` — which does NOT exist, because hub-local addon
+* runners register NO Moleculer service (UDS-only) — and 30s-deadlines
+* (`trpc-links.ts` "discovery deadline exceeded"). See
+* docs/superpowers/2026-07-02-crossnode-hub-cap-forward-design.md.
+*
+* The `forward` handler simply invokes the hub's EXISTING `onUnownedCall`
+* handler (`createParentUnownedCallHandler`) — the same battle-tested path the
+* hub already uses to route its own forked children's unowned calls
+* (resolver-first: hub-in-process → hub-local-uds → remote; broker-fallback for
+* the hub's `$`-core services). So the agent gets the hub's full routing for
+* free, with no duplication.
+*/
+import type { ServiceSchema } from "moleculer";
+import type { CapCallInput } from "./child-cap-protocol.js";
 /** The Moleculer service name the hub registers for agent→hub cap forwarding. */
 export declare const HUB_CAP_FWD_SERVICE: "$hub-cap-fwd";
 /** The Moleculer action (service.action) for hub cap forwarding. */
-export declare const HUB_CAP_FWD_ACTION: "$hub-cap-fwd.forward";
+export declare const HUB_CAP_FWD_ACTION: string;
 /**
- * Params envelope an agent sends to `$hub-cap-fwd.forward`. Mirrors
- * {@link CapCallInput} (the hub's onUnownedCall input): `capName` + `method` are
- * required; `args` passes through; `deviceId` / `nodeId` are optional routing
- * hints the hub's resolver honours.
- */
+* Params envelope an agent sends to `$hub-cap-fwd.forward`. Mirrors
+* {@link CapCallInput} (the hub's onUnownedCall input): `capName` + `method` are
+* required; `args` passes through; `deviceId` / `nodeId` are optional routing
+* hints the hub's resolver honours.
+*/
 export interface HubCapForwardParams {
-    readonly capName: string;
-    readonly method: string;
-    readonly args: unknown;
-    readonly deviceId?: number;
-    readonly nodeId?: string;
-    /**
-     * Native-only routing hint (see `CapCallOutMessage.native`). An agent has no
-     * native authority of its own, so a forked wrapper on an agent asking for a
-     * per-device native forwards the question here. It MUST survive the envelope:
-     * without it the hub resolves the cap NAME, i.e. the wrapper the caller is
-     * trying to skip.
-     */
-    readonly native?: boolean;
-    /**
-     * The ORIGINATING addon, stamped by the AGENT's `LocalChildRegistry` off the
-     * child connection the call arrived on (D787) — the agent-side equivalent of
-     * what the hub's own registry stamps for a hub-local child. The hub believes
-     * it only from a node that joined the mesh (D802: challenge–response; in
-     * `transition` an unauthenticated node is tolerated) and only when that
-     * node's registered manifest hosts the runner ({@link HubCapForwardOptions}).
-     * Absent → the call is anonymous, and an owner-checked cap refuses it.
-     */
-    readonly callerAddonId?: string;
+	readonly capName: string;
+	readonly method: string;
+	readonly args: unknown;
+	readonly deviceId?: number;
+	readonly nodeId?: string;
+	/**
+	* Native-only routing hint (see `CapCallOutMessage.native`). An agent has no
+	* native authority of its own, so a forked wrapper on an agent asking for a
+	* per-device native forwards the question here. It MUST survive the envelope:
+	* without it the hub resolves the cap NAME, i.e. the wrapper the caller is
+	* trying to skip.
+	*/
+	readonly native?: boolean;
+	/**
+	* The ORIGINATING addon, stamped by the AGENT's `LocalChildRegistry` off the
+	* child connection the call arrived on (D787) — the agent-side equivalent of
+	* what the hub's own registry stamps for a hub-local child. The hub believes
+	* it only from a node that joined the mesh (D802: challenge–response; in
+	* `transition` an unauthenticated node is tolerated) and only when that
+	* node's registered manifest hosts the runner ({@link HubCapForwardOptions}).
+	* Absent → the call is anonymous, and an owner-checked cap refuses it.
+	*/
+	readonly callerAddonId?: string;
 }
 /** How the hub decides whether an agent's caller stamp is believable. */
 export interface HubCapForwardOptions {
-    /**
-     * Is `callerAddonId` (a runner id) actually running on `nodeId`, the agent
-     * this request came from? A stamp that fails the check is DROPPED — the call
-     * proceeds anonymous, it is not refused here. Omitted → stamps are trusted
-     * as the cluster secret already authenticates the node.
-     */
-    readonly isCallerOnNode?: (nodeId: string, callerAddonId: string) => boolean;
-    /** Told about a dropped stamp — a misrouted or lying runner deserves a line. */
-    readonly onRejectedCaller?: (nodeId: string, callerAddonId: string) => void;
+	/**
+	* Is `callerAddonId` (a runner id) actually running on `nodeId`, the agent
+	* this request came from? A stamp that fails the check is DROPPED — the call
+	* proceeds anonymous, it is not refused here. Omitted → stamps are trusted
+	* as the cluster secret already authenticates the node.
+	*/
+	readonly isCallerOnNode?: (nodeId: string, callerAddonId: string) => boolean;
+	/** Told about a dropped stamp — a misrouted or lying runner deserves a line. */
+	readonly onRejectedCaller?: (nodeId: string, callerAddonId: string) => void;
 }
 /**
- * Drop a `caller` the forwarded args carry. `caller` is the USER identity the
- * hub's tRPC router injects for `caller: 'required'` methods
- * (`cap-router-builder.ts`), and providers trust it — `keychainAdmin.reveal`
- * reads `input.caller.userId`. A call that arrives over the mesh has no user
- * session behind it, so whatever `caller` it carries is forged (D802). The
- * args' `callerAddonId` is overwritten or stripped further down by
- * `stampCallerAddonId`; `caller` had no such guard.
- */
+* Drop a `caller` the forwarded args carry. `caller` is the USER identity the
+* hub's tRPC router injects for `caller: 'required'` methods
+* (`cap-router-builder.ts`), and providers trust it — `keychainAdmin.reveal`
+* reads `input.caller.userId`. A call that arrives over the mesh has no user
+* session behind it, so whatever `caller` it carries is forged (D802). The
+* args' `callerAddonId` is overwritten or stripped further down by
+* `stampCallerAddonId`; `caller` had no such guard.
+*/
 export declare function stripForwardedCaller(args: unknown): unknown;
 /**
- * Handler that routes an agent-originated cap call through the hub's own
- * unowned-call routing. Structurally the hub's `onUnownedCall`.
- */
+* Handler that routes an agent-originated cap call through the hub's own
+* unowned-call routing. Structurally the hub's `onUnownedCall`.
+*/
 export type HubUnownedCallHandler = (input: CapCallInput) => Promise<unknown>;
 /**
- * Build the `$hub-cap-fwd` Moleculer `ServiceSchema`. The hub registers this on
- * its broker (only the hub registers it → an agent's `broker.call` for
- * `$hub-cap-fwd.forward` discovers it on the hub with no explicit nodeID pin).
- *
- * @param onUnownedCall  The hub's cap routing handler (from
- *                       `createParentUnownedCallHandler`). Reused verbatim so
- *                       forwarded calls route exactly like a hub-local child's.
- */
+* Build the `$hub-cap-fwd` Moleculer `ServiceSchema`. The hub registers this on
+* its broker (only the hub registers it → an agent's `broker.call` for
+* `$hub-cap-fwd.forward` discovers it on the hub with no explicit nodeID pin).
+*
+* @param onUnownedCall  The hub's cap routing handler (from
+*                       `createParentUnownedCallHandler`). Reused verbatim so
+*                       forwarded calls route exactly like a hub-local child's.
+*/
 export declare function createHubCapForwardService(onUnownedCall: HubUnownedCallHandler, options?: HubCapForwardOptions): ServiceSchema;

package/dist/kernel/transport/index.d.ts

@@ -1,36 +1,36 @@
-export type { Frame, RequestHandler, EventHandler, LocalChannel, LocalTransportServer, LocalTransportClient, LocalTransportFactory, } from './local-transport.js';
-export { encodeFrame, FrameDecoder } from './frame-codec.js';
-export type { SocketDirectionCounters, SocketDirectionSample, SocketMessageKind, SocketTrafficSample, } from './socket-traffic.js';
-export { createSocketDirectionCounters, EMPTY_SOCKET_DIRECTION, recordSocketFrame, sampleSocketDirection, socketDirectionBytes, socketDirectionMessages, } from './socket-traffic.js';
-export type { CapActionCensus, CapActionChannelObserver, CapActionDelta, CapActionReading, CapActionSample, CapActionWindow, } from './cap-action-census.js';
-export { CAP_ACTION_OVERFLOW_LABEL, CAP_ACTION_UNLABELLED, capActionLabel, createCapActionCensus, diffCapActionCensus, EMPTY_CAP_ACTION_READING, MAX_CAP_ACTIONS_PER_PEER, } from './cap-action-census.js';
-export { localEndpointPath } from './local-endpoint-path.js';
-export { SocketChannel } from './socket-channel.js';
-export { PeerAnsweredError } from './peer-answered-error.js';
-export { UdsLocalTransportServer, UdsLocalTransportClient } from './uds-local-transport.js';
-export { createLocalTransport } from './create-local-transport.js';
-export type { ChildCapDescriptor, RegisterMessage, ChildLogMessage, ChildEventMessage, ChildToParentRequest, CapCallMessage, CapCallInput, CapCallOutMessage, AddonCallMessage, AddonCallInput, AddonCallTarget, AddonSettingsMethod, ParentToChildRequest, RegisteredChild, SetLogLevelMessage, } from './child-cap-protocol.js';
-export { LocalChildRegistry, afterWorkerOnlineAnnounce, UDS_NO_ROUTE_PREFIX, } from './local-child-registry.js';
-export type { LocalChildRegistryOptions, LocalChildRegistryLogger, ChildLifecycleEvents, } from './local-child-registry.js';
-export type { LocalChildClientOptions, AddonCallHandler } from './local-child-client.js';
-export { LocalChildClient } from './local-child-client.js';
-export type { CapRoute, CapRouteBase, CapRouteOpts, HubInProcessRoute, HubLocalUdsRoute, RemoteMoleculerRoute, AgentChildForwardRoute, CapInvoker, InProcessProviderRef, CapRouteReason, RejectedRoute, CapRouteErrorDetail, } from './cap-route.js';
-export { CapRouteError, classifyCapRoute } from './cap-route.js';
-export { CapRouteResolver, AGENT_CAP_FWD_SERVICE, AGENT_CAP_FWD_ACTION, stampCallerAddonId, } from './cap-route-resolver.js';
-export type { NodeCapAuthority, InProcessProviderLookup, CapRouteResolverDeps, AgentCapForwardParams, HubLocalChildDispatcher, } from './cap-route-resolver.js';
-export { NATIVE_PROVIDER_SERVICE_INFIX, capServiceName, capActionName, capActionSuffix, capBareAction, parseCapAction, } from './cap-action-name.js';
-export type { ParsedCapAction } from './cap-action-name.js';
-export { createUdsLogger, createUdsLoggerWithControl } from './uds-logger.js';
-export type { UdsLogSink, UdsLogLevelControl } from './uds-logger.js';
-export { udsChildLogToWorkerEntry } from './uds-log-ingest.js';
-export type { WorkerLogEntry } from './uds-log-ingest.js';
-export { createUdsEventBus } from './uds-event-bus.js';
-export type { UdsEventChannel } from './uds-event-bus.js';
-export { createUdsEventBridge } from './uds-event-bridge.js';
-export type { UdsEventBridgeDeps, ChildEventBroadcaster } from './uds-event-bridge.js';
-export { createParentUnownedCallHandler } from './parent-unowned-call.js';
-export { answerClaimedGetStatus, deviceOfGetStatus, GET_STATUS_METHOD, } from './claimed-get-status.js';
-export type { ClaimedGetStatusAnswer, ClaimedGetStatusCall } from './claimed-get-status.js';
-export type { ParentUnownedCallDeps, ParentUnownedCallLogger } from './parent-unowned-call.js';
-export { createHubCapForwardService, HUB_CAP_FWD_SERVICE, HUB_CAP_FWD_ACTION, stripForwardedCaller, } from './hub-cap-forward.js';
-export type { HubCapForwardOptions, HubCapForwardParams, HubUnownedCallHandler, } from './hub-cap-forward.js';
+export type { Frame, RequestHandler, EventHandler, LocalChannel, LocalTransportServer, LocalTransportClient, LocalTransportFactory } from "./local-transport.js";
+export { encodeFrame, FrameDecoder } from "./frame-codec.js";
+export type { SocketDirectionCounters, SocketDirectionSample, SocketMessageKind, SocketTrafficSample } from "./socket-traffic.js";
+export { createSocketDirectionCounters, EMPTY_SOCKET_DIRECTION, recordSocketFrame, sampleSocketDirection, socketDirectionBytes, socketDirectionMessages } from "./socket-traffic.js";
+export type { CapActionCensus, CapActionChannelObserver, CapActionDelta, CapActionReading, CapActionSample, CapActionWindow } from "./cap-action-census.js";
+export { CAP_ACTION_OVERFLOW_LABEL, CAP_ACTION_UNLABELLED, capActionLabel, createCapActionCensus, diffCapActionCensus, EMPTY_CAP_ACTION_READING, MAX_CAP_ACTIONS_PER_PEER } from "./cap-action-census.js";
+export { localEndpointPath } from "./local-endpoint-path.js";
+export { SocketChannel } from "./socket-channel.js";
+export { PeerAnsweredError } from "./peer-answered-error.js";
+export { UdsLocalTransportServer, UdsLocalTransportClient } from "./uds-local-transport.js";
+export { createLocalTransport } from "./create-local-transport.js";
+export type { ChildCapDescriptor, RegisterMessage, ChildLogMessage, ChildEventMessage, ChildToParentRequest, CapCallMessage, CapCallInput, CapCallOutMessage, AddonCallMessage, AddonCallInput, AddonCallTarget, AddonSettingsMethod, ParentToChildRequest, RegisteredChild, SetLogLevelMessage } from "./child-cap-protocol.js";
+export { LocalChildRegistry, afterWorkerOnlineAnnounce, UDS_NO_ROUTE_PREFIX } from "./local-child-registry.js";
+export type { LocalChildRegistryOptions, LocalChildRegistryLogger, ChildLifecycleEvents } from "./local-child-registry.js";
+export type { LocalChildClientOptions, AddonCallHandler } from "./local-child-client.js";
+export { LocalChildClient } from "./local-child-client.js";
+export type { CapRoute, CapRouteBase, CapRouteOpts, HubInProcessRoute, HubLocalUdsRoute, RemoteMoleculerRoute, AgentChildForwardRoute, CapInvoker, InProcessProviderRef, CapRouteReason, RejectedRoute, CapRouteErrorDetail } from "./cap-route.js";
+export { CapRouteError, classifyCapRoute } from "./cap-route.js";
+export { CapRouteResolver, AGENT_CAP_FWD_SERVICE, AGENT_CAP_FWD_ACTION, stampCallerAddonId } from "./cap-route-resolver.js";
+export type { NodeCapAuthority, InProcessProviderLookup, CapRouteResolverDeps, AgentCapForwardParams, HubLocalChildDispatcher } from "./cap-route-resolver.js";
+export { NATIVE_PROVIDER_SERVICE_INFIX, capServiceName, capActionName, capActionSuffix, capBareAction, parseCapAction } from "./cap-action-name.js";
+export type { ParsedCapAction } from "./cap-action-name.js";
+export { createUdsLogger, createUdsLoggerWithControl } from "./uds-logger.js";
+export type { UdsLogSink, UdsLogLevelControl } from "./uds-logger.js";
+export { udsChildLogToWorkerEntry } from "./uds-log-ingest.js";
+export type { WorkerLogEntry } from "./uds-log-ingest.js";
+export { createUdsEventBus } from "./uds-event-bus.js";
+export type { UdsEventChannel } from "./uds-event-bus.js";
+export { createUdsEventBridge } from "./uds-event-bridge.js";
+export type { UdsEventBridgeDeps, ChildEventBroadcaster } from "./uds-event-bridge.js";
+export { createParentUnownedCallHandler } from "./parent-unowned-call.js";
+export { answerClaimedGetStatus, deviceOfGetStatus, GET_STATUS_METHOD } from "./claimed-get-status.js";
+export type { ClaimedGetStatusAnswer, ClaimedGetStatusCall } from "./claimed-get-status.js";
+export type { ParentUnownedCallDeps, ParentUnownedCallLogger } from "./parent-unowned-call.js";
+export { createHubCapForwardService, HUB_CAP_FWD_SERVICE, HUB_CAP_FWD_ACTION, stripForwardedCaller } from "./hub-cap-forward.js";
+export type { HubCapForwardOptions, HubCapForwardParams, HubUnownedCallHandler } from "./hub-cap-forward.js";