@vtechcom/hexcore 2.0.0-beta.1

package/dist/hydra/head.service.js

@@ -0,0 +1,1072 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var HeadService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeadService = exports.HeadValidationError = exports.HeadConflictError = exports.HeadNotFoundError = void 0;
+/**
+ * Head lifecycle service.
+ *
+ * Owns the whole "boot N hydra-nodes that form one Head" flow:
+ *   create  -> allocate ports, generate keys, write envelopes, persist rows
+ *   start   -> fetch protocol params, ensure image/network, create N containers
+ *              wired as peers of each other, wait for every node to greet
+ *   stop    -> remove containers, keep keys + persistence
+ *   reset   -> wipe persistence (optionally keys) for a clean restart
+ *
+ * Differences from v1 that matter:
+ *  - keys are generated here, not supplied by the caller
+ *  - ports are deterministic per (head, node index) instead of "scan upward
+ *    from 10005 until something is free", which made peer wiring unpredictable
+ *  - a failed boot rolls back every container it created and records the real
+ *    error on the head row instead of leaving orphans behind
+ */
+const promises_1 = require("node:fs/promises");
+const shared_1 = require("@hexcore/shared");
+const common_1 = require("@nestjs/common");
+const config_module_1 = require("../config.module");
+const repositories_1 = require("../db/repositories");
+const docker_service_1 = require("../docker/docker.service");
+const container_stats_1 = require("../docker/container-stats");
+const capabilities_1 = require("./capabilities");
+const node_monitor_service_1 = require("./node-monitor.service");
+const boot_progress_1 = require("./boot-progress");
+const blockfrost_keys_1 = require("./blockfrost-keys");
+const socket_1 = require("../chain/socket");
+const argv_1 = require("./argv");
+const keys_1 = require("./keys");
+const ws_client_1 = require("./ws-client");
+const provider_1 = require("../chain/provider");
+class HeadNotFoundError extends Error {
+    constructor(id) {
+        super(`Head ${id} not found`);
+        this.name = 'HeadNotFoundError';
+    }
+}
+exports.HeadNotFoundError = HeadNotFoundError;
+class HeadConflictError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'HeadConflictError';
+    }
+}
+exports.HeadConflictError = HeadConflictError;
+/**
+ * A request that is well-formed but cannot be satisfied by THIS server — the
+ * cardano-node socket is missing, or no Blockfrost key exists at any level.
+ * Zod cannot see server state, so these checks live in the service, but they
+ * are field errors to the caller and are reported as such: the create form
+ * highlights the input instead of showing a bare toast.
+ */
+class HeadValidationError extends Error {
+    field;
+    constructor(field, message) {
+        super(message);
+        this.field = field;
+        this.name = 'HeadValidationError';
+    }
+}
+exports.HeadValidationError = HeadValidationError;
+let HeadService = HeadService_1 = class HeadService {
+    config;
+    docker;
+    heads;
+    nodes;
+    events;
+    capabilities;
+    monitor;
+    boot;
+    logger = new common_1.Logger(HeadService_1.name);
+    /** Heads currently being started/stopped — guards against double-boot. */
+    inFlight = new Set();
+    constructor(config, docker, heads, nodes, events, capabilities, monitor, boot) {
+        this.config = config;
+        this.docker = docker;
+        this.heads = heads;
+        this.nodes = nodes;
+        this.events = events;
+        this.capabilities = capabilities;
+        this.monitor = monitor;
+        this.boot = boot;
+    }
+    /**
+     * Adopt reality once, at boot.
+     *
+     * The control-plane can be restarted while heads are up — a deploy, a crash,
+     * a machine reboot — and the status columns only ever recorded what the last
+     * lifecycle call intended. Reconciling here means a head that died while
+     * nothing was watching is already corrected, and its live nodes already have
+     * a monitor connection, before the first request arrives.
+     *
+     * Best effort: Docker being down at boot is not a reason to refuse to start.
+     */
+    onApplicationBootstrap() {
+        void this.reconcile(0).catch((err) => this.logger.warn(`initial reconcile failed: ${err.message}`));
+    }
+    // ---------------------------------------------------------------- queries
+    /** Whether a node with no key of its own would still find one at boot. */
+    get serverKeyConfigured() {
+        return Boolean(this.config.blockfrostProjectId);
+    }
+    async list() {
+        await this.reconcile();
+        return this.heads.list().map(h => (0, repositories_1.toHeadView)(h, this.nodes.byHead(h.id), this.serverKeyConfigured));
+    }
+    async get(id) {
+        await this.reconcile();
+        return this.view(id);
+    }
+    /** Read a head from the DB without reconciling — for callers that just did. */
+    view(id) {
+        const row = this.heads.findById(id);
+        if (!row)
+            throw new HeadNotFoundError(id);
+        return (0, repositories_1.toHeadView)(row, this.nodes.byHead(id), this.serverKeyConfigured);
+    }
+    recentEvents(headId, limit = 100) {
+        return this.events.recent(headId, limit);
+    }
+    // ------------------------------------------------------------- reconcile
+    /** Last reconciliation, so a burst of requests does not hit Docker N times. */
+    lastReconcileAt = 0;
+    reconcileInFlight = null;
+    /**
+     * Make the stored status agree with what Docker actually has.
+     *
+     * The status columns were only ever written by the lifecycle methods, so
+     * they recorded *intent*, not fact: a head whose containers died — OOM, a
+     * daemon restart, `docker rm` by hand — kept reporting RUNNING forever,
+     * because nothing ever looked again. The same gap left a head stuck on
+     * STARTING when the control-plane was restarted mid-boot.
+     *
+     * One `listContainers` call answers for every head, so this is cheap enough
+     * to run on the list and detail endpoints the UI already polls, rather than
+     * on a timer that would keep a laptop awake.
+     *
+     * Two rules keep it from doing harm:
+     *  - **A head with an action in flight is skipped.** Reconciling mid-start
+     *    would race the boot it is watching and mark half-created containers
+     *    failed.
+     *  - **An unreachable Docker changes nothing.** If the daemon is down every
+     *    container looks gone, and writing that would turn a transient outage
+     *    into every head being marked FAILED.
+     */
+    async reconcile(minIntervalMs = 2000) {
+        if (this.reconcileInFlight)
+            return this.reconcileInFlight;
+        if (Date.now() - this.lastReconcileAt < minIntervalMs)
+            return;
+        this.reconcileInFlight = this.runReconcile().finally(() => {
+            this.lastReconcileAt = Date.now();
+            this.reconcileInFlight = null;
+        });
+        return this.reconcileInFlight;
+    }
+    async runReconcile() {
+        let running;
+        try {
+            const containers = await this.docker.listManaged();
+            running = new Set(containers
+                .filter(c => c.State === 'running')
+                .flatMap(c => c.Names ?? [])
+                // Docker returns names with a leading slash.
+                .map(n => n.replace(/^\//, '')));
+        }
+        catch (err) {
+            this.logger.debug(`skipping reconcile — Docker unreachable: ${err.message}`);
+            return;
+        }
+        for (const head of this.heads.list()) {
+            if (this.inFlight.has(head.id))
+                continue;
+            const nodeRows = this.nodes.byHead(head.id);
+            if (nodeRows.length === 0)
+                continue;
+            let up = 0;
+            for (const node of nodeRows) {
+                const isUp = running.has(node.name);
+                if (isUp)
+                    up++;
+                if (isUp) {
+                    // Keep a connection to every node that is actually up, so a
+                    // peer dropping out is observed rather than guessed at.
+                    this.monitor.watch(node.name, node.api_port);
+                    if (node.status !== 'RUNNING')
+                        this.nodes.setStatus(node.id, 'RUNNING', node.container_id);
+                }
+                else {
+                    this.monitor.unwatch(node.name);
+                    // FAILED rather than STOPPED: `stop` sets STOPPED itself, so
+                    // a container that vanished from under a RUNNING row did not
+                    // go away on purpose.
+                    if (node.status === 'RUNNING' || node.status === 'STARTING') {
+                        this.nodes.setStatus(node.id, 'FAILED', null);
+                    }
+                }
+            }
+            this.reconcileHeadStatus(head, nodeRows.length, up);
+        }
+    }
+    /** Head-level verdict from how many of its containers are actually up. */
+    reconcileHeadStatus(head, total, up) {
+        const status = head.status;
+        if (up === 0 && (status === 'RUNNING' || status === 'STARTING')) {
+            const message = status === 'STARTING'
+                ? `Head ${head.id} was left STARTING with no containers running — the start never finished.`
+                : `Head ${head.id} was marked RUNNING but none of its ${total} container(s) are running.`;
+            this.heads.setStatus(head.id, 'FAILED', message);
+            this.heads.setHydraState(head.id, 'UNKNOWN');
+            this.nodes.setStatusForHead(head.id, 'FAILED');
+            this.events.add(head.id, 'head.desynced', message, 'error');
+            this.logger.warn(message);
+            return;
+        }
+        // Containers are up under a head that does not think it is running:
+        // a start that completed after the control-plane went down, or someone
+        // starting the containers by hand. Adopt them rather than showing a
+        // stopped head with live nodes.
+        if (up > 0 && status !== 'RUNNING' && status !== 'STARTING') {
+            const message = `Head ${head.id} has ${up}/${total} container(s) running while marked ${status} — adopted as RUNNING.`;
+            this.heads.setStatus(head.id, 'RUNNING', null);
+            this.events.add(head.id, 'head.desynced', message, 'warn');
+            this.logger.warn(message);
+            return;
+        }
+        // A start that finished while nothing was watching.
+        if (up === total && status === 'STARTING') {
+            this.heads.setStatus(head.id, 'RUNNING', null);
+            this.events.add(head.id, 'head.started', `All ${total} node(s) are up`);
+        }
+    }
+    // ----------------------------------------------------------------- create
+    /**
+     * Allocate the next free block of ports. Each node occupies PORTS_PER_NODE
+     * consecutive numbers, so we simply continue past the highest port in use.
+     */
+    nextSlot() {
+        const max = this.nodes.maxApiPort();
+        if (max === null)
+            return 0;
+        return Math.floor((max - this.config.portBase) / shared_1.PORTS_PER_NODE) + 1;
+    }
+    async create(input) {
+        if (this.heads.findByName(input.name)) {
+            throw new HeadConflictError(`A head named "${input.name}" already exists`);
+        }
+        const network = input.network ?? this.config.network;
+        const chainBackend = input.chainBackend ?? this.config.chainBackend;
+        /**
+         * Refuse a head that could never boot, while the caller is still on the
+         * form and can do something about it.
+         *
+         * Neither credential is required to run the control-plane any more, so
+         * both gaps are possible at once: no node socket, and no Blockfrost key
+         * anywhere. Left to `start`, either one surfaces as a container that
+         * dies during option parsing — a readiness timeout that names nothing.
+         */
+        if (chainBackend === 'offline') {
+            /**
+             * Offline mode needs no credential at all — that is the point of it
+             * — but its node cap is lower, and the schema can only enforce that
+             * when the request names the backend explicitly. A server whose
+             * CHAIN_BACKEND default is `offline` reaches here instead.
+             */
+            if (input.nodeCount > shared_1.MAX_OFFLINE_NODES) {
+                throw new HeadValidationError('nodeCount', `An offline head runs at most ${shared_1.MAX_OFFLINE_NODES} nodes — they all share this machine, ` +
+                    'with no layer 1 to spread the load over.');
+            }
+        }
+        else if (chainBackend === 'cardano-node') {
+            const socket = await (0, socket_1.checkNodeSocket)(this.config.cardanoNodeSocket);
+            if (!socket.available) {
+                throw new HeadValidationError('chainBackend', `cardano-node backend unavailable: ${socket.reason}`);
+            }
+        }
+        else {
+            const nodeKeys = input.nodeBlockfrostProjectIds;
+            const missing = Array.from({ length: input.nodeCount }, (_, i) => (0, blockfrost_keys_1.resolveBlockfrostKey)(nodeKeys?.[i], input.blockfrostProjectId, this.config.blockfrostProjectId)).some(k => k.key === null);
+            if (missing) {
+                throw new HeadValidationError(nodeKeys ? 'nodeBlockfrostProjectIds' : 'blockfrostProjectId', 'A Blockfrost project id is required: this server has no default one configured, ' +
+                    'so every node needs a key. Get a free one at https://blockfrost.io.');
+            }
+        }
+        /**
+         * Parse every supplied Cardano key before writing anything. Creating a
+         * head is a row, N node rows and four files per node — a key that only
+         * fails on the last node would otherwise leave a half-built head behind.
+         */
+        input.nodeCardanoKeys?.forEach((provided, index) => {
+            if (!provided)
+                return;
+            try {
+                (0, keys_1.validateCardanoKeyInput)(provided, network);
+            }
+            catch (err) {
+                throw new HeadValidationError(`nodeCardanoKeys.${index}.signingKey`, `Node ${index}: ${err.message}`);
+            }
+        });
+        const offline = chainBackend === 'offline' ? input.offline : undefined;
+        const logging = input.logging;
+        const headId = this.heads.create({
+            name: input.name,
+            description: input.description ?? null,
+            network,
+            chain_backend: chainBackend,
+            node_count: input.nodeCount,
+            contestation_period: input.contestationPeriod,
+            deposit_period: input.depositPeriod,
+            persistence_rotate_after: input.persistenceRotateAfter,
+            // Stored as given: an empty override object is not the same as no
+            // overrides, and the difference is visible in the head view.
+            protocol_parameters: input.protocolParameters ? JSON.stringify(input.protocolParameters) : null,
+            blockfrost_project_id: input.blockfrostProjectId ?? null,
+            // Pinned per head at creation: a later HYDRA_NODE_IMAGE bump must
+            // not silently move an existing head onto another version, since
+            // 2.x cannot resume persistence written by 0.22.x.
+            hydra_node_image: input.hydraNodeImage ?? this.config.hydraNodeImage,
+            log_quiet: logging?.quiet ? 1 : 0,
+            log_max_size_mb: logging?.maxSizeMb ?? 10,
+            log_max_files: logging?.maxFiles ?? 3,
+            // Filled in below once the row id exists, which is what the default
+            // seed is derived from.
+            offline_head_seed: offline?.headSeed ?? null,
+            offline_initial_utxo: offline?.initialUtxo ? JSON.stringify(offline.initialUtxo) : null,
+            offline_seed_lovelace: chainBackend === 'offline' ? (offline?.seedLovelace ?? shared_1.DEFAULT_OFFLINE_SEED_LOVELACE) : null,
+            offline_ledger_genesis: offline?.ledgerGenesis ? JSON.stringify(offline.ledgerGenesis) : null,
+        });
+        /**
+         * Pin the seed now that the id exists, instead of deriving it on every
+         * start. hydra-node derives the offline head id from this value, so it
+         * has to be stable for the life of the head — and stored, so an
+         * operator can read back what their head is actually keyed on.
+         */
+        if (chainBackend === 'offline' && !offline?.headSeed) {
+            this.heads.update(headId, { offline_head_seed: (0, shared_1.defaultOfflineHeadSeed)(headId) });
+        }
+        const hp = (0, shared_1.headPaths)(this.config.stateDir, headId);
+        await (0, promises_1.mkdir)(hp.keys, { recursive: true });
+        await (0, promises_1.mkdir)(hp.persistence, { recursive: true });
+        const baseSlot = this.nextSlot();
+        for (let i = 0; i < input.nodeCount; i++) {
+            const ports = (0, shared_1.portsForSlot)(baseSlot + i, this.config.portBase);
+            // Generating keys up front means the UI can show fundable addresses
+            // the moment a head is created, before anything is started. A node
+            // may instead bring its own Cardano key, so an already-funded
+            // address can be reused rather than filled from the faucet again.
+            const keys = await (0, keys_1.ensureNodeKeys)(this.config.stateDir, headId, i, network, input.nodeCardanoKeys?.[i] ?? undefined);
+            this.nodes.create({
+                head_id: headId,
+                node_index: i,
+                name: (0, shared_1.nodeContainerName)(headId, i),
+                api_port: ports.api,
+                p2p_port: ports.p2p,
+                monitoring_port: ports.monitoring,
+                hydra_vkey: keys.hydraVk.cborHex,
+                cardano_address: keys.cardanoAddress,
+                // Only stored when it differs from the head's; otherwise the
+                // head's key stays the single place to change it later.
+                blockfrost_project_id: input.nodeBlockfrostProjectIds?.[i] ?? null,
+            });
+        }
+        this.events.add(headId, 'head.created', `Head "${input.name}" created with ${input.nodeCount} node(s)`);
+        this.logger.log(`head ${headId} created with ${input.nodeCount} node(s)`);
+        return this.view(headId);
+    }
+    /** Patch mutable head settings. Takes effect on the next start. */
+    update(id, patch) {
+        const head = this.heads.findById(id);
+        if (!head)
+            throw new HeadNotFoundError(id);
+        if (patch.name && patch.name !== head.name && this.heads.findByName(patch.name)) {
+            throw new HeadConflictError(`A head named "${patch.name}" already exists`);
+        }
+        /**
+         * Swapping the image under a live head would leave the running
+         * containers and the row disagreeing about what is deployed, so it is
+         * only allowed while nothing is up. Even then it is not free: hydra-node
+         * 2.x cannot resume persistence written by 0.22.x (no commit phase,
+         * different event store, different script hashes), so a cross-line
+         * change needs a reset — say so instead of failing at the next start.
+         */
+        const imageChanged = patch.hydraNodeImage !== undefined && patch.hydraNodeImage !== head.hydra_node_image;
+        if (imageChanged && (head.status === 'RUNNING' || head.status === 'STARTING')) {
+            throw new HeadConflictError(`Cannot change the hydra-node image while head ${id} is ${head.status.toLowerCase()}. Stop it first.`);
+        }
+        this.heads.update(id, {
+            ...(patch.name !== undefined ? { name: patch.name } : {}),
+            ...(patch.description !== undefined ? { description: patch.description } : {}),
+            ...(patch.contestationPeriod !== undefined ? { contestation_period: patch.contestationPeriod } : {}),
+            ...(patch.depositPeriod !== undefined ? { deposit_period: patch.depositPeriod } : {}),
+            ...(patch.persistenceRotateAfter !== undefined
+                ? { persistence_rotate_after: patch.persistenceRotateAfter }
+                : {}),
+            ...(patch.protocolParameters !== undefined
+                ? { protocol_parameters: JSON.stringify(patch.protocolParameters) }
+                : {}),
+            ...(patch.blockfrostProjectId !== undefined ? { blockfrost_project_id: patch.blockfrostProjectId } : {}),
+            ...(patch.hydraNodeImage !== undefined ? { hydra_node_image: patch.hydraNodeImage } : {}),
+            ...(patch.logging !== undefined
+                ? {
+                    log_quiet: patch.logging.quiet ? 1 : 0,
+                    log_max_size_mb: patch.logging.maxSizeMb,
+                    log_max_files: patch.logging.maxFiles,
+                }
+                : {}),
+            /**
+             * Offline settings are patchable except the seed, which is left
+             * out on purpose: it determines the offline head id, so changing it
+             * under existing persistence points the node at a head that its own
+             * state does not describe. Recreate the head instead.
+             */
+            ...(patch.offline?.initialUtxo !== undefined
+                ? { offline_initial_utxo: JSON.stringify(patch.offline.initialUtxo) }
+                : {}),
+            ...(patch.offline?.seedLovelace !== undefined ? { offline_seed_lovelace: patch.offline.seedLovelace } : {}),
+            ...(patch.offline?.ledgerGenesis !== undefined
+                ? { offline_ledger_genesis: JSON.stringify(patch.offline.ledgerGenesis) }
+                : {}),
+        });
+        this.events.add(id, 'head.updated', 'Head settings updated');
+        if (imageChanged) {
+            const from = (0, shared_1.findVersionProfile)(head.hydra_node_image);
+            const to = (0, shared_1.findVersionProfile)(patch.hydraNodeImage);
+            const crossLine = from?.id !== to?.id;
+            this.events.add(id, 'head.image_changed', `hydra-node image ${head.hydra_node_image} → ${patch.hydraNodeImage}` +
+                (crossLine ? ' — reset this head before starting; its persistence is not portable' : ''), crossLine ? 'warn' : 'info');
+        }
+        return this.view(id);
+    }
+    // ------------------------------------------------------------------ start
+    async start(id) {
+        const head = this.heads.findById(id);
+        if (!head)
+            throw new HeadNotFoundError(id);
+        if (this.inFlight.has(id))
+            throw new HeadConflictError(`Head ${id} is already starting or stopping`);
+        const nodeRows = this.nodes.byHead(id);
+        if (nodeRows.length === 0)
+            throw new HeadConflictError(`Head ${id} has no nodes`);
+        const runningNow = this.nodes.countRunning();
+        if (runningNow + nodeRows.length > this.config.maxActiveNodes) {
+            throw new HeadConflictError(`Starting this head would exceed MAX_ACTIVE_NODES (${this.config.maxActiveNodes}). ` +
+                `Currently running: ${runningNow}, this head needs ${nodeRows.length}.`);
+        }
+        this.inFlight.add(id);
+        this.heads.setStatus(id, 'STARTING');
+        this.nodes.setStatusForHead(id, 'STARTING');
+        this.events.add(id, 'head.starting', `Starting ${nodeRows.length} node(s)`);
+        /**
+         * The live view of this boot, polled by the UI while the POST is still
+         * in flight. Starting a head is six phases and the image pull alone can
+         * run for minutes; a spinner over all of it says nothing about whether
+         * anything is happening, and on failure the single error left on the row
+         * is usually the last symptom rather than the cause.
+         */
+        const run = this.boot.begin(id);
+        run.log(`Starting ${nodeRows.length} node(s) on ${head.hydra_node_image}`);
+        const created = [];
+        try {
+            run.step('docker');
+            await this.docker.ping();
+            await this.docker.ensureNetwork();
+            run.step('image');
+            if (await this.docker.hasImage(head.hydra_node_image)) {
+                run.detail('image', 'already present');
+            }
+            else {
+                // A first pull is the longest part of a cold start by far, and
+                // the only one worth streaming: without it the operator cannot
+                // tell a slow download from a stuck one.
+                run.detail('image', 'pulling — this is the slow part of a first run');
+                await this.docker.ensureImage(head.hydra_node_image, line => run.detail('image', line));
+                run.detail('image', 'pulled');
+            }
+            // Settle which flags this image accepts before building any argv:
+            // an unknown flag aborts hydra-node during option parsing, and the
+            // resulting container death reads as a generic readiness timeout.
+            // A declared version profile answers it; anything else is probed.
+            run.step('flags');
+            const resolved = await this.capabilities.resolve(head.hydra_node_image, this.config.hydraArgOverrides);
+            this.logger.log(`head ${id}: ${head.hydra_node_image} → ${resolved.caps.version} ` +
+                `(${resolved.source}${resolved.profileId ? ` ${resolved.profileId}` : ''})`);
+            run.detail('flags', `${resolved.caps.version} (${resolved.source})`);
+            run.log(`Flags settled from the ${resolved.source}: ${resolved.caps.version}`);
+            const hp = (0, shared_1.headPaths)(this.config.stateDir, id);
+            await (0, promises_1.mkdir)(hp.persistence, { recursive: true });
+            /**
+             * Re-check the backend's credential here as well as at creation:
+             * a socket can disappear with the node that owned it, and a head
+             * created while one existed would otherwise boot into containers
+             * that die during option parsing.
+             */
+            if (head.chain_backend === 'cardano-node') {
+                const socket = await (0, socket_1.checkNodeSocket)(this.config.cardanoNodeSocket);
+                if (!socket.available) {
+                    throw new Error(`cardano-node backend unavailable: ${socket.reason}. ` +
+                        'Fix CARDANO_NODE_SOCKET, or recreate this head on the Blockfrost backend.');
+                }
+            }
+            /**
+             * Warn about upstream defects this version carries on this backend.
+             *
+             * Recorded as an event, not just logged: the create form shows the
+             * same warning, but a head created through the API never saw it, and
+             * the image cannot be changed later without resetting the head. This
+             * is the last point where someone can still see it.
+             */
+            for (const issue of (0, shared_1.knownIssuesFor)(head.hydra_node_image, head.chain_backend, (0, shared_1.toHostPlatform)(process.platform, process.arch))) {
+                const message = 
+                // Not every issue has an upstream number — an image built
+                // for the wrong architecture is not a bug in the node.
+                `${head.hydra_node_image}: ${issue.title}${issue.id ? ` (hydra#${issue.id})` : ''}. ` +
+                    `${issue.impact}` +
+                    (issue.fixedIn ? ` Fixed in hydra-node ${issue.fixedIn}.` : ` See ${issue.url}`);
+                this.events.add(id, 'head.known_issue', message, issue.severity === 'blocker' ? 'warn' : 'info');
+                this.logger.warn(`head ${id}: ${message}`);
+                run.log(message, 'warn');
+            }
+            /**
+             * An image with no offline branch cannot run this head at all —
+             * there is no online argv to fall back to, since the head has no
+             * credential for either backend. Better a named error here than a
+             * container that dies in option parsing.
+             */
+            if (head.chain_backend === 'offline' && !resolved.caps.offline) {
+                throw new Error(`${head.hydra_node_image} does not support offline mode (no --offline-head-seed). ` +
+                    'Use a hydra-node image that does, or recreate this head on a chain backend.');
+            }
+            run.step('config');
+            // Resolved once and reused: the protocol parameters fetch and each
+            // node's token file must not disagree about which key is in play.
+            const nodeKeys = new Map(nodeRows.map(node => [
+                node.node_index,
+                (0, blockfrost_keys_1.resolveBlockfrostKey)(node.blockfrost_project_id, head.blockfrost_project_id, this.config.blockfrostProjectId),
+            ]));
+            /**
+             * Protocol parameters for the L2 ledger. Read over Blockfrost even
+             * for a cardano-node head, so any key that resolves will do — but
+             * NOT for an offline head: one that reached out to Blockfrost at
+             * start would fail on a machine with no network, which is exactly
+             * where offline mode is worth having. It gets the static baseline,
+             * which now carries real cost models (see chain/cost-models.ts).
+             *
+             * Whatever the source, the head's own overrides are merged last, so
+             * a pinned parameter survives an epoch that moves the live value.
+             */
+            const overrides = head.protocol_parameters
+                ? JSON.parse(head.protocol_parameters)
+                : undefined;
+            const params = await (0, provider_1.fetchProtocolParameters)({
+                network: head.network,
+                projectId: head.chain_backend === 'offline'
+                    ? ''
+                    : nodeKeys.get(nodeRows[0].node_index)?.key ||
+                        head.blockfrost_project_id ||
+                        this.config.blockfrostProjectId,
+                baseUrl: this.config.blockfrostBaseUrl,
+                overrides,
+            });
+            await (0, promises_1.writeFile)(hp.protocolParameters, JSON.stringify(params, null, 2), 'utf8');
+            run.log(head.chain_backend === 'offline'
+                ? 'Protocol parameters written from the built-in baseline'
+                : 'Protocol parameters written from the chain');
+            if (head.chain_backend === 'offline') {
+                await this.writeOfflineFiles(head, nodeRows);
+                run.log('Offline starting UTxO written');
+            }
+            /**
+             * One token file per node, read by hydra-node with `--blockfrost`.
+             * Nodes sharing a key just get identical contents; a node with its
+             * own key gets its own budget, which is the point of allowing it.
+             */
+            if (head.chain_backend === 'blockfrost') {
+                for (const node of nodeRows) {
+                    const { key } = nodeKeys.get(node.node_index);
+                    if (!key) {
+                        throw new Error(`${node.name} has no Blockfrost project id, and neither the head nor the ` +
+                            'server supplies one. Set BLOCKFROST_PROJECT_ID or recreate the head with a key.');
+                    }
+                    await (0, promises_1.writeFile)(hp.nodeBlockfrostToken(node.node_index), key, {
+                        encoding: 'utf8',
+                        mode: 0o600,
+                    });
+                }
+                // Heads created before per-node keys left one shared file here;
+                // nothing reads it now, so do not leave a project id on disk.
+                await (0, promises_1.rm)(hp.legacyBlockfrostToken, { force: true });
+            }
+            for (const node of nodeRows) {
+                await (0, promises_1.mkdir)(hp.nodePersistence(node.node_index), { recursive: true });
+                await (0, keys_1.ensureNodeKeys)(this.config.stateDir, id, node.node_index, head.network);
+            }
+            run.step('containers', `0/${nodeRows.length} created`);
+            for (const node of nodeRows) {
+                const peers = nodeRows.filter(n => n.id !== node.id);
+                const cmd = this.buildNodeCommand(head, node, peers, resolved);
+                const container = await this.docker.createAndStart({
+                    name: node.name,
+                    image: head.hydra_node_image,
+                    cmd,
+                    binds: this.buildBinds(head),
+                    ports: [node.api_port, node.p2p_port, node.monitoring_port],
+                    labels: this.docker.labelsFor(id, node.id, node.node_index),
+                    // Docker's json-file driver is unbounded by default, so a
+                    // head left running writes logs until the disk fills.
+                    logRotation: { maxSizeMb: head.log_max_size_mb, maxFiles: head.log_max_files },
+                    env: [
+                        'ETCD_AUTO_COMPACTION_MODE=periodic',
+                        'ETCD_AUTO_COMPACTION_RETENTION=168h',
+                        'ETCD_HEARTBEAT_INTERVAL=1000',
+                        'ETCD_ELECTION_TIMEOUT=5000',
+                    ],
+                });
+                created.push(node.name);
+                this.nodes.setStatus(node.id, 'STARTING', container.id);
+                run.detail('containers', `${created.length}/${nodeRows.length} created`);
+                run.log(`${node.name} created on api ${node.api_port}`);
+            }
+            // Wait for every node to answer on its API port.
+            run.step('ready', `0/${nodeRows.length} ready`);
+            const ports = nodeRows.map(n => n.api_port);
+            const results = await (0, ws_client_1.waitForNodes)(ports, {
+                timeoutMs: 180_000,
+                onProgress: (ready, total) => {
+                    this.logger.log(`head ${id}: ${ready}/${total} nodes ready`);
+                    run.detail('ready', `${ready}/${total} ready`);
+                },
+                /**
+                 * Pull what the containers have printed on every poll. This is
+                 * the part that turns "node never became ready" into an answer:
+                 * hydra-node explains its own refusals — an unknown flag, a key
+                 * it cannot read, a chain it cannot reach — and until now none
+                 * of that reached anyone watching the head come up.
+                 */
+                onTick: () => this.collectBootLogs(run, nodeRows),
+            });
+            // One last sweep, so whatever a node printed just before giving up
+            // is in the pane the operator is about to read.
+            await this.collectBootLogs(run, nodeRows);
+            const unreachable = nodeRows.filter(n => !results.get(n.api_port)?.reachable);
+            if (unreachable.length > 0) {
+                const detail = unreachable
+                    .map(n => `${n.name} (port ${n.api_port}): ${results.get(n.api_port)?.error ?? 'no response'}`)
+                    .join('; ');
+                throw new Error(`Node(s) never became ready — ${detail}`);
+            }
+            for (const node of nodeRows) {
+                this.nodes.setStatus(node.id, 'RUNNING', node.container_id);
+                // Hold a connection open from here on: a peer dropping out later
+                // is announced as an event, and nothing that connects after the
+                // fact can see it.
+                this.monitor.watch(node.name, node.api_port);
+            }
+            const state = (0, ws_client_1.aggregateHydraState)(nodeRows.map(n => results.get(n.api_port)?.info?.hydraState ?? 'UNKNOWN'));
+            this.heads.setStatus(id, 'RUNNING', null);
+            this.heads.setHydraState(id, state);
+            this.events.add(id, 'head.started', `All ${nodeRows.length} node(s) ready (state ${state})`);
+            this.logger.log(`head ${id} running (state ${state})`);
+            run.succeed(`All ${nodeRows.length} node(s) ready (Hydra state ${state})`);
+            return this.view(id);
+        }
+        catch (err) {
+            const message = err.message;
+            this.logger.error(`head ${id} start failed — rolling back: ${message}`);
+            /**
+             * Fail the run BEFORE the rollback removes the containers: the pane
+             * is the only place their output survives, and it is what turns a
+             * readiness timeout into a reason.
+             */
+            run.fail(message);
+            // Roll back every container we created so a retry starts clean.
+            for (const name of created) {
+                this.monitor.unwatch(name);
+                await this.docker.removeContainer(name);
+            }
+            run.log(`Rolled back ${created.length} container(s) so a retry starts clean`, 'warn');
+            this.nodes.setStatusForHead(id, 'FAILED');
+            this.heads.setStatus(id, 'FAILED', message);
+            this.events.add(id, 'head.failed', message, 'error');
+            throw err;
+        }
+        finally {
+            this.inFlight.delete(id);
+        }
+    }
+    // ------------------------------------------------------------------- stop
+    async stop(id) {
+        const head = this.heads.findById(id);
+        if (!head)
+            throw new HeadNotFoundError(id);
+        if (this.inFlight.has(id))
+            throw new HeadConflictError(`Head ${id} is busy`);
+        this.inFlight.add(id);
+        try {
+            for (const node of this.nodes.byHead(id)) {
+                // Drop the connection before the container goes, so its close
+                // does not read as a node that failed on its own.
+                this.monitor.unwatch(node.name);
+                await this.docker.removeContainer(node.name);
+                this.nodes.setStatus(node.id, 'STOPPED', null);
+            }
+            this.heads.setStatus(id, 'STOPPED', null);
+            this.heads.setHydraState(id, 'UNKNOWN');
+            this.events.add(id, 'head.stopped', 'Head stopped');
+            return this.view(id);
+        }
+        finally {
+            this.inFlight.delete(id);
+        }
+    }
+    async restart(id) {
+        await this.stop(id);
+        return this.start(id);
+    }
+    /**
+     * Wipe the head's persistence so the next start begins from a fresh Hydra
+     * state. In v1 this was the only way out of a corrupted head, but it was a
+     * manual `rm -rf` on the server.
+     */
+    async reset(id, includeKeys = false) {
+        const head = this.heads.findById(id);
+        if (!head)
+            throw new HeadNotFoundError(id);
+        if (head.status === 'RUNNING' || head.status === 'STARTING') {
+            throw new HeadConflictError('Stop the head before resetting it');
+        }
+        const hp = (0, shared_1.headPaths)(this.config.stateDir, id);
+        await (0, promises_1.rm)(hp.persistence, { recursive: true, force: true });
+        await (0, promises_1.mkdir)(hp.persistence, { recursive: true });
+        if (includeKeys) {
+            await (0, promises_1.rm)(hp.keys, { recursive: true, force: true });
+            await (0, promises_1.mkdir)(hp.keys, { recursive: true });
+            for (const node of this.nodes.byHead(id)) {
+                const keys = await (0, keys_1.ensureNodeKeys)(this.config.stateDir, id, node.node_index, head.network);
+                // New keys mean new addresses — the UI must show the fresh ones.
+                this.nodes.setStatus(node.id, 'CREATED', null);
+                this.nodes.setIdentity(node.id, keys.hydraVk.cborHex, keys.cardanoAddress);
+            }
+        }
+        this.heads.setStatus(id, 'CONFIGURED', null);
+        this.heads.setHydraState(id, 'UNKNOWN');
+        this.events.add(id, 'head.reset', includeKeys ? 'Persistence and keys wiped' : 'Persistence wiped');
+        return this.view(id);
+    }
+    async delete(id) {
+        const head = this.heads.findById(id);
+        if (!head)
+            throw new HeadNotFoundError(id);
+        /**
+         * A start in flight is still creating containers and, on failure, rolls
+         * back by name. Deleting underneath it would race that rollback and
+         * leave containers whose head row is already gone — unreachable from
+         * the UI and only removable by hand.
+         */
+        if (this.inFlight.has(id)) {
+            throw new HeadConflictError(`Head ${id} is starting or stopping — wait for that to finish first`);
+        }
+        for (const node of this.nodes.byHead(id)) {
+            this.monitor.unwatch(node.name);
+            await this.docker.removeContainer(node.name);
+        }
+        await (0, promises_1.rm)((0, shared_1.headPaths)(this.config.stateDir, id).root, { recursive: true, force: true });
+        this.heads.delete(id);
+        this.events.add(null, 'head.deleted', `Head ${id} ("${head.name}") deleted`);
+    }
+    // ----------------------------------------------------------------- status
+    /**
+     * Live status of a head.
+     *
+     * Three sources, and each answers something the others cannot:
+     *  - **Docker** says whether the container exists and runs. A node that is
+     *    simply gone is a different failure from one that is up but silent, and
+     *    treating them the same is what let a dead head report RUNNING.
+     *  - **The monitor's open connection** carries the node's own view, folded
+     *    from its event stream — including the connectivity events (a peer
+     *    dropping out) that nothing can observe after the fact.
+     *  - **A one-shot probe**, only as a fallback for a node the monitor has not
+     *    heard from yet, so a status request right after a start still answers.
+     */
+    async liveStatus(id) {
+        await this.reconcile();
+        const head = this.heads.findById(id);
+        if (!head)
+            throw new HeadNotFoundError(id);
+        const rows = this.nodes.byHead(id);
+        const nodes = await Promise.all(rows.map(async (row) => {
+            const containerRunning = await this.docker.isRunning(row.name);
+            const base = { nodeId: row.id, name: row.name, containerRunning };
+            if (!containerRunning) {
+                return {
+                    ...base,
+                    reachable: false,
+                    hydraState: 'UNKNOWN',
+                    error: 'container not running',
+                };
+            }
+            const live = this.monitor.stateFor(row.name);
+            if (live?.connected) {
+                return {
+                    ...base,
+                    reachable: true,
+                    hydraState: live.hydraState,
+                    version: live.version ?? undefined,
+                    snapshotUtxoCount: live.snapshotUtxoCount ?? undefined,
+                    peersDown: [...live.peersDown],
+                    networkConnected: live.networkConnected ?? undefined,
+                    chainSynced: live.chainSynced ?? undefined,
+                    headId: live.headId ?? undefined,
+                    lastMessageAt: live.lastMessageAt ?? undefined,
+                };
+            }
+            // The container is up but our connection is not — either it just
+            // started, or the API is not answering. A probe distinguishes
+            // those two, which the monitor alone cannot.
+            const probe = await (0, ws_client_1.probeNode)(row.api_port, 5000);
+            return {
+                ...base,
+                reachable: probe.reachable,
+                hydraState: probe.info?.hydraState ?? 'UNKNOWN',
+                version: probe.info?.version,
+                snapshotUtxoCount: probe.info?.snapshotUtxoCount,
+                headId: probe.info?.headId,
+                chainSynced: probe.info?.chainSynced,
+                error: probe.error ?? live?.lastError ?? undefined,
+            };
+        }));
+        const state = (0, ws_client_1.aggregateHydraState)(nodes.map(n => n.hydraState));
+        if (state !== head.hydra_state)
+            this.heads.setHydraState(id, state);
+        const containersRunning = nodes.filter(n => n.containerRunning).length;
+        const { degraded, degradedReasons } = this.describeHealth(head.status, nodes, containersRunning);
+        return {
+            headId: id,
+            status: head.status,
+            hydraState: state,
+            nodes,
+            checkedAt: new Date().toISOString(),
+            degraded,
+            degradedReasons,
+            containersRunning,
+        };
+    }
+    /**
+     * Is the head whole, and if not, what is missing.
+     *
+     * Kept off `status` on purpose. A three-node head with one node down is
+     * still RUNNING and still serving the other two — but a head that is short a
+     * party cannot reach consensus on a snapshot, so reporting it as plain
+     * "running" is how a half-dead head goes unnoticed until someone asks why
+     * nothing confirms.
+     *
+     * Only meaningful for a head that is supposed to be up; a STOPPED head is
+     * not degraded, it is stopped.
+     */
+    describeHealth(status, nodes, containersRunning) {
+        if (status !== 'RUNNING' && status !== 'STARTING')
+            return { degraded: false, degradedReasons: [] };
+        const reasons = [];
+        const missing = nodes.filter(n => !n.containerRunning);
+        if (missing.length > 0) {
+            reasons.push(`${missing.length} of ${nodes.length} container(s) not running: ${missing.map(n => n.name).join(', ')}`);
+        }
+        const silent = nodes.filter(n => n.containerRunning && !n.reachable);
+        if (silent.length > 0) {
+            reasons.push(`${silent.map(n => n.name).join(', ')} running but not answering the Hydra API`);
+        }
+        /**
+         * The signal a peer dropping out actually produces. The head's own state
+         * stays Open — losing a peer is a connectivity fact, not a protocol
+         * transition — so `GET /head` will never report this and only the
+         * surviving nodes' event streams can.
+         */
+        const isolated = nodes.filter(n => n.reachable && n.networkConnected === false);
+        if (isolated.length > 0) {
+            reasons.push(`${isolated.map(n => n.name).join(', ')} lost the Hydra network — a peer is unreachable`);
+        }
+        /**
+         * Peers a node told us went away. Only departures are tracked — the
+         * connections that predate our own are never replayed to us — so a
+         * non-empty list is a fact, while an empty one only means nothing has
+         * been reported. See NodeLiveStatus.peersDown.
+         */
+        const lostPeers = nodes.filter(n => (n.peersDown?.length ?? 0) > 0);
+        if (lostPeers.length > 0) {
+            reasons.push(lostPeers.map(n => `${n.name} lost peer(s) ${n.peersDown.join(', ')}`).join('; '));
+        }
+        const behind = nodes.filter(n => n.chainSynced === 'CatchingUp');
+        if (behind.length > 0) {
+            reasons.push(`${behind.map(n => n.name).join(', ')} is catching up with the chain`);
+        }
+        return { degraded: reasons.length > 0 || containersRunning < nodes.length, degradedReasons: reasons };
+    }
+    /**
+     * What this head is costing the machine right now.
+     *
+     * Sampled for every node in one call rather than per node, because the
+     * question this answers is a head-level one: docs/PRODUCT.md sizes the
+     * node-count ceilings on roughly 500 MB per hydra-node at peak, and an
+     * offline head runs up to five of them side by side on the one machine. A
+     * per-node figure cannot be checked against that budget; the total can.
+     *
+     * Nodes are sampled in parallel and one failure does not sink the rest —
+     * a container removed between the row read and the sample is reported as
+     * not running, which is exactly what it is.
+     */
+    async resourceUsage(id) {
+        const head = this.heads.findById(id);
+        if (!head)
+            throw new HeadNotFoundError(id);
+        const sampledAt = new Date().toISOString();
+        const nodes = await Promise.all(this.nodes.byHead(id).map(async (row) => {
+            const base = { nodeId: row.id, name: row.name, sampledAt };
+            try {
+                const raw = await this.docker.stats(row.name);
+                if (!raw)
+                    return { ...base, running: false, ...(0, container_stats_1.emptyUsage)() };
+                return { ...base, running: true, ...(0, container_stats_1.readContainerStats)(raw) };
+            }
+            catch (err) {
+                // Docker being unreachable must not turn a status pane into
+                // an error page — the head view above it still works.
+                this.logger.debug(`stats for ${row.name} failed: ${err.message}`);
+                return { ...base, running: false, ...(0, container_stats_1.emptyUsage)() };
+            }
+        }));
+        const running = nodes.filter(n => n.running);
+        const sum = (pick) => {
+            const values = running.map(pick).filter((v) => v !== null);
+            return values.length > 0 ? values.reduce((a, b) => a + b, 0) : null;
+        };
+        return {
+            headId: id,
+            nodes,
+            totalMemoryBytes: sum(n => n.memoryBytes),
+            totalCpuPercent: sum(n => n.cpuPercent),
+            sampledAt,
+        };
+    }
+    async nodeLogs(headId, nodeIndex, tail = 200) {
+        const node = this.nodes.byHead(headId).find(n => n.node_index === nodeIndex);
+        if (!node)
+            throw new HeadNotFoundError(headId);
+        return this.docker.logs(node.name, tail);
+    }
+    // ---------------------------------------------------------------- private
+    /**
+     * The two files an offline head boots from.
+     *
+     * `--initial-utxo` is the L2 ledger's entire starting state — there is no
+     * chain to commit from, so whatever is in this file is all the head will
+     * ever hold. Written fresh on every start so an edited seed amount takes
+     * effect after a reset, and so the addresses follow a `reset --includeKeys`
+     * that changed them.
+     *
+     * `--ledger-genesis` is only written when the operator supplied one.
+     * hydra-node's own default is to run without it, and a hand-built partial
+     * genesis fails to decode and kills the node during startup — so an absent
+     * genesis stays absent rather than being invented.
+     */
+    async writeOfflineFiles(head, nodeRows) {
+        const hp = (0, shared_1.headPaths)(this.config.stateDir, head.id);
+        let utxo;
+        if (head.offline_initial_utxo) {
+            utxo = JSON.parse(head.offline_initial_utxo);
+        }
+        else {
+            // Seeding the nodes' OWN addresses is what makes the default useful:
+            // the operator already holds those signing keys, so everything in
+            // the head is spendable without importing anything.
+            const funded = nodeRows.filter(n => n.cardano_address);
+            if (funded.length === 0) {
+                throw new Error(`Head ${head.id} has no Cardano address to seed its offline UTxO with. ` +
+                    'Reset the head with key regeneration, or supply an initial UTxO explicitly.');
+            }
+            utxo = (0, shared_1.buildInitialUtxo)(funded.map(n => ({
+                address: n.cardano_address,
+                lovelace: head.offline_seed_lovelace ?? shared_1.DEFAULT_OFFLINE_SEED_LOVELACE,
+            })));
+        }
+        await (0, promises_1.writeFile)(hp.initialUtxo, JSON.stringify(utxo, null, 2), 'utf8');
+        if (head.offline_ledger_genesis) {
+            await (0, promises_1.writeFile)(hp.ledgerGenesis, head.offline_ledger_genesis, 'utf8');
+        }
+        else {
+            // A file left behind by a head that used to have one would still be
+            // found by the flag if it were ever re-enabled.
+            await (0, promises_1.rm)(hp.ledgerGenesis, { force: true });
+        }
+    }
+    /**
+     * Pull each container's recent output into the boot pane.
+     *
+     * Best effort by design: a container that has not been created yet, or has
+     * already died, answers with nothing useful, and a logging failure must
+     * never be the reason a head fails to start.
+     */
+    async collectBootLogs(run, nodeRows) {
+        await Promise.all(nodeRows.map(async (node) => {
+            try {
+                const logs = await this.docker.logs(node.name, 40);
+                if (logs)
+                    run.appendContainerLogs(node.name, logs);
+            }
+            catch {
+                /* the container is not up yet, or is already gone */
+            }
+        }));
+    }
+    /** Live progress of the current or last boot, for the UI to poll. */
+    bootProgress(id) {
+        if (!this.heads.findById(id))
+            throw new HeadNotFoundError(id);
+        return this.boot.get(id) ?? null;
+    }
+    buildBinds(head) {
+        const binds = [`${this.config.stateDir}:/data`];
+        if (head.chain_backend === 'cardano-node' && this.config.cardanoNodeSocket) {
+            binds.push(`${this.config.cardanoNodeSocket}:/cardano-node/node.socket`);
+        }
+        return binds;
+    }
+    /**
+     * Assemble the hydra-node argv.
+     *
+     * Delegates to the pure builders in argv.ts so the exact flag set can be
+     * asserted in tests without Docker or a Blockfrost key. `resolved.caps`
+     * gates the flags that only exist on newer images, and `resolved.args`
+     * carries the values that version wants — see capabilities.ts.
+     */
+    buildNodeCommand(head, node, peers, resolved) {
+        return (0, argv_1.buildNodeArgv)(head, node, peers, {
+            caps: resolved.caps,
+            hydraScriptsTxId: this.config.hydraScriptsTxId,
+            unsyncedPeriod: resolved.args.unsyncedPeriod,
+            blockfrostQueryTimeout: resolved.args.blockfrostQueryTimeout,
+            blockfrostRetryTimeout: resolved.args.blockfrostRetryTimeout,
+            extraArgs: resolved.args.extraArgs,
+        });
+    }
+};
+exports.HeadService = HeadService;
+exports.HeadService = HeadService = HeadService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(config_module_1.APP_CONFIG)),
+    __metadata("design:paramtypes", [Object, docker_service_1.DockerService,
+        repositories_1.HeadRepository,
+        repositories_1.NodeRepository,
+        repositories_1.EventRepository,
+        capabilities_1.NodeCapabilitiesService,
+        node_monitor_service_1.NodeMonitorService,
+        boot_progress_1.BootTracker])
+], HeadService);
+//# sourceMappingURL=head.service.js.map