@camstack/server 0.2.2 → 1.0.1

package/dist/core/agent/agent-registry.service.js

@@ -0,0 +1,477 @@
+"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.AgentRegistryService = void 0;
+const node_crypto_1 = require("node:crypto");
+const os = __importStar(require("node:os"));
+const types_1 = require("@camstack/types");
+/** Per-call timeout for `$agent.*` RPC during reconciliation. */
+const AGENT_RECONCILE_RPC_TIMEOUT_MS = 8_000;
+class AgentRegistryService {
+    eventBus;
+    moleculer;
+    capabilityService;
+    // Role assignments: key = `${cameraId}:${role}`
+    assignments = new Map();
+    bootTimestamp = Date.now();
+    /**
+     * Hub addon registry — the source of truth for which addons are
+     * installed and their `execution.placement`. Injected via
+     * `setAddonRegistry()` rather than the constructor because
+     * `AddonRegistryService` is built AFTER this service in the boot
+     * order (see `manual-boot.ts`).
+     */
+    addonRegistry = null;
+    constructor(eventBus, moleculer, capabilityService) {
+        this.eventBus = eventBus;
+        this.moleculer = moleculer;
+        this.capabilityService = capabilityService;
+    }
+    /** Wire the hub addon registry once it has been constructed. */
+    setAddonRegistry(addonRegistry) {
+        this.addonRegistry = addonRegistry;
+    }
+    /** Typed view of the Moleculer broker — single documented cast. */
+    get broker() {
+        return this.moleculer.broker;
+    }
+    onModuleInit() {
+        const classifyNode = (id) => {
+            if (id === 'hub')
+                return null;
+            if (id.includes('/'))
+                return 'worker';
+            return 'agent';
+        };
+        // D3: reconcile placement when an agent completes the $hub.registerNode
+        // handshake — the manifest is authoritative and complete at that point,
+        // no grace delay needed. MoleculerService fires this callback from its
+        // onRegisterNode dep for every bare-ID agent node.
+        this.moleculer.setOnAgentRegistered((agentId) => {
+            void this.reconcileAgentAddons(agentId);
+        });
+        this.broker.localBus.on('$node.connected', ({ node }) => {
+            const kind = classifyNode(node.id);
+            if (!kind)
+                return;
+            if (kind === 'agent') {
+                console.log(`[agent-registry] Agent connected: ${node.id}`);
+                this.eventBus.emit({
+                    id: (0, node_crypto_1.randomUUID)(),
+                    timestamp: new Date(),
+                    source: { type: 'core', id: 'agent-registry' },
+                    category: types_1.EventCategory.AgentOnline,
+                    data: { agentId: node.id },
+                });
+            }
+            else {
+                this.eventBus.emit({
+                    id: (0, node_crypto_1.randomUUID)(),
+                    timestamp: new Date(),
+                    source: { type: 'core', id: 'agent-registry' },
+                    category: types_1.EventCategory.WorkerOnline,
+                    data: { workerId: node.id },
+                });
+            }
+        });
+        this.broker.localBus.on('$node.disconnected', ({ node }) => {
+            const kind = classifyNode(node.id);
+            if (!kind)
+                return;
+            if (kind === 'agent') {
+                console.log(`[agent-registry] Agent disconnected: ${node.id}`);
+                this.eventBus.emit({
+                    id: (0, node_crypto_1.randomUUID)(),
+                    timestamp: new Date(),
+                    source: { type: 'core', id: 'agent-registry' },
+                    category: types_1.EventCategory.AgentOffline,
+                    data: { agentId: node.id },
+                });
+            }
+            else {
+                this.eventBus.emit({
+                    id: (0, node_crypto_1.randomUUID)(),
+                    timestamp: new Date(),
+                    source: { type: 'core', id: 'agent-registry' },
+                    category: types_1.EventCategory.WorkerOffline,
+                    data: { workerId: node.id },
+                });
+            }
+        });
+        // Retroactive scan: emit lifecycle events for nodes already
+        // connected when the listener registers. Classifies each as
+        // agent or worker — same logic as the live handlers above.
+        try {
+            const registry = this.moleculer.broker.registry;
+            const existing = registry?.getNodeList?.({ onlyAvailable: true }) ?? [];
+            for (const { id } of existing) {
+                const kind = classifyNode(id);
+                if (!kind)
+                    continue;
+                if (kind === 'agent') {
+                    this.eventBus.emit({
+                        id: (0, node_crypto_1.randomUUID)(),
+                        timestamp: new Date(),
+                        source: { type: 'core', id: 'agent-registry' },
+                        category: types_1.EventCategory.AgentOnline,
+                        data: { agentId: id },
+                    });
+                }
+                else {
+                    this.eventBus.emit({
+                        id: (0, node_crypto_1.randomUUID)(),
+                        timestamp: new Date(),
+                        source: { type: 'core', id: 'agent-registry' },
+                        category: types_1.EventCategory.WorkerOnline,
+                        data: { workerId: id },
+                    });
+                }
+            }
+        }
+        catch {
+            // Registry shape varies across Moleculer versions — never fatal.
+        }
+    }
+    // ---- Placement reconciliation ----
+    /**
+     * Boot-time reconciliation pass. Agents already connected when the hub
+     * starts never fire a fresh `$node.connected` event, so the per-connect
+     * trigger would miss them — this method walks the current node list once
+     * and reconciles every connected agent. Must be invoked AFTER
+     * `AddonRegistryService.onModuleInit()` so the hub's installed-addon set
+     * is populated. Per-agent failures are isolated — one unreachable agent
+     * must not abort the pass or hub boot.
+     */
+    async reconcileConnectedAgents() {
+        const registry = this.moleculer.broker.registry;
+        const nodes = registry?.getNodeList?.({ onlyAvailable: true }) ?? [];
+        const agentIds = nodes.map((n) => n.id).filter((id) => id !== 'hub' && !id.includes('/'));
+        if (agentIds.length === 0)
+            return;
+        console.log(`[agent-registry] Boot reconcile: ${agentIds.length} connected agent(s)`);
+        for (const agentId of agentIds) {
+            await this.reconcileAgentAddons(agentId);
+        }
+    }
+    /**
+     * Reconcile a single agent's deployed addons against the hub's installed
+     * set + placements. An addon running on the agent is STALE — and must be
+     * undeployed — when it is either:
+     *   - not installed on the hub at all, or
+     *   - installed but declared `execution.placement: 'hub-only'`.
+     *
+     * `agent-only` / `any-node` addons that ARE installed on the hub are
+     * legitimate agent residents and left untouched.
+     *
+     * Matching is by addon DECLARATION id: `$agent.status` reports
+     * `addons[].id` (the decl id), and the hub's `listAddons()` rows expose
+     * the same decl id at `manifest.id`. Package names are NOT used for the
+     * match — a single package can ship multiple addons with distinct ids
+     * and placements.
+     *
+     * All errors are caught and logged so a single bad agent never breaks
+     * the caller (connect handler or boot pass).
+     */
+    async reconcileAgentAddons(agentId) {
+        if (!this.addonRegistry) {
+            console.warn(`[agent-registry] Reconcile skipped for ${agentId}: addon registry not wired`);
+            return;
+        }
+        try {
+            const broker = this.broker;
+            const statusRaw = await broker.call('$agent.status', {}, {
+                nodeID: agentId,
+                timeout: AGENT_RECONCILE_RPC_TIMEOUT_MS,
+            });
+            const agentAddons = this.extractAgentAddons(statusRaw);
+            if (agentAddons.length === 0)
+                return;
+            // Build the hub's placement map: decl id → placement. Absence from
+            // this map means "not installed on the hub".
+            const hubPlacements = new Map();
+            for (const row of this.addonRegistry.listAddons()) {
+                const declId = row.manifest.id;
+                if (typeof declId !== 'string')
+                    continue;
+                const decl = row.declaration ?? row.manifest;
+                hubPlacements.set(declId, (0, types_1.resolveAddonPlacement)(decl));
+            }
+            const stale = agentAddons.filter((addon) => {
+                const placement = hubPlacements.get(addon.id);
+                // Not installed on the hub → stale.
+                if (placement === undefined)
+                    return true;
+                // Installed but pinned to the hub → must not run on an agent.
+                return placement === 'hub-only';
+            });
+            if (stale.length === 0) {
+                console.log(`[agent-registry] Reconcile ${agentId}: no stale addons (${agentAddons.length} checked)`);
+                return;
+            }
+            for (const addon of stale) {
+                const reason = hubPlacements.has(addon.id)
+                    ? 'placement is hub-only'
+                    : 'not installed on hub';
+                try {
+                    await broker.call('$agent.undeploy', { addonId: addon.id }, {
+                        nodeID: agentId,
+                        timeout: AGENT_RECONCILE_RPC_TIMEOUT_MS,
+                    });
+                    console.log(`[agent-registry] Reconcile ${agentId}: undeployed stale addon "${addon.id}" (${reason})`);
+                    this.eventBus.emit({
+                        id: (0, node_crypto_1.randomUUID)(),
+                        timestamp: new Date(),
+                        source: { type: 'core', id: 'agent-registry' },
+                        category: types_1.EventCategory.AddonUninstalled,
+                        data: { addonId: addon.id, agentId, reason },
+                    });
+                }
+                catch (err) {
+                    console.error(`[agent-registry] Reconcile ${agentId}: failed to undeploy "${addon.id}":`, err instanceof Error ? err.message : String(err));
+                }
+            }
+        }
+        catch (err) {
+            console.error(`[agent-registry] Reconcile failed for agent ${agentId}:`, err instanceof Error ? err.message : String(err));
+        }
+    }
+    /** Narrow the `$agent.status` response down to its addon list. */
+    extractAgentAddons(statusRaw) {
+        if (statusRaw === null || typeof statusRaw !== 'object')
+            return [];
+        const addons = statusRaw.addons;
+        if (!Array.isArray(addons))
+            return [];
+        const result = [];
+        for (const entry of addons) {
+            if (entry === null || typeof entry !== 'object')
+                continue;
+            const id = entry.id;
+            if (typeof id !== 'string' || id.length === 0)
+                continue;
+            result.push({ id });
+        }
+        return result;
+    }
+    /** Log an agent rename (name changes are persisted via $agent.rename RPC). */
+    updateAgentName(nodeId, name) {
+        console.log(`[agent-registry] Agent renamed: "${nodeId}" → "${name}"`);
+    }
+    async listNodes() {
+        // Get child processes for hub via $process.list
+        let hubProcesses = [];
+        try {
+            const processes = (await this.broker.call('$process.list'));
+            hubProcesses = processes.map((p) => ({
+                pid: p.pid ?? 0,
+                name: p.name ?? '',
+                command: 'moleculer-service',
+                state: p.state ?? 'running',
+                cpuPercent: p.cpuPercent ?? 0,
+                memoryRss: p.memoryRss ?? 0,
+                uptimeSeconds: p.uptimeSeconds ?? 0,
+                addonIds: p.addonIds ?? [],
+                groupId: p.groupId ?? null,
+            }));
+        }
+        catch {
+            // $process service may not be ready yet
+        }
+        const hubEntry = await this.buildHubEntry(hubProcesses);
+        const remoteEntries = [];
+        const registry = this.moleculer.broker.registry;
+        const nodes = registry?.getNodeList?.({ onlyAvailable: true }) ?? [];
+        for (const node of nodes) {
+            const nodeId = node.id;
+            // Skip hub (already included) and child processes (contain '/')
+            if (nodeId === 'hub' || nodeId.includes('/'))
+                continue;
+            try {
+                const status = (await this.broker.call('$agent.status', {}, {
+                    nodeID: nodeId,
+                    timeout: 5000,
+                }));
+                // Get real sub-process stats from the agent's $process.list
+                let subProcesses = [];
+                try {
+                    const processes = (await this.broker.call('$process.list', {}, {
+                        nodeID: nodeId,
+                        timeout: 5000,
+                    }));
+                    subProcesses = processes.map((p) => ({
+                        pid: p.pid ?? 0,
+                        name: p.name ?? '',
+                        command: 'moleculer-service',
+                        state: p.state ?? 'running',
+                        cpuPercent: p.cpuPercent ?? 0,
+                        memoryRss: p.memoryRss ?? 0,
+                        uptimeSeconds: p.uptimeSeconds ?? 0,
+                        addonIds: p.addonIds ?? [],
+                        groupId: p.groupId ?? null,
+                    }));
+                }
+                catch {
+                    // Fall back to addon list from $agent.status (no stats)
+                    subProcesses =
+                        status.addons?.map((a) => ({
+                            pid: 0,
+                            name: a.id ?? '',
+                            command: 'moleculer-service',
+                            state: (a.status ?? 'running'),
+                            cpuPercent: 0,
+                            memoryRss: 0,
+                            uptimeSeconds: 0,
+                        })) ?? [];
+                }
+                // Extract addon IDs from $agent.status
+                const agentAddons = status.addons?.map((a) => a.id) ?? [];
+                const hostname = typeof status.hostname === 'string' ? status.hostname : null;
+                const agentName = typeof status.name === 'string' ? status.name : nodeId;
+                remoteEntries.push({
+                    info: {
+                        id: nodeId,
+                        name: agentName,
+                        hostname: hostname ?? nodeId,
+                        capabilities: [],
+                        platform: status.platform ?? 'unknown',
+                        arch: status.arch ?? 'unknown',
+                        cpuCores: status.cpuCores ?? 0,
+                        memoryMB: status.totalMemoryMB ?? 0,
+                        cpuModel: status.cpuModel,
+                    },
+                    localIps: Array.isArray(status.localIps) ? status.localIps : [],
+                    status: {
+                        activeCameras: 0,
+                        cpuPercent: status.cpuPercent ?? 0,
+                        memoryPercent: status.memoryPercent ?? 0,
+                        fps: {},
+                        errors: [],
+                    },
+                    connectedSince: typeof status.uptime === 'number'
+                        ? Date.now() - status.uptime * 1000
+                        : Date.now(),
+                    isHub: false,
+                    subProcesses,
+                    agentAddons,
+                });
+            }
+            catch {
+                // Skip nodes without $agent service
+            }
+        }
+        // TODO(D3 follow-up): offline-agent history dropped with knownAgents.
+        // Previously, agents that disconnected were kept in a shadow map and
+        // surfaced here as offline rows. listNodes now reflects only live
+        // broker.registry nodes.
+        return [hubEntry, ...remoteEntries];
+    }
+    async buildHubEntry(subProcesses = []) {
+        const cpus = os.cpus();
+        // Get live metrics from the metrics-provider capability (NativeMetricsProvider).
+        // The cap contract only exposes async snapshots; the cached read is cheap
+        // because the addon's background sampler keeps the snapshot warm.
+        let cpuPercent = 0;
+        let memoryPercent = 0;
+        const registry = this.capabilityService.getRegistry();
+        if (registry) {
+            const metricsProvider = registry.getSingleton('metrics-provider');
+            if (metricsProvider) {
+                const snapshot = await metricsProvider.getCached();
+                if (snapshot) {
+                    cpuPercent = snapshot.cpu.total;
+                    memoryPercent = snapshot.memory.percent;
+                }
+            }
+        }
+        return {
+            info: {
+                id: 'hub',
+                name: 'Hub',
+                hostname: os.hostname(),
+                capabilities: [],
+                platform: os.platform(),
+                arch: os.arch(),
+                cpuCores: cpus.length,
+                memoryMB: Math.round(os.totalmem() / 1024 / 1024),
+                cpuModel: cpus[0]?.model,
+            },
+            status: {
+                activeCameras: 0,
+                cpuPercent,
+                memoryPercent,
+                fps: {},
+                errors: [],
+            },
+            connectedSince: this.bootTimestamp,
+            isHub: true,
+            subProcesses,
+        };
+    }
+    // ---- Role assignments ----
+    getAssignments(cameraId) {
+        const all = [...this.assignments.values()];
+        if (cameraId !== undefined)
+            return all.filter((a) => a.cameraId === cameraId);
+        return all;
+    }
+    setAssignment(assignment) {
+        const key = `${assignment.cameraId}:${assignment.role}`;
+        this.assignments.set(key, { ...assignment });
+    }
+    removeAssignment(cameraId, role) {
+        const key = `${cameraId}:${role}`;
+        this.assignments.delete(key);
+    }
+    activateBackup(cameraId, role) {
+        const primaryKey = `${cameraId}:${role}`;
+        const primary = this.assignments.get(primaryKey);
+        const backup = [...this.assignments.values()].find((a) => a.cameraId === cameraId && a.role === role && a.priority === 'backup');
+        if (!backup)
+            return;
+        if (primary) {
+            this.assignments.delete(primaryKey);
+        }
+        const promoted = { ...backup, priority: 'primary' };
+        this.assignments.set(primaryKey, promoted);
+        this.eventBus.emit({
+            id: (0, node_crypto_1.randomUUID)(),
+            timestamp: new Date(),
+            source: { type: 'core', id: 'agent-registry' },
+            category: types_1.EventCategory.AgentBackupActivated,
+            data: { cameraId, role, agentId: promoted.agentId },
+        });
+    }
+}
+exports.AgentRegistryService = AgentRegistryService;

