@camstack/server 1.2.594 → 1.2.596

package/dist/manual-boot.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Boot — constructs every service by hand in dependency order, runs
  * `onModuleInit` hooks in sequence, and exposes a `BootedApp` facade
@@ -5,47 +6,85 @@
  * removed to drop the accidental DI layer on top of an already-explicit
  * dependency graph.
  */
-import { randomUUID } from 'node:crypto';
-import * as path from 'node:path';
-import { AddonDepsManager, ConsoleDestination } from '@camstack/system';
-import { EventCategory, memoizePinnedFfmpeg, ServerPackageStatusSchema } from '@camstack/types';
-import Fastify from 'fastify';
-import { buildHubHttpSource } from './api/addon-upload';
-import { createNodeRootPackageLookup } from './api/core/cap-providers';
-import { clusterBaseUrlResolver } from './api/hub-cluster-url';
-import { runBootInitSequence } from './boot/init-sequence';
-import { PostBootService } from './boot/post-boot.service';
-import { AddonPackageService } from './core/addon/addon-package.service';
-import { AddonRegistryService } from './core/addon/addon-registry.service';
-import { AddonSearchService } from './core/addon/addon-search.service';
-import { AddonBridgeService } from './core/addon-bridge/addon-bridge.service';
-import { AddonPagesService } from './core/addon-pages/addon-pages.service';
-import { AddonWidgetsService } from './core/addon-widgets/addon-widgets.service';
-import { AGENT_BACKFILL_RPC_TIMEOUT_MS, AgentRegistryService, } from './core/agent/agent-registry.service';
-import { ClusterNodeHistoryStore } from './core/agent/cluster-node-history-store';
-import { AuthService } from './core/auth/auth.service';
-import { CapabilityService } from './core/capability/capability.service';
-import { ConfigService } from './core/config/config.service';
-import { EventBusService } from './core/events/event-bus.service';
-import { FeatureService } from './core/feature/feature.service';
-import { initLifecycleRunner } from './core/lifecycle/lifecycle-runner.singleton';
-import { LoggingService } from './core/logging/logging.service';
-import { MoleculerService } from './core/moleculer/moleculer.service';
-import { NetworkQualityService } from './core/network/network-quality.service';
-import { NotificationServiceWrapper } from './core/notification/notification-wrapper.service';
-import { ToastServiceWrapper } from './core/notification/toast-wrapper.service';
-import { ReplEngineService } from './core/repl/repl-engine.service';
-import { ServerUpdateService } from './core/server-update/server-update.service';
-import { describeRunnerBootCheck, isRunnerBootCheckDegraded, RunnerBootCheckService, } from './core/runner-health/runner-boot-check';
-import { buildUpdatePreflight, legacyGuardClientOf } from './core/runner-health/update-preflight';
-import { StorageService } from './core/storage/storage.service';
-import { StreamProbeService } from './core/streaming/stream-probe.service';
-import { TopologyEmitterService } from './core/topology/topology-emitter.service';
-import { UpdateAvailabilityEmitter } from './core/update-availability-emitter.js';
-import { FileUpdateAvailabilityStore } from './core/update-availability-store.js';
-import { fetchAgentInstalledPackages, } from './core/updates/agent-installed-packages.js';
-import { UpdateCheckScheduler } from './core/updates/update-check-scheduler.js';
-import { WrapperUpdateChecker } from './core/updates/wrapper-update-checker.js';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootManual = bootManual;
+const node_crypto_1 = require("node:crypto");
+const path = __importStar(require("node:path"));
+const system_1 = require("@camstack/system");
+const types_1 = require("@camstack/types");
+const fastify_1 = __importDefault(require("fastify"));
+const addon_upload_1 = require("./api/addon-upload");
+const cap_providers_1 = require("./api/core/cap-providers");
+const hub_cluster_url_1 = require("./api/hub-cluster-url");
+const init_sequence_1 = require("./boot/init-sequence");
+const post_boot_service_1 = require("./boot/post-boot.service");
+const addon_package_service_1 = require("./core/addon/addon-package.service");
+const addon_registry_service_1 = require("./core/addon/addon-registry.service");
+const addon_search_service_1 = require("./core/addon/addon-search.service");
+const addon_bridge_service_1 = require("./core/addon-bridge/addon-bridge.service");
+const addon_pages_service_1 = require("./core/addon-pages/addon-pages.service");
+const addon_widgets_service_1 = require("./core/addon-widgets/addon-widgets.service");
+const agent_registry_service_1 = require("./core/agent/agent-registry.service");
+const cluster_node_history_store_1 = require("./core/agent/cluster-node-history-store");
+const auth_service_1 = require("./core/auth/auth.service");
+const capability_service_1 = require("./core/capability/capability.service");
+const config_service_1 = require("./core/config/config.service");
+const event_bus_service_1 = require("./core/events/event-bus.service");
+const feature_service_1 = require("./core/feature/feature.service");
+const lifecycle_runner_singleton_1 = require("./core/lifecycle/lifecycle-runner.singleton");
+const logging_service_1 = require("./core/logging/logging.service");
+const moleculer_service_1 = require("./core/moleculer/moleculer.service");
+const network_quality_service_1 = require("./core/network/network-quality.service");
+const notification_wrapper_service_1 = require("./core/notification/notification-wrapper.service");
+const toast_wrapper_service_1 = require("./core/notification/toast-wrapper.service");
+const repl_engine_service_1 = require("./core/repl/repl-engine.service");
+const server_update_service_1 = require("./core/server-update/server-update.service");
+const runner_boot_check_1 = require("./core/runner-health/runner-boot-check");
+const update_preflight_1 = require("./core/runner-health/update-preflight");
+const storage_service_1 = require("./core/storage/storage.service");
+const stream_probe_service_1 = require("./core/streaming/stream-probe.service");
+const topology_emitter_service_1 = require("./core/topology/topology-emitter.service");
+const update_availability_emitter_js_1 = require("./core/update-availability-emitter.js");
+const update_availability_store_js_1 = require("./core/update-availability-store.js");
+const agent_installed_packages_js_1 = require("./core/updates/agent-installed-packages.js");
+const update_check_scheduler_js_1 = require("./core/updates/update-check-scheduler.js");
+const wrapper_update_checker_js_1 = require("./core/updates/wrapper-update-checker.js");
 // ---------------------------------------------------------------------------
 // Service container — narrowing via `instanceof`, no casts.
 // ---------------------------------------------------------------------------
