@camstack/system 1.0.2

package/dist/builtins/addon-pages-aggregator/addon-pages-aggregator.addon.mjs

@@ -0,0 +1,251 @@
+import { t as settleSourcesWithTimeout } from "../../settle-sources-CDtNC8ub.mjs";
+import * as fs from "node:fs";
+import * as path$1 from "node:path";
+import { BaseAddon, EventCategory, addonPagesCapability, errMsg } from "@camstack/types";
+import { randomUUID } from "node:crypto";
+//#region src/builtins/addon-pages-aggregator/dedupe-pages.ts
+/** Stable identity for an addon page, independent of which node reported it. */
+function pageKey(info) {
+	return `${info.addonId}::${info.page.id}`;
+}
+/**
+* Return a new list with duplicate `(addonId, page.id)` entries removed,
+* preserving first-seen order. Pure — never mutates the input.
+*/
+function dedupePages(pages) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const info of pages) {
+		const key = pageKey(info);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(info);
+	}
+	return out;
+}
+//#endregion
+//#region src/builtins/addon-pages-aggregator/addon-pages-aggregator.addon.ts
+/**
+* Addon Pages Aggregator — hub-local builtin that owns the singleton
+* `addon-pages` cap.
+*
+* Walks every registered `addon-pages-source` (collection) provider and
+* emits an enriched `AddonPageInfo[]` list with versioned `bundleUrl`s
+* pointing at `/api/addon-pages/<addonId>/<bundle>?v=<mtime>`. The
+* filesystem `mtime` cache-buster lets the browser pick up addon
+* rebuilds without manual reload — same scheme the original
+* hand-written `AddonPagesService.listPages` used before this split.
+*
+* The static file endpoint (`/api/addon-pages/:addonId/*`) is still
+* served by `AddonPagesService.resolveBundle()` on the server side; this
+* addon only owns the listing surface.
+*
+* Why a builtin rather than a cap-providers helper:
+*   - The aggregator is conceptually the "addon-pages provider" — addons
+*     own caps, not the server. Living in `@camstack/system/builtins` keeps
+*     the surface symmetrical with `system-config`, `local-auth`, etc.
+*   - Lets the aggregator subscribe to source readiness without piping a
+*     CapabilityRegistry handle through `RouterServices`.
+*/
+/**
+* Backoff schedule (ms) used to retry sources that failed during a
+* `listPages()` round-trip — typically because the cap was just
+* registered (provider connected via Moleculer) but the worker-side
+* action registration hadn't propagated yet, so `Service '...listPages'
+* is not found on '<node>'` raced ahead of the call.
+*
+* We schedule one retry per entry; if every retry fails we stop
+* (the next aggregate() run will pick the source up again). On
+* success we re-emit `AddonPageReady` so admin-ui invalidates its
+* `addonPages.listPages` query and the sidebar populates without a
+* page reload.
+*/
+var RETRY_BACKOFF_MS = [
+	500,
+	1500,
+	4e3
+];
+/**
+* Per-source ceiling for a single `listPages()` round-trip. A healthy
+* source answers in well under this (hub-local UDS <100ms, a reachable
+* remote agent <1s). A source that's unreachable — e.g. an agent-hosted
+* addon whose cap routes through a Moleculer `waitForServices` that waits
+* its full 30s discovery timeout for a node that will never appear — must
+* NOT block the whole listing: we time it out fast, serve its cached
+* snapshot, and let the background retry recover it. Combined with the
+* parallel fan-out below, one slow/dead source can no longer stall the
+* sidebar query (which otherwise hangs long enough to trip the WS
+* keepalive → "server unreachable").
+*/
+var PER_SOURCE_TIMEOUT_MS = 2500;
+var AddonPagesAggregatorAddon = class extends BaseAddon {
+	id = "addon-pages-aggregator";
+	resolvedPaths = null;
+	/**
+	* Last successful `listPages()` snapshot per source. Used as the
+	* "stale-but-valid" fallback when a source transiently fails — drops
+	* happen often enough during boot (Moleculer service-discovery
+	* window) that swallowing the error and returning empty leaves the
+	* sidebar with nothing for several seconds. Keeping the previous
+	* good entry means a flake is invisible to the operator.
+	*/
+	lastGood = /* @__PURE__ */ new Map();
+	/** In-flight retry guards keyed by sourceId. Avoids double-scheduling. */
+	retryTimers = /* @__PURE__ */ new Map();
+	constructor() {
+		super({});
+	}
+	async onInitialize() {
+		this.resolvedPaths = await this.resolvePaths();
+		const provider = { listPages: async () => this.aggregate() };
+		this.ctx.logger.info("Initialized — aggregating addon-pages-source providers");
+		return [{
+			capability: addonPagesCapability,
+			provider
+		}];
+	}
+	async onShutdown() {
+		for (const t of this.retryTimers.values()) clearTimeout(t);
+		this.retryTimers.clear();
+		this.lastGood.clear();
+	}
+	async aggregate() {
+		const sources = this.capabilities?.getCollection("addon-pages-source") ?? [];
+		const out = [];
+		const seenIds = /* @__PURE__ */ new Set();
+		const settled = await settleSourcesWithTimeout(sources.map((source) => [source.id, () => Promise.resolve(source.listPages())]), PER_SOURCE_TIMEOUT_MS);
+		for (const [sourceId, result] of settled) {
+			seenIds.add(sourceId);
+			if (result.ok) {
+				const enriched = result.value.map((page) => ({
+					addonId: sourceId,
+					page,
+					bundleUrl: this.makeBundleUrl(sourceId, page.bundle)
+				}));
+				for (const item of enriched) out.push(item);
+				this.lastGood.set(sourceId, enriched);
+			} else {
+				this.ctx.logger.warn("addon-pages-source provider failed", { meta: {
+					sourceId,
+					error: result.error.message
+				} });
+				const cached = this.lastGood.get(sourceId);
+				if (cached !== void 0) {
+					for (const item of cached) out.push(item);
+					this.ctx.logger.info("addon-pages-source falling back to cached snapshot", { meta: {
+						sourceId,
+						cachedPages: cached.length
+					} });
+				}
+				this.scheduleRetry(sourceId);
+			}
+		}
+		for (const cachedId of this.lastGood.keys()) if (!seenIds.has(cachedId)) this.lastGood.delete(cachedId);
+		return dedupePages(out);
+	}
+	/**
+	* Schedule background re-call of `listPages()` on a source that just
+	* failed. Walks `RETRY_BACKOFF_MS` from index 0 — each successful
+	* call updates the cache and emits `AddonPageReady` so the admin UI
+	* invalidates its query. Stops on first success or after the schedule
+	* is exhausted.
+	*/
+	scheduleRetry(sourceId, attempt = 0) {
+		if (attempt >= RETRY_BACKOFF_MS.length) return;
+		if (this.retryTimers.has(sourceId)) return;
+		const delayMs = RETRY_BACKOFF_MS[attempt] ?? RETRY_BACKOFF_MS[RETRY_BACKOFF_MS.length - 1];
+		const timer = setTimeout(() => {
+			this.retryTimers.delete(sourceId);
+			this.retrySource(sourceId, attempt);
+		}, delayMs);
+		this.retryTimers.set(sourceId, timer);
+	}
+	async retrySource(sourceId, attempt) {
+		const source = (this.capabilities?.getCollection("addon-pages-source") ?? []).find((s) => s.id === sourceId);
+		if (!source) return;
+		try {
+			const enriched = (await Promise.resolve(source.listPages())).map((page) => ({
+				addonId: source.id,
+				page,
+				bundleUrl: this.makeBundleUrl(source.id, page.bundle)
+			}));
+			this.lastGood.set(source.id, enriched);
+			this.ctx.logger.info("addon-pages-source recovered after retry", { meta: {
+				sourceId,
+				attempt: attempt + 1,
+				pages: enriched.length
+			} });
+			this.ctx.eventBus.emit({
+				id: randomUUID(),
+				timestamp: /* @__PURE__ */ new Date(),
+				source: {
+					type: "addon",
+					id: this.id
+				},
+				category: EventCategory.AddonPageReady,
+				data: {
+					addonId: sourceId,
+					recovered: true
+				}
+			});
+		} catch (err) {
+			this.ctx.logger.debug("addon-pages-source retry failed", { meta: {
+				sourceId,
+				attempt: attempt + 1,
+				error: errMsg(err)
+			} });
+			this.scheduleRetry(sourceId, attempt + 1);
+		}
+	}
+	/**
+	* Build `/api/addon-pages/<addonId>/<bundle>?v=<mtime>`. Falls back
+	* to `Date.now()` when the bundle path can't be stat'd (remote addon
+	* with no local file, addon not yet on disk, etc.) — the browser
+	* just gets a fresh URL on each call instead of cache-friendly mtime.
+	*/
+	makeBundleUrl(addonId, bundle) {
+		const bundlePath = this.resolveBundlePath(addonId, bundle);
+		let mtime = Date.now();
+		if (bundlePath !== null) try {
+			mtime = fs.statSync(bundlePath).mtimeMs;
+		} catch {}
+		return `/api/addon-pages/${addonId}/${bundle}?v=${Math.floor(mtime)}`;
+	}
+	/**
+	* Resolve the local filesystem path for an addon's bundle. Mirrors
+	* `AddonPagesService.resolveBundle` (server-side), but without the
+	* existence / traversal checks — those still live on the server's
+	* static file route. We only need a stat-able path here for the
+	* `mtime` cache-buster.
+	*/
+	resolveBundlePath(addonId, bundle) {
+		const paths = this.resolvedPaths;
+		if (!paths) return null;
+		const addonDistPath = path$1.join(paths.addonsDir, "@camstack", `addon-${addonId}`, "dist");
+		const resolvedBase = path$1.resolve(addonDistPath);
+		const resolvedFile = path$1.resolve(addonDistPath, bundle);
+		if (!resolvedFile.startsWith(resolvedBase + path$1.sep) && resolvedFile !== resolvedBase) return null;
+		return resolvedFile;
+	}
+	/**
+	* Read `server.dataPath` from the cluster yml-backed sections (same
+	* source the server uses at boot), then derive the addons directory
+	* from it. Falls back to `camstack-data/addons` when no settings API
+	* is available — agents and isolated tests don't see this addon, so
+	* the fallback is purely defensive.
+	*/
+	async resolvePaths() {
+		const fallback = { addonsDir: path$1.resolve("camstack-data", "addons") };
+		if (!this.ctx.settings) return fallback;
+		try {
+			const server = await this.ctx.settings.getSection("server");
+			const dataPath = typeof server["dataPath"] === "string" && server["dataPath"] ? server["dataPath"] : "camstack-data";
+			return { addonsDir: path$1.resolve(dataPath, "addons") };
+		} catch (err) {
+			this.ctx.logger.debug("Failed to read server.dataPath — falling back", { meta: { error: errMsg(err) } });
+			return fallback;
+		}
+	}
+};
+//#endregion
+export { AddonPagesAggregatorAddon, AddonPagesAggregatorAddon as default };