package/dist/core/auth/auth.service.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const core_1 = require("@camstack/core");
+class AuthService extends core_1.AuthManager {
+    constructor(config) {
+        super(config);
+    }
+}
+exports.AuthService = AuthService;

package/dist/core/capability/capability.service.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * CapabilityService — NestJS-injectable wrapper around the CapabilityRegistry.
+ *
+ * Server services inject this instead of accessing the registry directly.
+ * The registry reference is set once during boot by AddonRegistryService.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityService = void 0;
+class CapabilityService {
+    registry = null;
+    /** Called once during boot by AddonRegistryService to wire the registry */
+    setRegistry(registry) {
+        this.registry = registry;
+    }
+    /** Get the underlying registry (may be null before boot completes) */
+    getRegistry() {
+        return this.registry;
+    }
+    /** Get the active singleton provider for a capability */
+    getSingleton(capability) {
+        return this.registry?.getSingleton(capability) ?? null;
+    }
+    /**
+     * Resolve the hub-local provider honoring the 'hub' per-node singleton override.
+     * Delegates to `CapabilityRegistry.getSingletonForNode` so the in-process lookup
+     * respects per-node overrides set by the operator.
+     */
+    getSingletonForNode(capability, nodeId) {
+        return this.registry?.getSingletonForNode(capability, nodeId) ?? null;
+    }
+    /** Get the addon ID of the active singleton provider for a capability */
+    getSingletonAddonId(capability) {
+        return this.registry?.getSingletonAddonId(capability) ?? null;
+    }
+    /** Get all active collection providers for a capability */
+    getCollection(capability) {
+        return this.registry?.getCollection(capability) ?? [];
+    }
+    /**
+     * Like {@link getCollection} but returns `[addonId, provider]` tuples
+     * so callers can attribute work back to the contributing addon —
+     * required by the addon-widgets static file route to validate that
+     * the requested `addonId` is a registered widget provider.
+     */
+    getCollectionEntries(capability) {
+        return this.registry?.getCollectionEntries(capability) ?? [];
+    }
+    /** Resolve a singleton provider for a specific device (with per-device override support) */
+    resolveForDevice(capability, deviceId) {
+        return this.registry?.resolveForDevice(capability, deviceId) ?? null;
+    }
+    /** Resolve collection providers for a specific device (with per-device filter support) */
+    resolveCollectionForDevice(capability, deviceId) {
+        return this.registry?.resolveCollectionForDevice(capability, deviceId) ?? [];
+    }
+}
+exports.CapabilityService = CapabilityService;