@@ -68,18 +107,18 @@ class ServiceContainer {
 // ---------------------------------------------------------------------------
 // Manual boot
 // ---------------------------------------------------------------------------
-export async function bootManual(opts) {
+async function bootManual(opts) {
     const { infra, fastifyOpts } = opts;
     void infra; // infraContext is consumed by main.ts directly (locationManager, etc.)
     const configPath = process.env.CONFIG_PATH ?? 'camstack-data/config.yaml';
     // ---- Layer 0: services with no service deps -----------------------------
-    const configService = new ConfigService(configPath);
-    const storageService = new StorageService();
-    const capabilityService = new CapabilityService();
-    const networkQualityService = new NetworkQualityService();
-    const toastWrapper = new ToastServiceWrapper();
+    const configService = new config_service_1.ConfigService(configPath);
+    const storageService = new storage_service_1.StorageService();
+    const capabilityService = new capability_service_1.CapabilityService();
+    const networkQualityService = new network_quality_service_1.NetworkQualityService();
+    const toastWrapper = new toast_wrapper_service_1.ToastServiceWrapper();
     // ---- Layer 1: need ConfigService / LoggingService -----------------------
-    const loggingService = new LoggingService(configService);
+    const loggingService = new logging_service_1.LoggingService(configService);
     // Bootstrap stdout, attached at the FIRST moment a LogManager exists.
     //
     // The real console destination is a core builtin that boots in pass 3, after
@@ -88,10 +127,10 @@ export async function bootManual(opts) {
     // investigation needed a parser (docs/design/boot-to-usable-camera.md, F).
     // This sink carries the window and is detached — without a second flush —
     // the moment `console-logging` registers.
-    const bootstrapConsole = new ConsoleDestination();
+    const bootstrapConsole = new system_1.ConsoleDestination();
     void bootstrapConsole.initialize();
     loggingService.attachBootstrapConsole(bootstrapConsole);
-    const eventBusService = new EventBusService(configService);
+    const eventBusService = new event_bus_service_1.EventBusService(configService);
     // Wire device-name cache for log formatter — subscribes here so the
     // very first DeviceRegistered event populates the cache before any
     // log line needing `deviceName` is emitted.
@@ -101,22 +140,22 @@ export async function bootManual(opts) {
     // the disabled set), so console/winston could not be turned off at all while
     // Loki appeared to work only through a second, private `enabled` setting.
     loggingService.setDestinationEnabledCheck((addonId) => capabilityService.getRegistry()?.isProviderDisabled('log-destination', addonId) !== true);
-    const featureService = new FeatureService(configService);
-    const authService = new AuthService(configService);
+    const featureService = new feature_service_1.FeatureService(configService);
+    const authService = new auth_service_1.AuthService(configService);
     // The probe runs the node's PINNED ffmpeg (D540) — resolved through the same
     // deps manager every addon is given, once, and never looked up on PATH.
     // (The manager roots binaries at the NODE's data dir whatever it is given.)
-    const probeDeps = new AddonDepsManager(path.resolve(process.env['CAMSTACK_DATA'] ?? 'camstack-data'), loggingService.createLogger('StreamProbeDeps'));
-    const streamProbeService = new StreamProbeService(loggingService, memoizePinnedFfmpeg(() => probeDeps.ensureFfmpeg()));
-    const addonBridgeService = new AddonBridgeService(loggingService);
-    const addonSearchService = new AddonSearchService(loggingService);
+    const probeDeps = new system_1.AddonDepsManager(path.resolve(process.env['CAMSTACK_DATA'] ?? 'camstack-data'), loggingService.createLogger('StreamProbeDeps'));
+    const streamProbeService = new stream_probe_service_1.StreamProbeService(loggingService, (0, types_1.memoizePinnedFfmpeg)(() => probeDeps.ensureFfmpeg()));
+    const addonBridgeService = new addon_bridge_service_1.AddonBridgeService(loggingService);
+    const addonSearchService = new addon_search_service_1.AddonSearchService(loggingService);
     // ---- Layer 2: need Layer 0/1 -------------------------------------------
-    const notificationWrapper = new NotificationServiceWrapper(capabilityService, loggingService);
-    const addonPagesService = new AddonPagesService(loggingService, configService, capabilityService);
-    const moleculerService = new MoleculerService(eventBusService, configService, loggingService, capabilityService, streamProbeService);
+    const notificationWrapper = new notification_wrapper_service_1.NotificationServiceWrapper(capabilityService, loggingService);
+    const addonPagesService = new addon_pages_service_1.AddonPagesService(loggingService, configService, capabilityService);
+    const moleculerService = new moleculer_service_1.MoleculerService(eventBusService, configService, loggingService, capabilityService, streamProbeService);
     // ---- Layer 3: need Moleculer / AddonRegistry ---------------------------
-    const agentRegistryService = new AgentRegistryService(eventBusService, moleculerService, capabilityService);
-    const addonRegistryService = new AddonRegistryService(loggingService, eventBusService, configService, storageService, capabilityService, moleculerService, streamProbeService);
+    const agentRegistryService = new agent_registry_service_1.AgentRegistryService(eventBusService, moleculerService, capabilityService);
+    const addonRegistryService = new addon_registry_service_1.AddonRegistryService(loggingService, eventBusService, configService, storageService, capabilityService, moleculerService, streamProbeService);
     // AgentRegistryService needs the hub addon registry for placement-based
     // reconciliation, but is constructed first (it has no other dependency
     // on AddonRegistryService) — wire it post-construction.
@@ -127,18 +166,18 @@ export async function bootManual(opts) {
     // A1: durable, routing-blind offline-node history — persisted through the
     // hub-resident `settings-store` cap (resolved lazily; null until it boots).
     // Wired post-construction so the service's 3-arg constructor stays intact.
-    const clusterNodeHistoryStore = new ClusterNodeHistoryStore(() => capabilityService.getRegistry()?.getSingleton('settings-store') ??
+    const clusterNodeHistoryStore = new cluster_node_history_store_1.ClusterNodeHistoryStore(() => capabilityService.getRegistry()?.getSingleton('settings-store') ??
         null, loggingService.createLogger('cluster-node-history'));
     agentRegistryService.setClusterNodeHistoryStore(clusterNodeHistoryStore);
     addonRegistryService.setClusterNodeHistoryStore(clusterNodeHistoryStore);
     // ---- Layer 4: need AddonRegistry ---------------------------------------
     // AddonWidgetsService — needs AddonRegistryService for the bundled-addon
     // dist sub-folder lookup (see service docstring).
-    const addonWidgetsService = new AddonWidgetsService(loggingService, capabilityService, addonRegistryService);
+    const addonWidgetsService = new addon_widgets_service_1.AddonWidgetsService(loggingService, capabilityService, addonRegistryService);
     // Durable `update.available` dedup lives next to `auto-update.json`, so a
     // hub restart never re-announces what the operator already saw.
     const availabilityDataDir = path.resolve(process.env['CAMSTACK_DATA'] ?? 'camstack-data');
-    const addonPackageService = new AddonPackageService(loggingService, eventBusService, configService, addonRegistryService, notificationWrapper, toastWrapper, new FileUpdateAvailabilityStore(availabilityDataDir, 'addon-packages', loggingService.createLogger('UpdateAvailability')));
+    const addonPackageService = new addon_package_service_1.AddonPackageService(loggingService, eventBusService, configService, addonRegistryService, notificationWrapper, toastWrapper, new update_availability_store_js_1.FileUpdateAvailabilityStore(availabilityDataDir, 'addon-packages', loggingService.createLogger('UpdateAvailability')));
     // Addon back-fill delivery seam. Wired here (not in the AgentRegistryService
     // constructor) because it needs AddonPackageService, which is a later layer.
     // Bytes come from THE HUB'S OWN INSTALLED COPY whenever it has one, and only
@@ -152,7 +191,7 @@ export async function bootManual(opts) {
     const backfillLogger = loggingService.createLogger('agent-backfill');
     // Where the agent pulls the bundle from: the hub's own cluster address, from
     // the `local-network` cap — never an env var, never loopback.
-    const resolveClusterBaseUrl = clusterBaseUrlResolver(() => addonRegistryService
+    const resolveClusterBaseUrl = (0, hub_cluster_url_1.clusterBaseUrlResolver)(() => addonRegistryService
         .getCapabilityRegistry()
         .getSingleton('local-network'));
     agentRegistryService.setAddonBackfill({
@@ -171,10 +210,10 @@ export async function bootManual(opts) {
             return (installed ?? (await addonPackageService.packPackage(name, version))).buffer;
         },
         deploy: async (nodeId, packageName, bundle) => {
-            await moleculerService.broker.call('$agent.deploy', { addonId: packageName, source: buildHubHttpSource(bundle, await resolveClusterBaseUrl()) }, { nodeID: nodeId, timeout: AGENT_BACKFILL_RPC_TIMEOUT_MS });
+            await moleculerService.broker.call('$agent.deploy', { addonId: packageName, source: (0, addon_upload_1.buildHubHttpSource)(bundle, await resolveClusterBaseUrl()) }, { nodeID: nodeId, timeout: agent_registry_service_1.AGENT_BACKFILL_RPC_TIMEOUT_MS });
         },
         reload: async (nodeId) => {
-            await moleculerService.broker.call('$agent.reload', {}, { nodeID: nodeId, timeout: AGENT_BACKFILL_RPC_TIMEOUT_MS });
+            await moleculerService.broker.call('$agent.reload', {}, { nodeID: nodeId, timeout: agent_registry_service_1.AGENT_BACKFILL_RPC_TIMEOUT_MS });
         },
     });
     // ---- Lifecycle job runner (boot singleton) -----------------------------
@@ -184,7 +223,7 @@ export async function bootManual(opts) {
     // it ONCE here from the addon-package service + event bus. `createdBy` is no
     // longer a construction dep — it travels on each `startJob` call.
     const lifecycleDataDir = path.resolve(process.env['CAMSTACK_DATA'] ?? 'camstack-data');
-    initLifecycleRunner({
+    (0, lifecycle_runner_singleton_1.initLifecycleRunner)({
         dataDir: lifecycleDataDir,
         fetchTarball: (name, version, signal) => addonPackageService.fetchAddonTarball(name, version, signal),
         extract: (tgz, destDir) => addonPackageService.extractTarball(tgz, destDir),
@@ -194,31 +233,31 @@ export async function bootManual(opts) {
         emit: (kind, job, entry) => {
             if (kind === 'progress') {
                 eventBusService.emit({
-                    id: randomUUID(),
+                    id: (0, node_crypto_1.randomUUID)(),
                     timestamp: new Date(),
                     source: { type: 'core', id: 'lifecycle-job-engine' },
-                    category: EventCategory.AddonsJobProgress,
+                    category: types_1.EventCategory.AddonsJobProgress,
                     data: { job },
                 });
             }
             else {
                 eventBusService.emit({
-                    id: randomUUID(),
+                    id: (0, node_crypto_1.randomUUID)(),
                     timestamp: new Date(),
                     source: { type: 'core', id: 'lifecycle-job-engine' },
-                    category: EventCategory.AddonsJobLog,
+                    category: types_1.EventCategory.AddonsJobLog,
                     data: { jobId: job.jobId, entry },
                 });
             }
         },
     });
-    const replEngineService = new ReplEngineService(addonRegistryService, eventBusService, loggingService);
+    const replEngineService = new repl_engine_service_1.ReplEngineService(addonRegistryService, eventBusService, loggingService);
     // Runtime-updatable root package (phase 1: hub only). The service owns the
     // data-dir server-root staging/rollback lifecycle; restarts route through
     // AddonPackageService.restartServer for the marker + reconnect toast.
     // D877: the runner boot check (one-shot after boot, scheduled by main.ts) and
     // the update pre-flight (would the target refuse addons on the live store?).
-    const hubRunnerBootCheck = new RunnerBootCheckService({
+    const hubRunnerBootCheck = new runner_boot_check_1.RunnerBootCheckService({
         logger: loggingService.createLogger('RunnerBootCheck'),
         nodeId: 'hub',
         planned: () => addonRegistryService.plannedRunnerIds(),
@@ -231,14 +270,14 @@ export async function bootManual(opts) {
         // The verdict reaches the alert centre (one alert + the direct critical push).
         onResult: (check) => {
             eventBusService.emit({
-                id: randomUUID(),
+                id: (0, node_crypto_1.randomUUID)(),
                 timestamp: new Date(),
                 source: { type: 'core', id: 'runner-boot-check' },
-                category: EventCategory.SystemRunnerCheck,
+                category: types_1.EventCategory.SystemRunnerCheck,
                 data: {
                     nodeId: 'hub',
-                    degraded: isRunnerBootCheckDegraded(check),
-                    summary: describeRunnerBootCheck(check),
+                    degraded: (0, runner_boot_check_1.isRunnerBootCheckDegraded)(check),
+                    summary: (0, runner_boot_check_1.describeRunnerBootCheck)(check),
                     expected: check.expected,
                     running: check.running,
                     failed: [...check.failed],
@@ -249,23 +288,23 @@ export async function bootManual(opts) {
         },
     });
     const settingsStoreOrNull = () => capabilityService.getRegistry()?.getSingleton('settings-store') ?? null;
-    const serverUpdateService = new ServerUpdateService({
-        updatePreflight: buildUpdatePreflight({
+    const serverUpdateService = new server_update_service_1.ServerUpdateService({
+        updatePreflight: (0, update_preflight_1.buildUpdatePreflight)({
             logger: loggingService.createLogger('UpdatePreflight'),
             forkedAddonIds: () => addonRegistryService.forkedAddonIds(),
             store: () => {
                 const store = settingsStoreOrNull();
-                return store === null ? null : legacyGuardClientOf(store);
+                return store === null ? null : (0, update_preflight_1.legacyGuardClientOf)(store);
             },
         }),
         runnerBootCheck: () => hubRunnerBootCheck.current(),
         logger: loggingService.createLogger('ServerUpdate'),
         restartServer: (requestedBy, update) => addonPackageService.restartServer(requestedBy, update),
         eventBus: eventBusService,
-        updateAvailabilityStore: new FileUpdateAvailabilityStore(availabilityDataDir, 'server-update', loggingService.createLogger('UpdateAvailability')),
+        updateAvailabilityStore: new update_availability_store_js_1.FileUpdateAvailabilityStore(availabilityDataDir, 'server-update', loggingService.createLogger('UpdateAvailability')),
     });
-    const topologyEmitterService = new TopologyEmitterService(eventBusService, agentRegistryService, addonRegistryService, createNodeRootPackageLookup(moleculerService, serverUpdateService), (nodeId) => moleculerService.isNodeRegistered(nodeId));
-    const postBootService = new PostBootService(addonRegistryService, eventBusService, loggingService);
+    const topologyEmitterService = new topology_emitter_service_1.TopologyEmitterService(eventBusService, agentRegistryService, addonRegistryService, (0, cap_providers_1.createNodeRootPackageLookup)(moleculerService, serverUpdateService), (nodeId) => moleculerService.isNodeRegistered(nodeId));
+    const postBootService = new post_boot_service_1.PostBootService(addonRegistryService, eventBusService, loggingService);
     // ---- Update availability poller ---------------------------------------
     // "Tell me, don't install." Deliberately NOT gated on the auto-update
     // channel — that gate is why the only periodic publisher was dead on every
@@ -274,9 +313,9 @@ export async function bootManual(opts) {
     // The fifth target: the SHELL each node runs inside. Its own emitter scope,
     // so a shell announcement and a code announcement never overwrite each
     // other's dedup state — they are different facts about the same node (D437).
-    const wrapperUpdateChecker = new WrapperUpdateChecker({
+    const wrapperUpdateChecker = new wrapper_update_checker_js_1.WrapperUpdateChecker({
         logger: updateCheckLogger,
-        emitter: new UpdateAvailabilityEmitter(eventBusService, { type: 'core', id: 'wrapper-update-check' }, new FileUpdateAvailabilityStore(availabilityDataDir, 'wrapper-update', loggingService.createLogger('UpdateAvailability'))),
+        emitter: new update_availability_emitter_js_1.UpdateAvailabilityEmitter(eventBusService, { type: 'core', id: 'wrapper-update-check' }, new update_availability_store_js_1.FileUpdateAvailabilityStore(availabilityDataDir, 'wrapper-update', loggingService.createLogger('UpdateAvailability'))),
         readStatus: async (nodeId, isHub) => {
             if (isHub)
                 return serverUpdateService.getServerPackageStatus();
@@ -287,10 +326,10 @@ export async function bootManual(opts) {
                 throw new Error(`server-management unreachable on ${nodeId}`);
             }
             const status = await proxy['getServerPackageStatus']?.({});
-            return ServerPackageStatusSchema.parse(status);
+            return types_1.ServerPackageStatusSchema.parse(status);
         },
     });
-    const updateCheckScheduler = new UpdateCheckScheduler({
+    const updateCheckScheduler = new update_check_scheduler_js_1.UpdateCheckScheduler({
         logger: updateCheckLogger,
         getIntervalSeconds: () => addonPackageService.getAutoUpdateSettings().updateCheckIntervalSeconds,
         targets: {
@@ -299,7 +338,7 @@ export async function bootManual(opts) {
             checkFrameworkPackages: () => addonPackageService.listFrameworkPackages(),
             checkAgentAddons: async (nodeId) => {
                 const broker = moleculerService.broker;
-                const installed = await fetchAgentInstalledPackages(broker, nodeId);
+                const installed = await (0, agent_installed_packages_js_1.fetchAgentInstalledPackages)(broker, nodeId);
                 return addonPackageService.checkUpdatesForInstalled(installed, nodeId);
             },
             checkNodeServerUpdate: async (nodeId, isHub) => {
@@ -323,36 +362,36 @@ export async function bootManual(opts) {
     updateCheckScheduler.start();
     // ---- Container ---------------------------------------------------------
     const container = new ServiceContainer();
-    container.register(ConfigService, configService);
-    container.register(LoggingService, loggingService);
-    container.register(EventBusService, eventBusService);
-    container.register(StorageService, storageService);
-    container.register(CapabilityService, capabilityService);
-    container.register(FeatureService, featureService);
-    container.register(AuthService, authService);
-    container.register(StreamProbeService, streamProbeService);
-    container.register(NetworkQualityService, networkQualityService);
-    container.register(ToastServiceWrapper, toastWrapper);
-    container.register(NotificationServiceWrapper, notificationWrapper);
-    container.register(AddonPagesService, addonPagesService);
-    container.register(AddonWidgetsService, addonWidgetsService);
-    container.register(AddonBridgeService, addonBridgeService);
-    container.register(MoleculerService, moleculerService);
-    container.register(AgentRegistryService, agentRegistryService);
-    container.register(AddonRegistryService, addonRegistryService);
-    container.register(AddonSearchService, addonSearchService);
-    container.register(AddonPackageService, addonPackageService);
-    container.register(ReplEngineService, replEngineService);
-    container.register(ServerUpdateService, serverUpdateService);
-    container.register(RunnerBootCheckService, hubRunnerBootCheck);
+    container.register(config_service_1.ConfigService, configService);
+    container.register(logging_service_1.LoggingService, loggingService);
+    container.register(event_bus_service_1.EventBusService, eventBusService);
+    container.register(storage_service_1.StorageService, storageService);
+    container.register(capability_service_1.CapabilityService, capabilityService);
+    container.register(feature_service_1.FeatureService, featureService);
+    container.register(auth_service_1.AuthService, authService);
+    container.register(stream_probe_service_1.StreamProbeService, streamProbeService);
+    container.register(network_quality_service_1.NetworkQualityService, networkQualityService);
+    container.register(toast_wrapper_service_1.ToastServiceWrapper, toastWrapper);
+    container.register(notification_wrapper_service_1.NotificationServiceWrapper, notificationWrapper);
+    container.register(addon_pages_service_1.AddonPagesService, addonPagesService);
+    container.register(addon_widgets_service_1.AddonWidgetsService, addonWidgetsService);
+    container.register(addon_bridge_service_1.AddonBridgeService, addonBridgeService);
+    container.register(moleculer_service_1.MoleculerService, moleculerService);
+    container.register(agent_registry_service_1.AgentRegistryService, agentRegistryService);
+    container.register(addon_registry_service_1.AddonRegistryService, addonRegistryService);
+    container.register(addon_search_service_1.AddonSearchService, addonSearchService);
+    container.register(addon_package_service_1.AddonPackageService, addonPackageService);
+    container.register(repl_engine_service_1.ReplEngineService, replEngineService);
+    container.register(server_update_service_1.ServerUpdateService, serverUpdateService);
+    container.register(runner_boot_check_1.RunnerBootCheckService, hubRunnerBootCheck);
     // A runner settling (READY / crashed / failed / refused) re-evaluates a verdict
     // that still had runners on their way (D877).
-    eventBusService.subscribe({ category: EventCategory.ProcessStateChanged }, () => hubRunnerBootCheck.noteRunnerChange());
-    container.register(TopologyEmitterService, topologyEmitterService);
-    container.register(PostBootService, postBootService);
-    container.register(UpdateCheckScheduler, updateCheckScheduler);
+    eventBusService.subscribe({ category: types_1.EventCategory.ProcessStateChanged }, () => hubRunnerBootCheck.noteRunnerChange());
+    container.register(topology_emitter_service_1.TopologyEmitterService, topologyEmitterService);
+    container.register(post_boot_service_1.PostBootService, postBootService);
+    container.register(update_check_scheduler_js_1.UpdateCheckScheduler, updateCheckScheduler);
     // ---- Fastify instance --------------------------------------------------
-    const fastify = Fastify(fastifyOpts);
+    const fastify = (0, fastify_1.default)(fastifyOpts);
     // /health and /health/* — registered in `main.ts` via
     // `registerHealthRoutes` once MoleculerService + AgentRegistryService are
     // available. The detailed shape is shared with each agent's `/health`
@@ -426,7 +465,7 @@ export async function bootManual(opts) {
         async init(hooks = {}) {
             // The order and the `beforeAddonBoot` seam live in `runBootInitSequence`
             // — see `boot/init-sequence.ts` for why that seam is load-bearing.
-            await runBootInitSequence({
+            await (0, init_sequence_1.runBootInitSequence)({
                 moleculer: () => moleculerService.onModuleInit(),
                 addonBridge: () => addonBridgeService.onModuleInit(),
                 agentRegistry: () => {

package/dist/node-role.js

@@ -1,4 +1,7 @@
-export function resolveNodeRole(env) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNodeRole = resolveNodeRole;
+function resolveNodeRole(env) {
     const raw = (env['CAMSTACK_ROLE'] ?? '').trim().toLowerCase();
     if (raw === '' || raw === 'hub')
         return 'hub';

package/dist/package-inventory.js

@@ -1,3 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOST_PROVIDED_PACKAGES = void 0;
+exports.hostProvidedSearchRoots = hostProvidedSearchRoots;
+exports.seedNodeModulesRoots = seedNodeModulesRoots;
+exports.inventoryHostProvided = inventoryHostProvided;
+exports.formatInventoryReport = formatInventoryReport;
+exports.formatShadowingNotes = formatShadowingNotes;
 /**
  * Boot-time inventory of host-provided packages — enforcement step 2 of
  * [D45](../../../docs/decisions/adr-0045.md).
@@ -28,13 +69,13 @@
  * so the whole inventory is testable against a described layout rather than a
  * real disk.
  */
-import * as path from 'node:path';
+const path = __importStar(require("node:path"));
 /**
  * Packages the closure provides to everything on the node. Addons never bundle
  * these ([D15](../../../docs/decisions/adr-0015.md)); a second copy on disk is
  * a resolution race waiting for a boot order to change.
  */
-export const HOST_PROVIDED_PACKAGES = [
+exports.HOST_PROVIDED_PACKAGES = [
     '@camstack/system',
     '@camstack/types',
     '@camstack/sdk',
@@ -53,7 +94,7 @@ export const HOST_PROVIDED_PACKAGES = [
  * on `NODE_PATH`: the launcher puts the deposit and the seeds there itself, so
  * "it is on NODE_PATH" would mark the whole fleet unexpected.
  */
-export function hostProvidedSearchRoots(input) {
+function hostProvidedSearchRoots(input) {
     const fromNodePath = (input.nodePath ?? '')
         .split(input.pathSeparator)
         .map((p) => p.trim())
@@ -112,7 +153,7 @@ export function hostProvidedSearchRoots(input) {
  * list would quietly stop finding the copy it was written for. Returns empty
  * when `/opt` does not exist, which is every dev machine.
  */
-export function seedNodeModulesRoots(fs, optDir = '/opt') {
+function seedNodeModulesRoots(fs, optDir = '/opt') {
     if (!fs.existsSync(optDir))
         return [];
     try {
@@ -133,7 +174,7 @@ export function seedNodeModulesRoots(fs, optDir = '/opt') {
  * count — and an unreadable copy is exactly the kind that has been sitting
  * somewhere since an interrupted install.
  */
-export function inventoryHostProvided(roots, fs, packages = HOST_PROVIDED_PACKAGES) {
+function inventoryHostProvided(roots, fs, packages = exports.HOST_PROVIDED_PACKAGES) {
     const copies = [];
     for (const pkg of packages) {
         // Keyed by canonical path: two roots that are the same directory (a
@@ -193,7 +234,7 @@ function classifyPackage(pkg, found) {
  * under the deposit is the fleet's normal shape and reports nothing here, or
  * the banner would print on every boot of every node and be read on none.
  */
-export function formatInventoryReport(result) {
+function formatInventoryReport(result) {
     const violating = result.packages.filter((p) => p.violation);
     if (violating.length === 0)
         return '';
@@ -230,7 +271,7 @@ function describeLocation(copy, inv) {
  * already named in {@link formatInventoryReport} is skipped: the banner lists
  * all of its copies, and a reassuring line beside it would read as verification.
  */
-export function formatShadowingNotes(result) {
+function formatShadowingNotes(result) {
     return result.packages
         .filter((p) => !p.violation && p.shadowedSeeds.length > 0)
         .map((p) => {