package/dist/builtins/addon-pages-aggregator/dedupe-pages.d.ts

@@ -0,0 +1,6 @@
+import { AddonPageInfo } from '@camstack/types';
+/**
+ * Return a new list with duplicate `(addonId, page.id)` entries removed,
+ * preserving first-seen order. Pure — never mutates the input.
+ */
+export declare function dedupePages(pages: readonly AddonPageInfo[]): readonly AddonPageInfo[];

package/dist/builtins/addon-pages-aggregator/index.d.ts

@@ -0,0 +1 @@
+export { AddonPagesAggregatorAddon, default } from './addon-pages-aggregator.addon.js';

package/dist/builtins/addon-pages-aggregator/index.js

@@ -0,0 +1,8 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+require("../../chunk-Cek0wNdY.js");
+const require_builtins_addon_pages_aggregator_addon_pages_aggregator_addon = require("./addon-pages-aggregator.addon.js");
+exports.AddonPagesAggregatorAddon = require_builtins_addon_pages_aggregator_addon_pages_aggregator_addon.AddonPagesAggregatorAddon;
+exports.default = require_builtins_addon_pages_aggregator_addon_pages_aggregator_addon.AddonPagesAggregatorAddon;

package/dist/builtins/addon-pages-aggregator/index.mjs