package/dist/core/config/config.schema.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_DEFAULTS = exports.bootstrapSchema = void 0;
+// Re-export from @camstack/kernel
+var kernel_1 = require("@camstack/kernel");
+Object.defineProperty(exports, "bootstrapSchema", { enumerable: true, get: function () { return kernel_1.bootstrapSchema; } });
+Object.defineProperty(exports, "RUNTIME_DEFAULTS", { enumerable: true, get: function () { return kernel_1.RUNTIME_DEFAULTS; } });

package/dist/core/config/config.service.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = void 0;
+const kernel_1 = require("@camstack/kernel");
+class ConfigService extends kernel_1.ConfigManager {
+    constructor(configPath) {
+        super(configPath);
+    }
+}
+exports.ConfigService = ConfigService;

package/dist/core/events/event-bus.service.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBusService = void 0;
+const kernel_1 = require("@camstack/kernel");
+/**
+ * Hub-side event bus. Pre-broker boot the service buffers nothing —
+ * subscribers / emits are no-ops until `attachBroker` lands the
+ * underlying per-broker shared bus. Once attached every operation
+ * delegates to the unified `getBrokerEventBus(broker)` instance,
+ * which is the SAME bus that group-runner / agent subprocess addons
+ * see when they call `ctx.eventBus.emit`. Single in-process delivery
+ * map per broker, single `broker.broadcast` for cross-broker
+ * delivery — no more dual hub-vs-subprocess implementations.
+ *
+ * **Persistence scope**: the in-memory ring buffer (10 000 events,
+ * owned by `getBrokerEventBus`) survives admin-ui browser refreshes
+ * but NOT server restarts — that's intentional. UI panels read
+ * `getRecent` on mount and live-subscribe via `live.onEvent` /
+ * `systemEvents.subscribe`, which is enough for the operator to see
+ * continuity across page reloads.
+ */
+class EventBusService {
+    broker = null;
+    inner = null;
+    // Used only as a loose ring buffer for the very first events emitted
+    // before `attachBroker` runs (NestJS-era boot legacy). Drained into
+    // the real bus on attach.
+    pending = [];
+    deferredSubs = [];
+    constructor(_configService) {
+        // The shared bus owns the ring-buffer size — hub-side config is
+        // accepted for API compatibility but no longer drives the bus.
+        void _configService;
+    }
+    attachBroker(broker) {
+        if (this.broker === broker)
+            return;
+        this.broker = broker;
+        const inner = (0, kernel_1.getBrokerEventBus)(broker);
+        this.inner = inner;
+        // Replay deferred subscriptions onto the real bus.
+        for (const sub of this.deferredSubs) {
+            sub.unsub = inner.subscribe(sub.filter, sub.handler);
+        }
+        // Flush events emitted before the broker was ready.
+        for (const evt of this.pending) {
+            inner.emit(evt);
+        }
+        this.pending = [];
+    }
+    detachBroker() {
+        for (const sub of this.deferredSubs) {
+            sub.unsub?.();
+            sub.unsub = undefined;
+        }
+        this.broker = null;
+        this.inner = null;
+    }
+    emit(event) {
+        if (!this.inner) {
+            this.pending.push(event);
+            return;
+        }
+        this.inner.emit(event);
+    }
+    subscribe(filter, handler) {
+        if (this.inner)
+            return this.inner.subscribe(filter, handler);
+        const sub = { filter, handler, unsub: undefined };
+        this.deferredSubs.push(sub);
+        return () => {
+            if (sub.unsub)
+                sub.unsub();
+            const idx = this.deferredSubs.indexOf(sub);
+            if (idx >= 0)
+                this.deferredSubs.splice(idx, 1);
+        };
+    }
+    getRecent(filter, limit) {
+        return this.inner?.getRecent(filter, limit) ?? [];
+    }
+}
+exports.EventBusService = EventBusService;

package/dist/core/feature/feature.service.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureService = void 0;
+const core_1 = require("@camstack/core");
+class FeatureService extends core_1.FeatureManager {
+    constructor(configService) {
+        super(configService);
+    }
+}
+exports.FeatureService = FeatureService;

package/dist/core/lifecycle/lifecycle-state-machine.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleStateMachine = void 0;
+// Re-export from @camstack/core — LifecycleStateMachine is already a plain class
+var core_1 = require("@camstack/core");
+Object.defineProperty(exports, "LifecycleStateMachine", { enumerable: true, get: function () { return core_1.LifecycleStateMachine; } });

package/dist/core/logging/log-ring-buffer.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogRingBuffer = void 0;
+// Re-export from @camstack/core
+var core_1 = require("@camstack/core");
+Object.defineProperty(exports, "LogRingBuffer", { enumerable: true, get: function () { return core_1.LogRingBuffer; } });