@camstack/system 1.2.169 → 1.2.171

package/dist/builtins/system-config/system-config.addon.mjs

@@ -1,4 +1,4 @@
-import { Mt as errMsg, Nt as BaseAddon, Xt as hydrateSchema } from "../../dist-digPByP6.mjs";
+import { Mt as errMsg, Nt as BaseAddon, Xt as hydrateSchema } from "../../dist-1DEQFmTq.mjs";
 //#region src/builtins/system-config/system-config.addon.ts
 /**
 * Built-in `system-config` addon — Phase 4 of the settings redesign.

package/dist/builtins/winston-logging/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-D6kBG4fg.js");
+const require_dist = require("../../dist-DsoVfJSR.js");
 const require_formatter = require("../../formatter-DqAKDlvN.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);

package/dist/builtins/winston-logging/index.mjs

@@ -1,4 +1,4 @@
-import { Nt as BaseAddon, st as logDestinationCapability } from "../../dist-digPByP6.mjs";
+import { Nt as BaseAddon, st as logDestinationCapability } from "../../dist-1DEQFmTq.mjs";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 import * as path$1 from "node:path";
 import path from "node:path";

package/dist/{dist-digPByP6.mjs → dist-1DEQFmTq.mjs}

@@ -17987,6 +17987,34 @@ var KeyEventsForDeviceSchema = z.object({
 	deviceId: z.number(),
 	events: z.array(KeyEventSchema).readonly()
 });
+/** One non-empty bucket of the timeline histogram. */
+var EventDensityBucketSchema = z.object({
+	bucketStart: z.number(),
+	motion: z.number().int(),
+	object: z.number().int(),
+	audio: z.number().int()
+});
+/**
+* One camera's row in a `getEventDensityBatch` answer.
+*
+* TWO facts, and the timeline draws them differently:
+*
+*  - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
+*    claim: read, and nothing happened in the window.
+*  - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
+*    empty and that emptiness means NOTHING; the timeline must render unknown,
+*    not quiet.
+*
+* Fanned out per camera the difference was free — one query rejected while the
+* others resolved — and collapsing to a batch is the exact moment it is lost
+* silently. Every requested id gets a row: a caller that asked for twelve and
+* got eleven cannot tell which one is missing, or that any is.
+*/
+var EventDensityForDeviceSchema = z.object({
+	deviceId: z.number(),
+	read: z.enum(["read", "unreadable"]),
+	buckets: z.array(EventDensityBucketSchema).readonly()
+});
 z.object({
 	trackId: z.string(),
 	className: z.string(),
@@ -18387,12 +18415,31 @@ var pipelineAnalyticsCapability = {
 			since: z.number(),
 			until: z.number(),
 			bucketMs: z.number().int().positive()
-		}), z.array(z.object({
-			bucketStart: z.number(),
-			motion: z.number().int(),
-			object: z.number().int(),
-			audio: z.number().int()
-		})).readonly()),
+		}), z.array(EventDensityBucketSchema).readonly()),
+		/**
+		* The same histogram, for a SET of cameras, in one round trip.
+		*
+		* A multi-camera timeline (the tablet grid) re-asks this of every camera in
+		* the grid on every day change — N browser → hub → post-analysis round
+		* trips for N independent, already-indexed store queries. The queries are
+		* unchanged and still run per camera (`densityByKind`, one per deviceId,
+		* concurrently INSIDE the owner); only the transport collapses.
+		*
+		* Deliberately per-device rather than pre-merged: a timeline lane belongs
+		* to a camera, and a caller that merged would have to un-merge.
+		* `getEventDensity` stays for single-camera callers.
+		*
+		* Every requested id gets a row, marked — see
+		* {@link EventDensityForDeviceSchema}. `deviceIds` is capped at
+		* {@link EVENT_DENSITY_BATCH_MAX}, and an over-cap ask is refused rather
+		* than truncated.
+		*/
+		getEventDensityBatch: method(z.object({
+			deviceIds: z.array(z.number()).min(1).max(200),
+			since: z.number(),
+			until: z.number(),
+			bucketMs: z.number().int().positive()
+		}), z.array(EventDensityForDeviceSchema).readonly()),
 		/**
 		* @deprecated Prefer `pruneTracksBefore` — the track is the ROOT of the
 		* analytics model and retention must cascade from it (design §5.1). This
@@ -29827,6 +29874,39 @@ var RecordingDaysSchema = z.object({
 	/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
 	days: z.array(z.number())
 });
+/**
+* One camera's row in a `getAvailabilityBatch` answer.
+*
+* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
+* batch collapses the transport, not the work — plus the one thing the singular
+* method never had to say:
+*
+*  - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
+*    no footage in the window", which is a real claim.
+*  - `read: 'unreadable'` — the recorder could not answer for this camera (its
+*    calendar rung threw, its location is unmounted). `ranges` is empty and
+*    that emptiness means NOTHING.
+*
+* A timeline that renders the second as the first tells an operator there is no
+* footage when the truth is that nobody looked.
+*/
+var RecordingAvailabilityForDeviceSchema = z.object({
+	deviceId: z.number(),
+	read: z.enum(["read", "unreadable"]),
+	ranges: z.array(RecordingRangeSchema).readonly()
+});
+/**
+* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
+* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
+* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
+* the date-picker's day dots must not spell them the same.
+*/
+var RecordingDaysForDeviceSchema = z.object({
+	deviceId: z.number(),
+	read: z.enum(["read", "unreadable"]),
+	/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
+	days: z.array(z.number()).readonly()
+});
 var RecordingManifestSchema = z.object({
 	deviceId: z.number(),
 	/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
@@ -30072,6 +30152,32 @@ var recordingCapability = {
 			kind: "query",
 			auth: "protected"
 		}),
+		/**
+		* `getAvailability` for a SET of cameras, in one round trip.
+		*
+		* A multi-camera timeline re-asks availability for every camera in the grid
+		* on every day change; fanned out that is one request per camera for N
+		* independent calendar walks. The per-camera work is IDENTICAL (the same
+		* `availabilityProfileFor` + `rangesIn`, run concurrently inside the
+		* recorder) — only the transport collapses.
+		*
+		* `protected` for the same reason the singular method is: every id in
+		* `deviceIds` is a device reference, so the F1 #3 gate refuses any camera
+		* outside the caller's scope — one id out of scope refuses the CALL, it
+		* does not quietly drop a row.
+		*
+		* Every requested id gets a row, marked — see
+		* {@link RecordingAvailabilityForDeviceSchema}. `deviceIds` is capped at
+		* {@link RECORDING_TIMELINE_BATCH_MAX} and an over-cap ask is refused.
+		*/
+		getAvailabilityBatch: method(z.object({
+			deviceIds: z.array(z.number()).min(1).max(200),
+			fromMs: z.number(),
+			toMs: z.number()
+		}), z.array(RecordingAvailabilityForDeviceSchema).readonly(), {
+			kind: "query",
+			auth: "protected"
+		}),
 		/** Which calendar days in [fromMs,toMs) have ≥1 recorded segment, bucketed by
 		*  the client's local day (`tzOffsetMinutes` = minutes to add to UTC). Drives
 		*  the theater date-picker's day dots. */
@@ -30084,6 +30190,26 @@ var recordingCapability = {
 			kind: "query",
 			auth: "protected"
 		}),