@@ -0,0 +1,2 @@
+import { AddonPagesAggregatorAddon } from "./addon-pages-aggregator.addon.mjs";
+export { AddonPagesAggregatorAddon, AddonPagesAggregatorAddon as default };

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.addon.d.ts

@@ -0,0 +1,47 @@
+import { BaseAddon, ProviderRegistration } from '@camstack/types';
+export declare class AddonWidgetsAggregatorAddon extends BaseAddon {
+    readonly id = "addon-widgets-aggregator";
+    private resolvedPaths;
+    /**
+     * Last successful `listWidgets()` snapshot per source. Used as the
+     * "stale-but-valid" fallback when a source transiently fails — drops
+     * happen often enough during boot (Moleculer service-discovery
+     * window) that swallowing the error and returning empty would leave
+     * the dashboard with nothing for several seconds. Keeping the
+     * previous good entry means a flake is invisible to the operator.
+     */
+    private readonly lastGood;
+    /** In-flight retry guards keyed by sourceAddonId. Avoids double-scheduling. */
+    private readonly retryTimers;
+    constructor();
+    protected onInitialize(): Promise<ProviderRegistration[]>;
+    protected onShutdown(): Promise<void>;
+    /**
+     * Strip the `@<nodeId>` suffix that the CapabilityBridge appends to
+     * collection-provider registry keys for cross-node addons (see
+     * `moleculer.service.ts` — `registryKey = ${addonId}@${nodeId}`).
+     *
+     * The widget bundle is hub-resident (the same npm package ships to
+     * every node and the hub keeps a copy on disk keyed by the bare
+     * manifest id), so both the static-file URL and the admin-ui widget
+     * namespace must use the bare addon id. Without this, a widget
+     * source running on a remote agent yields a `bundleUrl` like
+     * `/api/addon-widgets/pipeline-analytics@agent-0/pipeline-analytics/remoteEntry.js`
+     * — the embedded `@<node>/<group>` makes the static-file route's
+     * `:addonId` param mismatch the registered provider and 404.
+     */
+    private bareAddonId;
+    private aggregate;
+    private scheduleRetry;
+    private retrySource;
+    /**
+     * Build `/api/addon-widgets/<addonId>/<bundle>?v=<mtime>`. Falls back
+     * to `Date.now()` when the bundle path can't be stat'd (remote addon
+     * with no local file, addon not yet on disk, etc.) — the browser
+     * just gets a fresh URL on each call instead of cache-friendly mtime.
+     */
+    private makeBundleUrl;
+    private resolveBundlePath;
+    private resolvePaths;
+}
+export default AddonWidgetsAggregatorAddon;

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.addon.js