+		/**
+		* `getDaysWithRecordings` for a SET of cameras, in one round trip.
+		*
+		* The cheapest question in the product, asked once per camera per month
+		* change. One directory read per day per camera at the owner, unchanged;
+		* what collapses is the N requests it took to ask.
+		*
+		* Every requested id gets a row, marked — see
+		* {@link RecordingDaysForDeviceSchema}. `deviceIds` is capped at
+		* {@link RECORDING_TIMELINE_BATCH_MAX} and an over-cap ask is refused.
+		*/
+		getDaysWithRecordingsBatch: method(z.object({
+			deviceIds: z.array(z.number()).min(1).max(200),
+			fromMs: z.number(),
+			toMs: z.number(),
+			tzOffsetMinutes: z.number()
+		}), z.array(RecordingDaysForDeviceSchema).readonly(), {
+			kind: "query",
+			auth: "protected"
+		}),
 		getPlaybackManifest: method(z.object({
 			deviceId: z.number(),
 			fromMs: z.number(),
@@ -37287,6 +37413,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getEventDensityBatch": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getEventMedia": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -38409,12 +38541,24 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.getAvailabilityBatch": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"recording.getDaysWithRecordings": {
 		capName: "recording",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
+	"recording.getDaysWithRecordingsBatch": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"recording.getDeviceConfig": {
 		capName: "recording",
 		capScope: "system",
@@ -41019,6 +41163,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.getEventDensityBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"pipelineAnalytics.getEventMedia": [{
 		name: "deviceId",
 		form: "single",
@@ -41434,11 +41583,21 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"recording.getAvailabilityBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"recording.getDaysWithRecordings": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
+	"recording.getDaysWithRecordingsBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"recording.getDeviceConfig": [{
 		name: "deviceId",
 		form: "single",

package/dist/{dist-D6kBG4fg.js → dist-DsoVfJSR.js}

@@ -17987,6 +17987,34 @@ var KeyEventsForDeviceSchema = zod.z.object({
 	deviceId: zod.z.number(),
 	events: zod.z.array(KeyEventSchema).readonly()
 });
+/** One non-empty bucket of the timeline histogram. */
+var EventDensityBucketSchema = zod.z.object({
+	bucketStart: zod.z.number(),
+	motion: zod.z.number().int(),
+	object: zod.z.number().int(),
+	audio: zod.z.number().int()
+});
+/**
+* One camera's row in a `getEventDensityBatch` answer.
+*
+* TWO facts, and the timeline draws them differently:
+*
+*  - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
+*    claim: read, and nothing happened in the window.
+*  - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
+*    empty and that emptiness means NOTHING; the timeline must render unknown,
+*    not quiet.
+*
+* Fanned out per camera the difference was free — one query rejected while the
+* others resolved — and collapsing to a batch is the exact moment it is lost
+* silently. Every requested id gets a row: a caller that asked for twelve and
+* got eleven cannot tell which one is missing, or that any is.
+*/
+var EventDensityForDeviceSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	read: zod.z.enum(["read", "unreadable"]),
+	buckets: zod.z.array(EventDensityBucketSchema).readonly()
+});
 zod.z.object({
 	trackId: zod.z.string(),
 	className: zod.z.string(),
@@ -18387,12 +18415,31 @@ var pipelineAnalyticsCapability = {
 			since: zod.z.number(),
 			until: zod.z.number(),
 			bucketMs: zod.z.number().int().positive()
-		}), zod.z.array(zod.z.object({
-			bucketStart: zod.z.number(),
-			motion: zod.z.number().int(),
-			object: zod.z.number().int(),
-			audio: zod.z.number().int()
-		})).readonly()),
+		}), zod.z.array(EventDensityBucketSchema).readonly()),
+		/**
+		* The same histogram, for a SET of cameras, in one round trip.
+		*
+		* A multi-camera timeline (the tablet grid) re-asks this of every camera in
+		* the grid on every day change — N browser → hub → post-analysis round
+		* trips for N independent, already-indexed store queries. The queries are
+		* unchanged and still run per camera (`densityByKind`, one per deviceId,
+		* concurrently INSIDE the owner); only the transport collapses.
+		*
+		* Deliberately per-device rather than pre-merged: a timeline lane belongs
+		* to a camera, and a caller that merged would have to un-merge.
+		* `getEventDensity` stays for single-camera callers.
+		*
+		* Every requested id gets a row, marked — see
+		* {@link EventDensityForDeviceSchema}. `deviceIds` is capped at
+		* {@link EVENT_DENSITY_BATCH_MAX}, and an over-cap ask is refused rather
+		* than truncated.
+		*/
+		getEventDensityBatch: method(zod.z.object({
+			deviceIds: zod.z.array(zod.z.number()).min(1).max(200),
+			since: zod.z.number(),
+			until: zod.z.number(),
+			bucketMs: zod.z.number().int().positive()
+		}), zod.z.array(EventDensityForDeviceSchema).readonly()),
 		/**
 		* @deprecated Prefer `pruneTracksBefore` — the track is the ROOT of the
 		* analytics model and retention must cascade from it (design §5.1). This
@@ -29827,6 +29874,39 @@ var RecordingDaysSchema = zod.z.object({
 	/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
 	days: zod.z.array(zod.z.number())
 });
+/**
+* One camera's row in a `getAvailabilityBatch` answer.
+*
+* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
+* batch collapses the transport, not the work — plus the one thing the singular
+* method never had to say:
+*
+*  - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
+*    no footage in the window", which is a real claim.
+*  - `read: 'unreadable'` — the recorder could not answer for this camera (its
+*    calendar rung threw, its location is unmounted). `ranges` is empty and
+*    that emptiness means NOTHING.
+*
+* A timeline that renders the second as the first tells an operator there is no
+* footage when the truth is that nobody looked.
+*/
+var RecordingAvailabilityForDeviceSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	read: zod.z.enum(["read", "unreadable"]),
+	ranges: zod.z.array(RecordingRangeSchema).readonly()
+});
+/**
+* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
+* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
+* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
+* the date-picker's day dots must not spell them the same.
+*/
+var RecordingDaysForDeviceSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	read: zod.z.enum(["read", "unreadable"]),
+	/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
+	days: zod.z.array(zod.z.number()).readonly()
+});
 var RecordingManifestSchema = zod.z.object({
 	deviceId: zod.z.number(),
 	/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
@@ -30072,6 +30152,32 @@ var recordingCapability = {
 			kind: "query",
 			auth: "protected"
 		}),
+		/**
+		* `getAvailability` for a SET of cameras, in one round trip.
+		*
+		* A multi-camera timeline re-asks availability for every camera in the grid
+		* on every day change; fanned out that is one request per camera for N
+		* independent calendar walks. The per-camera work is IDENTICAL (the same
+		* `availabilityProfileFor` + `rangesIn`, run concurrently inside the
+		* recorder) — only the transport collapses.
+		*
+		* `protected` for the same reason the singular method is: every id in
+		* `deviceIds` is a device reference, so the F1 #3 gate refuses any camera
+		* outside the caller's scope — one id out of scope refuses the CALL, it
+		* does not quietly drop a row.
+		*
+		* Every requested id gets a row, marked — see
+		* {@link RecordingAvailabilityForDeviceSchema}. `deviceIds` is capped at
+		* {@link RECORDING_TIMELINE_BATCH_MAX} and an over-cap ask is refused.
+		*/
+		getAvailabilityBatch: method(zod.z.object({
+			deviceIds: zod.z.array(zod.z.number()).min(1).max(200),
+			fromMs: zod.z.number(),
+			toMs: zod.z.number()
+		}), zod.z.array(RecordingAvailabilityForDeviceSchema).readonly(), {
+			kind: "query",
+			auth: "protected"
+		}),
 		/** Which calendar days in [fromMs,toMs) have ≥1 recorded segment, bucketed by
 		*  the client's local day (`tzOffsetMinutes` = minutes to add to UTC). Drives
 		*  the theater date-picker's day dots. */
@@ -30084,6 +30190,26 @@ var recordingCapability = {
 			kind: "query",
 			auth: "protected"
 		}),
+		/**
+		* `getDaysWithRecordings` for a SET of cameras, in one round trip.
+		*
+		* The cheapest question in the product, asked once per camera per month
+		* change. One directory read per day per camera at the owner, unchanged;
+		* what collapses is the N requests it took to ask.
+		*
+		* Every requested id gets a row, marked — see
+		* {@link RecordingDaysForDeviceSchema}. `deviceIds` is capped at
+		* {@link RECORDING_TIMELINE_BATCH_MAX} and an over-cap ask is refused.
+		*/
+		getDaysWithRecordingsBatch: method(zod.z.object({
+			deviceIds: zod.z.array(zod.z.number()).min(1).max(200),
+			fromMs: zod.z.number(),
+			toMs: zod.z.number(),
+			tzOffsetMinutes: zod.z.number()
+		}), zod.z.array(RecordingDaysForDeviceSchema).readonly(), {
+			kind: "query",
+			auth: "protected"
+		}),
 		getPlaybackManifest: method(zod.z.object({
 			deviceId: zod.z.number(),
 			fromMs: zod.z.number(),
@@ -37287,6 +37413,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getEventDensityBatch": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getEventMedia": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -38409,12 +38541,24 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.getAvailabilityBatch": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"recording.getDaysWithRecordings": {
 		capName: "recording",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
+	"recording.getDaysWithRecordingsBatch": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"recording.getDeviceConfig": {
 		capName: "recording",
 		capScope: "system",
@@ -41019,6 +41163,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.getEventDensityBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"pipelineAnalytics.getEventMedia": [{
 		name: "deviceId",
 		form: "single",
@@ -41434,11 +41583,21 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"recording.getAvailabilityBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"recording.getDaysWithRecordings": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
+	"recording.getDaysWithRecordingsBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"recording.getDeviceConfig": [{
 		name: "deviceId",
 		form: "single",

package/dist/hub-cap-forward-BdT320dq.mjs

@@ -0,0 +1,53 @@
+//#region src/kernel/transport/hub-cap-forward.ts
+/** The Moleculer service name the hub registers for agent→hub cap forwarding. */
+var HUB_CAP_FWD_SERVICE = "$hub-cap-fwd";
+/** The Moleculer action (service.action) for hub cap forwarding. */
+var HUB_CAP_FWD_ACTION = `${HUB_CAP_FWD_SERVICE}.forward`;
+/**
+* Narrow Moleculer's loosely-typed `ctx.params` to {@link HubCapForwardParams}
+* without unsafe casts — mirrors `agent-cap-dispatch-service.ts:narrowParams`.
+*/
+function narrowParams(raw) {
+	if (raw === null || typeof raw !== "object") throw new Error("$hub-cap-fwd.forward: invalid params — capName and method are required strings");
+	const capName = Reflect.get(raw, "capName");
+	const method = Reflect.get(raw, "method");
+	if (typeof capName !== "string" || typeof method !== "string") throw new Error("$hub-cap-fwd.forward: invalid params — capName and method are required strings");
+	const deviceId = Reflect.get(raw, "deviceId");
+	const nodeId = Reflect.get(raw, "nodeId");
+	const native = Reflect.get(raw, "native");
+	return {
+		capName,
+		method,
+		args: Reflect.get(raw, "args"),
+		deviceId: typeof deviceId === "number" ? deviceId : void 0,
+		nodeId: typeof nodeId === "string" && nodeId.length > 0 ? nodeId : void 0,
+		native: native === true ? true : void 0
+	};
+}
+/**
+* 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.
+*/
+function createHubCapForwardService(onUnownedCall) {
+	return {
+		name: HUB_CAP_FWD_SERVICE,
+		actions: { forward: { handler: async (ctx) => {
+			const { capName, method, args, deviceId, nodeId, native } = narrowParams(ctx.params);
+			return onUnownedCall({
+				capName,
+				method,
+				args,
+				...deviceId !== void 0 ? { deviceId } : {},
+				...nodeId !== void 0 ? { nodeId } : {},
+				...native === true ? { native: true } : {}
+			});
+		} } }
+	};
+}
+//#endregion
+export { HUB_CAP_FWD_SERVICE as n, createHubCapForwardService as r, HUB_CAP_FWD_ACTION as t };

package/dist/hub-cap-forward-DmHNjbB0.js

@@ -0,0 +1,70 @@
+//#region src/kernel/transport/hub-cap-forward.ts
+/** The Moleculer service name the hub registers for agent→hub cap forwarding. */
+var HUB_CAP_FWD_SERVICE = "$hub-cap-fwd";
+/** The Moleculer action (service.action) for hub cap forwarding. */
+var HUB_CAP_FWD_ACTION = `${HUB_CAP_FWD_SERVICE}.forward`;
+/**
+* Narrow Moleculer's loosely-typed `ctx.params` to {@link HubCapForwardParams}
+* without unsafe casts — mirrors `agent-cap-dispatch-service.ts:narrowParams`.
+*/
+function narrowParams(raw) {
+	if (raw === null || typeof raw !== "object") throw new Error("$hub-cap-fwd.forward: invalid params — capName and method are required strings");
+	const capName = Reflect.get(raw, "capName");
+	const method = Reflect.get(raw, "method");
+	if (typeof capName !== "string" || typeof method !== "string") throw new Error("$hub-cap-fwd.forward: invalid params — capName and method are required strings");
+	const deviceId = Reflect.get(raw, "deviceId");
+	const nodeId = Reflect.get(raw, "nodeId");
+	const native = Reflect.get(raw, "native");
+	return {
+		capName,
+		method,
+		args: Reflect.get(raw, "args"),
+		deviceId: typeof deviceId === "number" ? deviceId : void 0,
+		nodeId: typeof nodeId === "string" && nodeId.length > 0 ? nodeId : void 0,
+		native: native === true ? true : void 0
+	};
+}
+/**
+* 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.
+*/
+function createHubCapForwardService(onUnownedCall) {
+	return {
+		name: HUB_CAP_FWD_SERVICE,
+		actions: { forward: { handler: async (ctx) => {
+			const { capName, method, args, deviceId, nodeId, native } = narrowParams(ctx.params);
+			return onUnownedCall({
+				capName,
+				method,
+				args,
+				...deviceId !== void 0 ? { deviceId } : {},
+				...nodeId !== void 0 ? { nodeId } : {},
+				...native === true ? { native: true } : {}
+			});
+		} } }
+	};
+}
+//#endregion
+Object.defineProperty(exports, "HUB_CAP_FWD_ACTION", {
+	enumerable: true,
+	get: function() {
+		return HUB_CAP_FWD_ACTION;
+	}
+});
+Object.defineProperty(exports, "HUB_CAP_FWD_SERVICE", {
+	enumerable: true,
+	get: function() {
+		return HUB_CAP_FWD_SERVICE;
+	}
+});
+Object.defineProperty(exports, "createHubCapForwardService", {
+	enumerable: true,
+	get: function() {
+		return createHubCapForwardService;
+	}
+});