@@ -0,0 +1,228 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_chunk = require("../../chunk-Cek0wNdY.js");
+const require_settle_sources = require("../../settle-sources-Bhsy57y-.js");
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let _camstack_types = require("@camstack/types");
+let node_crypto = require("node:crypto");
+//#region src/builtins/addon-widgets-aggregator/addon-widgets-aggregator.addon.ts
+/**
+* Addon Widgets Aggregator — hub-local builtin that owns the singleton
+* `addon-widgets` cap.
+*
+* Mirrors `addon-pages-aggregator` exactly: walks every registered
+* `addon-widgets-source` (collection) provider and emits an enriched
+* widget metadata list with versioned `bundleUrl`s pointing at
+* `/api/addon-widgets/<addonId>/<bundle>?v=<mtime>`. The filesystem
+* `mtime` cache-buster lets the browser pick up addon rebuilds without
+* manual reload.
+*
+* The static file endpoint (`/api/addon-widgets/:addonId/*`) is served
+* by `AddonWidgetsService.resolveBundle()` on the server side; this
+* addon only owns the listing surface.
+*
+* Why a builtin: same reasoning as `addon-pages-aggregator`. The
+* aggregator is the de-facto "addon-widgets provider" — addons own caps,
+* not the server. Living in `@camstack/system/builtins` keeps the surface
+* symmetrical with `system-config`, `local-auth`, etc.
+*/
+/**
+* Backoff schedule (ms) used to retry sources that failed during a
+* `listWidgets()` round-trip — typically because the cap was just
+* registered (provider connected via Moleculer) but the worker-side
+* action registration hadn't propagated yet, so `Service '...listWidgets'
+* is not found on '<node>'` raced ahead of the call.
+*
+* On success we re-emit `AddonWidgetReady` so admin-ui invalidates its
+* `addonWidgets.listWidgets` query and the registry populates without a
+* page reload.
+*/
+var RETRY_BACKOFF_MS = [
+	500,
+	1500,
+	4e3
+];
+/**
+* Per-source ceiling for a single `listWidgets()` round-trip. Mirrors the
+* addon-pages aggregator: a slow/unreachable source (e.g. an agent-hosted
+* widget source whose cap call sits in a Moleculer `waitForServices`) times
+* out fast and serves its cached snapshot instead of blocking the dashboard.
+*/
+var PER_SOURCE_TIMEOUT_MS = 2500;
+var AddonWidgetsAggregatorAddon = class extends _camstack_types.BaseAddon {
+	id = "addon-widgets-aggregator";
+	resolvedPaths = null;
+	/**
+	* Last successful `listWidgets()` snapshot per source. Used as the
+	* "stale-but-valid" fallback when a source transiently fails — drops
+	* happen often enough during boot (Moleculer service-discovery
+	* window) that swallowing the error and returning empty would leave
+	* the dashboard with nothing for several seconds. Keeping the
+	* previous good entry means a flake is invisible to the operator.
+	*/
+	lastGood = /* @__PURE__ */ new Map();
+	/** In-flight retry guards keyed by sourceAddonId. Avoids double-scheduling. */
+	retryTimers = /* @__PURE__ */ new Map();
+	constructor() {
+		super({});
+	}
+	async onInitialize() {
+		this.resolvedPaths = await this.resolvePaths();
+		const provider = { listWidgets: async () => this.aggregate() };
+		this.ctx.logger.info("Initialized — aggregating addon-widgets-source providers");
+		return [{
+			capability: _camstack_types.addonWidgetsCapability,
+			provider
+		}];
+	}
+	async onShutdown() {
+		for (const t of this.retryTimers.values()) clearTimeout(t);
+		this.retryTimers.clear();
+		this.lastGood.clear();
+	}
+	/**
+	* Strip the `@<nodeId>` suffix that the CapabilityBridge appends to
+	* collection-provider registry keys for cross-node addons (see
+	* `moleculer.service.ts` — `registryKey = ${addonId}@${nodeId}`).
+	*
+	* The widget bundle is hub-resident (the same npm package ships to
+	* every node and the hub keeps a copy on disk keyed by the bare
+	* manifest id), so both the static-file URL and the admin-ui widget
+	* namespace must use the bare addon id. Without this, a widget
+	* source running on a remote agent yields a `bundleUrl` like
+	* `/api/addon-widgets/pipeline-analytics@agent-0/pipeline-analytics/remoteEntry.js`
+	* — the embedded `@<node>/<group>` makes the static-file route's
+	* `:addonId` param mismatch the registered provider and 404.
+	*/
+	bareAddonId(registryKey) {
+		const at = registryKey.indexOf("@");
+		return at === -1 ? registryKey : registryKey.slice(0, at);
+	}
+	async aggregate() {
+		const entries = this.capabilities?.getCollectionEntries("addon-widgets-source") ?? [];
+		const out = [];
+		const seenIds = /* @__PURE__ */ new Set();
+		const settled = await require_settle_sources.settleSourcesWithTimeout(entries.map(([registryKey, source]) => [registryKey, () => Promise.resolve(source.listWidgets())]), PER_SOURCE_TIMEOUT_MS);
+		for (const [addonId, result] of settled) {
+			const publicAddonId = this.bareAddonId(addonId);
+			seenIds.add(addonId);
+			if (result.ok) {
+				const enriched = result.value.map((w) => ({
+					...w,
+					addonId: publicAddonId,
+					bundleUrl: this.makeBundleUrl(publicAddonId, w.bundle)
+				}));
+				for (const item of enriched) out.push(item);
+				this.lastGood.set(addonId, enriched);
+			} else {
+				this.ctx.logger.warn("addon-widgets-source provider failed", { meta: {
+					sourceId: addonId,
+					error: result.error.message
+				} });
+				const cached = this.lastGood.get(addonId);
+				if (cached !== void 0) {
+					for (const item of cached) out.push(item);
+					this.ctx.logger.info("addon-widgets-source falling back to cached snapshot", { meta: {
+						sourceId: addonId,
+						cachedWidgets: cached.length
+					} });
+				}
+				this.scheduleRetry(addonId);
+			}
+		}
+		for (const cachedId of this.lastGood.keys()) if (!seenIds.has(cachedId)) this.lastGood.delete(cachedId);
+		return out;
+	}
+	scheduleRetry(sourceId, attempt = 0) {
+		if (attempt >= RETRY_BACKOFF_MS.length) return;
+		if (this.retryTimers.has(sourceId)) return;
+		const delayMs = RETRY_BACKOFF_MS[attempt] ?? RETRY_BACKOFF_MS[RETRY_BACKOFF_MS.length - 1];
+		const timer = setTimeout(() => {
+			this.retryTimers.delete(sourceId);
+			this.retrySource(sourceId, attempt);
+		}, delayMs);
+		this.retryTimers.set(sourceId, timer);
+	}
+	async retrySource(sourceId, attempt) {
+		const found = (this.capabilities?.getCollectionEntries("addon-widgets-source") ?? []).find(([id]) => id === sourceId);
+		if (!found) return;
+		const [addonId, source] = found;
+		const publicAddonId = this.bareAddonId(addonId);
+		try {
+			const enriched = (await Promise.resolve(source.listWidgets())).map((w) => ({
+				...w,
+				addonId: publicAddonId,
+				bundleUrl: this.makeBundleUrl(publicAddonId, w.bundle)
+			}));
+			this.lastGood.set(addonId, enriched);
+			this.ctx.logger.info("addon-widgets-source recovered after retry", { meta: {
+				sourceId: addonId,
+				attempt: attempt + 1,
+				widgets: enriched.length
+			} });
+			this.ctx.eventBus.emit({
+				id: (0, node_crypto.randomUUID)(),
+				timestamp: /* @__PURE__ */ new Date(),
+				source: {
+					type: "addon",
+					id: this.id
+				},
+				category: _camstack_types.EventCategory.AddonWidgetReady,
+				data: {
+					addonId: publicAddonId,
+					recovered: true
+				}
+			});
+		} catch (err) {
+			this.ctx.logger.debug("addon-widgets-source retry failed", { meta: {
+				sourceId,
+				attempt: attempt + 1,
+				error: (0, _camstack_types.errMsg)(err)
+			} });
+			this.scheduleRetry(sourceId, attempt + 1);
+		}
+	}
+	/**
+	* Build `/api/addon-widgets/<addonId>/<bundle>?v=<mtime>`. Falls back
+	* to `Date.now()` when the bundle path can't be stat'd (remote addon
+	* with no local file, addon not yet on disk, etc.) — the browser
+	* just gets a fresh URL on each call instead of cache-friendly mtime.
+	*/
+	makeBundleUrl(addonId, bundle) {
+		const bundlePath = this.resolveBundlePath(addonId, bundle);
+		let mtime = Date.now();
+		if (bundlePath !== null) try {
+			mtime = node_fs.statSync(bundlePath).mtimeMs;
+		} catch {}
+		return `/api/addon-widgets/${addonId}/${bundle}?v=${Math.floor(mtime)}`;
+	}
+	resolveBundlePath(addonId, bundle) {
+		const paths = this.resolvedPaths;
+		if (!paths) return null;
+		const addonDistPath = node_path.join(paths.addonsDir, "@camstack", `addon-${addonId}`, "dist");
+		const resolvedBase = node_path.resolve(addonDistPath);
+		const resolvedFile = node_path.resolve(addonDistPath, bundle);
+		if (!resolvedFile.startsWith(resolvedBase + node_path.sep) && resolvedFile !== resolvedBase) return null;
+		return resolvedFile;
+	}
+	async resolvePaths() {
+		const fallback = { addonsDir: node_path.resolve("camstack-data", "addons") };
+		if (!this.ctx.settings) return fallback;
+		try {
+			const server = await this.ctx.settings.getSection("server");
+			const dataPath = typeof server["dataPath"] === "string" && server["dataPath"] ? server["dataPath"] : "camstack-data";
+			return { addonsDir: node_path.resolve(dataPath, "addons") };
+		} catch (err) {
+			this.ctx.logger.debug("Failed to read server.dataPath — falling back", { meta: { error: (0, _camstack_types.errMsg)(err) } });
+			return fallback;
+		}
+	}
+};
+//#endregion
+exports.AddonWidgetsAggregatorAddon = AddonWidgetsAggregatorAddon;
+exports.default = AddonWidgetsAggregatorAddon;