@qvac/core 0.0.0 → 0.1.0

package/dist-lib/lib/core.js

@@ -0,0 +1,2126 @@
+import BlindPeering from 'blind-peering';
+import Corestore from 'corestore';
+import CorestoreStorage from 'hypercore-storage';
+import { constants as RocksConstants } from 'rocksdb-native';
+import Rache from 'rache';
+import Hyperswarm from 'hyperswarm';
+import Wakeup from 'protomux-wakeup';
+import Top from 'process-top';
+import ReadyGuard from 'ready-guard';
+import ReadyResource from 'ready-resource';
+import ScopeLock from 'scope-lock';
+import { createApi } from "./api/index.js";
+import { BLIND_PEER_KEYS, BLIND_RELAY_KEYS } from "./core/blind-peers.js";
+import { CoreBlobServer, MemoryVectorIndex } from "./core/files/index.js";
+import { removeChatAttachments, removeChatKnowledge } from "./core/chat.js";
+import { createFsDriveHost } from "./core/fs-drives.js";
+import { sweepDriveStaging } from "./fs-drive-bridge.js";
+import { closeCollaboraWorker } from "./collabora/worker.js";
+import { decodeMeshInvite, encodeMeshInvite } from "./core/invite.js";
+import { openLocalStore } from "./core/local/index.js";
+import { getAgent } from "./core/agent.js";
+import { HostedAgents } from "./core/hosted-agents.js";
+import { SecretHandoff } from "./core/secret-handoff.js";
+import { SkillOverlayHandoff } from "./core/skill-overlay-handoff.js";
+import { createSkillOverlayReceiver } from "./core/skill-overlay-receiver.js";
+import { createSkillSecretReceiver, HOST_REVOKED, NO_SUCH_AGENT, NOT_THE_HOST } from "./core/skill-secrets.js";
+import { attestUnattestedDevices } from "./core/membership.js";
+import { runMigrations } from "./core/migrations/index.js";
+import { advertiseDeviceVersion } from "./core/devices.js";
+import { OtaConfigReader, configCoreFor, resolveConfigChannel, vendoredMinSupportedVersion } from "./core/ota-config.js";
+import { updateRequired } from "./core/min-version.js";
+import { PendingDepartures } from "./core/departures.js";
+import { Mesh } from "./core/mesh.js";
+import { raceResource } from "./race-resource.js";
+import { createSystemInfoSampler } from "./core/system-info.js";
+import { oauthStateKeyFor } from "./credential-pusher.js";
+import { setLogger } from "./logger.js";
+import { settleOnClose } from '@qvac/harness/rpc';
+import { openLocalSpec } from "./spec-loader.js";
+import { unref } from "./unref.js";
+import { local } from '../spec/index.js';
+const QvacState = local.getEnum('@local/qvac-state');
+const top = new Top();
+const SWARM_KEYPAIR_NAME = 'qvac-swarm-keypair';
+const QVAC_CORE_NAMESPACE = 'qvac-core';
+const MESH_JOIN_CANCELED = 'Mesh join canceled';
+const MESH_BELOW_FLOOR = 'Build is below the mesh floor';
+const INVITE_DHT_NODES_LIMIT = 3;
+const INVITE_BLIND_PEERS_LIMIT = 3;
+const DIAGNOSTICS_SAMPLE_MS = 2000;
+export class Core extends ReadyResource {
+    _storagePath;
+    store;
+    rootCorestore;
+    storage;
+    local;
+    state;
+    _transport;
+    _apiLifecycle;
+    _log;
+    _spec;
+    _bootstrapNodes;
+    _device;
+    _app;
+    _minSupportedVersion;
+    _otaConfigCore;
+    _otaConfig = null;
+    _configPeering = null;
+    _localDevice;
+    _blindPeerKeys;
+    _blindPeeringOpts;
+    _meshSeed;
+    _meshKey;
+    _additionalNodes;
+    _listModels;
+    _deleteModel;
+    _clearKvCache;
+    _deleteChatKvCache;
+    _compactChat;
+    _modelCatalogWatch;
+    _modelCatalogWatchSource = new ReadyGuard();
+    _retryModelDownload;
+    _transcribe;
+    _speak;
+    _speakStream;
+    _embedder;
+    _ragExtractors;
+    _indexedEmbedder = null;
+    _indexingLock = new ScopeLock();
+    _meshTransitionLock = new ScopeLock();
+    _processingFiles;
+    _skills;
+    _skillCatalog;
+    _skillManagement;
+    _catalogHooks = new ReadyGuard();
+    _tools;
+    _hostsModelSource;
+    _vectorIndex;
+    _closeSignal;
+    _signalClose;
+    _closeListeners;
+    _closeSignaled;
+    _mesh;
+    _offlineBoot = new ReadyGuard();
+    onlineBoot = new ReadyGuard();
+    _candidateMesh;
+    _cancelCandidateJoin;
+    _joinCancellation;
+    _meshSecretSeed;
+    _rpcs = new Set();
+    _stream;
+    _api;
+    _clients;
+    _deviceKeyPair;
+    _memberLock = new ScopeLock({ debounce: true });
+    _identityPhrase = null;
+    _identityPublicKey = null;
+    _swarm;
+    _departures = null;
+    _fsDrives = null;
+    _blobServer = null;
+    _attachmentUrl = (attachment) => this._blobServer?.link(attachment) ?? null;
+    _wakeup;
+    _secretHandoff;
+    _skillOverlayHandoff;
+    _hostedAgents;
+    _minting;
+    _leaving;
+    _kicked;
+    _kickedPending;
+    _peers;
+    _statusListeners;
+    _diagnosticsProviders;
+    _systemInfo;
+    _onMeshWritable;
+    _onMeshDead;
+    _onMeshStalled;
+    _statusError;
+    _upgradeRequired;
+    constructor(transport, { storagePath, logger = null, spec = openLocalSpec, bootstrapNodes = undefined, device = undefined, app = undefined, minSupportedVersion = undefined, otaConfigCore = undefined, blindPeerKeys = undefined, blindPeeringOpts = undefined, meshSeed = undefined, meshKey = undefined, additionalNodes = undefined, listModels = undefined, deleteModel = undefined, clearKvCache = undefined, deleteChatKvCache = undefined, compactChat = undefined, modelCatalogWatch = undefined, retryModelDownload = undefined, transcribe = undefined, speak = undefined, speakStream = undefined, embedder = undefined, extractors = undefined, skills = undefined, skillCatalog = undefined, tools = undefined, hostsModelSource = false, vectorIndex = undefined, apiLifecycle = undefined }) {
+        super();
+        this._transport = transport;
+        this._apiLifecycle = apiLifecycle ?? {
+            suspend: () => this.suspend(),
+            resume: () => this.resume()
+        };
+        this._log = logger;
+        if (logger)
+            setLogger(logger);
+        this._storagePath = storagePath;
+        this.storage = new CorestoreStorage(this._storagePath, {
+            blobGarbageCollectionAgeCutOff: 1.0,
+            blobGarbageCollectionForceThreshold: 0.5,
+            blobFileSize: 64 * 1024 * 1024
+        });
+        this.rootCorestore = new Corestore(this.storage, {
+            globalCache: new Rache()
+        });
+        this.store = this.rootCorestore.namespace(QVAC_CORE_NAMESPACE);
+        this.local = openLocalStore(this.storage);
+        this.state = QvacState.RESUME;
+        this._spec = spec;
+        this._bootstrapNodes = bootstrapNodes;
+        this._device = device;
+        this._app = app;
+        this._minSupportedVersion = minSupportedVersion;
+        const channel = resolveConfigChannel(app?.channel);
+        const lane = channel ? configCoreFor(channel) : null;
+        this._otaConfigCore = minSupportedVersion ? null : (otaConfigCore ?? lane);
+        if (!minSupportedVersion)
+            this._minSupportedVersion = vendoredMinSupportedVersion();
+        this._localDevice = null;
+        this._blindPeerKeys = blindPeerKeys;
+        this._blindPeeringOpts = blindPeeringOpts;
+        this._meshSeed = meshSeed;
+        this._meshKey = meshKey;
+        this._additionalNodes = additionalNodes;
+        this._listModels = listModels ?? null;
+        this._deleteModel = deleteModel ?? null;
+        this._clearKvCache = clearKvCache ?? null;
+        this._deleteChatKvCache = deleteChatKvCache ?? null;
+        this._compactChat = compactChat ?? null;
+        this._modelCatalogWatch = modelCatalogWatch ?? null;
+        this._openModelCatalogWatchSource();
+        void this._modelCatalogWatchSource.ready().catch(noop);
+        this._retryModelDownload = retryModelDownload ?? null;
+        this._transcribe = transcribe ?? null;
+        this._speak = speak ?? null;
+        this._speakStream = speakStream ?? null;
+        this._embedder = embedder ?? null;
+        this._ragExtractors = extractors;
+        this._processingFiles = null;
+        this._skills = skills ?? null;
+        this._skillCatalog = skillCatalog ?? null;
+        this._skillManagement = null;
+        this._tools = tools ?? null;
+        this._hostsModelSource = hostsModelSource;
+        this._openCatalogHooks();
+        void this._catalogHooks.ready().catch(noop);
+        this._vectorIndex = vectorIndex ?? (embedder ? new MemoryVectorIndex() : null);
+        this._closeSignal = new Promise((resolve) => {
+            this._signalClose = resolve;
+        });
+        this._closeListeners = new Set();
+        this._closeSignaled = false;
+        void this._closeSignal.then(() => {
+            this._closeSignaled = true;
+            const listeners = [...this._closeListeners];
+            this._closeListeners.clear();
+            for (const listener of listeners)
+                listener();
+        });
+        this._mesh = null;
+        this._candidateMesh = null;
+        this._cancelCandidateJoin = null;
+        this._joinCancellation = null;
+        this._meshSecretSeed = null;
+        this._rpcs.clear();
+        this._stream = null;
+        this._api = null;
+        this._clients = new Set();
+        this._deviceKeyPair = null;
+        this._swarm = null;
+        this._wakeup = new Wakeup();
+        this._secretHandoff = new SecretHandoff({
+            onrequest: (request, from) => this._storeHandedOffSecret(request, from)
+        });
+        this._skillOverlayHandoff = new SkillOverlayHandoff({
+            onrequest: (op, from) => this._serveSkillOverlayOp(op, from)
+        });
+        this._hostedAgents = null;
+        this._minting = false;
+        this._leaving = false;
+        this._kicked = false;
+        this._kickedPending = false;
+        this._peers = new Set();
+        this._statusListeners = new Set();
+        this._diagnosticsProviders = new Set();
+        this._systemInfo = null;
+        this._onMeshWritable = () => {
+            this._kicked = false;
+            this._notifyStatus();
+        };
+        this._onMeshDead = (err) => {
+            const mesh = this._mesh;
+            if (this.closing || !mesh)
+                return;
+            this._log?.error(['p2p', 'mesh'], 'mesh autobee died — retiring it', err);
+            this._mesh = null;
+            this._statusError = statusErrorMessage('the local database died', err);
+            this._notifyStatus();
+            this._retireMesh(mesh).catch((retireErr) => {
+                this._log?.warn(['p2p', 'mesh'], 'retiring the dead mesh failed', retireErr);
+            });
+        };
+        this._onMeshStalled = (err) => {
+            if (this._mesh)
+                this._withdrawFromMesh(this._mesh, err);
+        };
+        this._statusError = null;
+        this._upgradeRequired = null;
+    }
+    get devicePublicKey() {
+        return this._deviceKeyPair?.publicKey ?? null;
+    }
+    get fsDrives() {
+        return this._fsDrives;
+    }
+    get suspended() {
+        return this.state === QvacState.SUSPEND;
+    }
+    get mesh() {
+        return this._mesh;
+    }
+    async meshReady() {
+        await this._awaitMesh();
+    }
+    get peerCount() {
+        return this._peers.size;
+    }
+    get peerDeviceIds() {
+        const ids = [...this._peers].map((conn) => conn.remotePublicKey.toString('hex'));
+        return [...new Set(ids)].sort();
+    }
+    async _open() {
+        this._runBootOffline().catch(noop);
+        this._runBootOnline().catch(noop);
+        await this._offlineBoot.ready();
+        this._log?.info('lifecycle', 'core open');
+    }
+    async _runBootOffline() {
+        try {
+            this._deviceKeyPair = await this.store.createKeyPair(SWARM_KEYPAIR_NAME);
+            this._identityPublicKey = (await this.local.readIdentity())?.publicKey.toString('hex') ?? null;
+            this._localDevice = await this.local.ensureDevice(this.devicePublicKey, this._device);
+            this._openSwarm(this._deviceKeyPair);
+            this._departures = new PendingDepartures(this.store, this.local, {
+                swarm: this._swarm,
+                logger: this._log,
+                blindPeerKeys: this._resolveBlindPeerKeys(),
+                blindPeeringOpts: this._blindPeeringOpts,
+                wakeup: this._wakeup
+            });
+            this._fsDrives = createFsDriveHost(this.store, {
+                swarm: this._swarm,
+                blindPeerKeys: this._resolveBlindPeerKeys(),
+                blindPeeringOpts: this._blindPeeringOpts
+            });
+            void sweepDriveStaging();
+            this._blobServer = new CoreBlobServer(this.store, () => this._currentMesh());
+            this._blobServer.on('rebound', (port) => {
+                logger.warn('core', 'blob server rebound, links minted before now are stale', { port });
+            });
+            await this._blobServer.ready();
+            await this._openOtaConfig();
+            await this._openBootMesh();
+            this._systemInfo = createSystemInfoSampler();
+            this._api = createApi({
+                state: this.local,
+                notificationLifetime: this,
+                mesh: () => this._currentMesh(),
+                meshStatus: this._meshStatusSource(),
+                network: this._networkStatusSource(),
+                diagnostics: this._diagnosticsSource(),
+                logs: this._logSource(),
+                deviceId: this.devicePublicKey,
+                lifecycle: this._apiLifecycle,
+                ragIndex: () => this._vectorIndex,
+                ragEmbed: () => this._indexedEmbedder,
+                platform: () => this._localDevice?.platform ?? null,
+                pushSkillSecret: (request) => this.pushSkillSecret(request),
+                listModels: this._hostsModelSource || this._listModels
+                    ? (options) => this._listModels?.(options) ?? Promise.resolve({ models: [] })
+                    : null,
+                deleteModel: this._hostsModelSource || this._deleteModel
+                    ? (options) => this._deleteModel?.(options) ??
+                        Promise.resolve({ name: options.name, removed: 0, freedBytes: 0 })
+                    : null,
+                clearKvCache: () => this._clearKvCache?.() ??
+                    Promise.resolve({
+                        status: 'unsupported',
+                        error: 'No harness KV cache deletion source is bound'
+                    }),
+                deleteChatKvCache: (chatId) => this._deleteChatKvCache?.(chatId) ??
+                    Promise.resolve({
+                        status: 'unsupported',
+                        error: 'No harness KV cache deletion source is bound'
+                    }),
+                compactChat: (chatId) => this._compactChat?.(chatId) ??
+                    Promise.resolve({ compacted: false, reason: 'unsupported' }),
+                modelCatalogWatch: this._hostsModelSource || this._modelCatalogWatch
+                    ? () => this._watchModelCatalog()
+                    : null,
+                retryModelDownload: this._hostsModelSource || this._retryModelDownload
+                    ? ({ name }) => this._retryModelDownload?.(name) ??
+                        Promise.reject(new Error('no model download source bound'))
+                    : null,
+                transcribe: this._hostsModelSource || this._transcribe
+                    ? (request) => this._transcribe?.(request) ??
+                        Promise.reject(new Error('no transcription source bound'))
+                    : null,
+                speak: this._hostsModelSource || this._speak
+                    ? (request) => this._speak?.(request) ?? Promise.reject(new Error('no tts source bound'))
+                    : null,
+                speakStream: this._hostsModelSource || this._speakStream
+                    ? (text) => {
+                        if (!this._speakStream)
+                            throw new Error('no tts source bound');
+                        return this._speakStream(text);
+                    }
+                    : null,
+                deviceHost: {
+                    removeWriter: (writerKey, deviceId) => this.removeDeviceWriter(writerKey, deviceId),
+                    renameLocal: (name) => this.renameLocalDevice(name),
+                    saveProfileLocal: (capabilityProfile, recommendedModelName, platform) => this.saveDeviceProfileLocal(capabilityProfile, recommendedModelName, platform),
+                    readLocalProfile: () => this._localDevice
+                        ? {
+                            capabilityProfile: this._localDevice.capabilityProfile,
+                            recommendedModelName: this._localDevice.recommendedModelName,
+                            platform: this._localDevice.platform
+                        }
+                        : null
+                },
+                skills: this._hostsModelSource || this._skills
+                    ? (agentId, modelName, options) => this._skills?.(agentId, modelName, options) ?? Promise.resolve([])
+                    : null,
+                skillCatalog: this._hostsModelSource || this._skillCatalog
+                    ? async (agentId, modelName, options) => {
+                        await this._waitForCatalogHooks();
+                        return (this._skillCatalog?.(agentId, modelName, options) ??
+                            Promise.resolve({ skills: [] }));
+                    }
+                    : null,
+                tools: this._hostsModelSource || this._tools
+                    ? async () => {
+                        await this._waitForCatalogHooks();
+                        return this._tools?.() ?? Promise.resolve({ tools: [] });
+                    }
+                    : null,
+                listManagedSkills: this._hostsModelSource || this._skillManagement
+                    ? async (agentId) => ({
+                        skills: [...((await this._skillOverlayOp(agentId, { op: 'list' })).skills ?? [])]
+                    })
+                    : null,
+                readSkillFile: this._hostsModelSource || this._skillManagement
+                    ? async (name, agentId) => {
+                        const res = await this._skillOverlayOp(agentId, { op: 'read', name });
+                        return { found: res.found ?? false, content: res.content, origin: res.origin };
+                    }
+                    : null,
+                writeSkillFile: this._hostsModelSource || this._skillManagement
+                    ? async (name, content, agentId) => ({
+                        ok: (await this._skillOverlayOp(agentId, { op: 'write', name, content })).ok ?? false
+                    })
+                    : null,
+                copySkillForEdit: this._hostsModelSource || this._skillManagement
+                    ? async (name, agentId) => ({
+                        copied: (await this._skillOverlayOp(agentId, { op: 'copy', name })).copied ?? false
+                    })
+                    : null,
+                deleteOverlaySkill: this._hostsModelSource || this._skillManagement
+                    ? async (name, agentId) => ({
+                        removed: (await this._skillOverlayOp(agentId, { op: 'delete', name })).removed ?? false
+                    })
+                    : null
+            });
+            this._stream = await this._transport();
+            const { bindApi, HRPC } = await this._spec();
+            const rpc = settleOnClose(new HRPC(this._stream));
+            bindApi(rpc, this._api);
+            this._rpcs.add(rpc);
+            this._offlineBoot.exit();
+            void this._pushIdentityPhrase();
+            return;
+        }
+        catch (err) {
+            try {
+                this._systemInfo?.destroy();
+                this._systemInfo = null;
+                await this._stopIndexing();
+                await this._closeOtaConfig();
+                await this._fsDrives?.close();
+                this._fsDrives = null;
+                await this._blobServer?.close();
+                this._blobServer = null;
+                await this._departures?.close();
+                this._departures = null;
+                logger.info('core', 'closing swarm');
+                await this._closeSwarm();
+                logger.info('core', 'closing local');
+                await this.local?.close();
+                logger.info('core', 'closing mesh');
+                await this._mesh?.close();
+                logger.info('core', 'closing storage');
+                await this.store?.close();
+                await this.rootCorestore?.close();
+            }
+            finally {
+                this._offlineBoot.destroy(err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+    }
+    async _openBootMesh() {
+        if (this._blockedByMinVersion() || this._mesh || this._minting)
+            return;
+        try {
+            await this._openMesh({ seed: this._meshSeed, baseKey: this._meshKey });
+        }
+        catch (err) {
+            if (this.closing)
+                return;
+            if (!this._upgradeRequired) {
+                this._statusError = statusErrorMessage('opening the local database failed', err);
+            }
+            this._notifyStatus();
+            this._log?.error(['p2p', 'mesh'], 'mesh open failed', err);
+        }
+    }
+    async _runBootOnline() {
+        void this.onlineBoot.ready().catch(noop);
+        try {
+            await this._offlineBoot.ready();
+            if (this.closing)
+                return;
+            if (this._mesh)
+                this._bringMeshOnline(this._mesh);
+        }
+        catch (err) {
+            if (this.closing)
+                return;
+            this._log?.error(['p2p', 'mesh'], 'online boot failed', err);
+        }
+        finally {
+            if (!this.closing && !this._offlineBoot.destroyed)
+                this._peerConfigCore();
+            if (!this.closing)
+                this._departures?.flush(this._mesh?.key);
+            this.onlineBoot.exit();
+        }
+    }
+    async _reopenMesh() {
+        try {
+            if (this.closing || this._mesh || this._minting)
+                return;
+            await this._startMesh({ seed: this._meshSeed, baseKey: this._meshKey });
+        }
+        catch (err) {
+            if (this.closing)
+                return;
+            if (!this._upgradeRequired) {
+                this._statusError = statusErrorMessage('reopening the local database failed', err);
+            }
+            this._notifyStatus();
+            this._log?.error(['p2p', 'mesh'], 'reopening the mesh failed', err);
+        }
+    }
+    get otaConfigCore() {
+        return this._otaConfigCore;
+    }
+    async _openOtaConfig() {
+        const core = this._otaConfigCore;
+        if (!core) {
+            this._log?.warn(['p2p', 'config'], 'no release lane: the version floor is inert', {
+                lane: this._app?.channel ?? null,
+                appVersion: this._app?.version ?? null
+            });
+            return;
+        }
+        if (this._otaConfig || this.closing)
+            return;
+        const config = new OtaConfigReader(this.store, core);
+        this._otaConfig = config;
+        try {
+            if (!(await recordedBlockIsLocal(config.core))) {
+                this._log?.warn(['p2p', 'config'], 'lane core records a block it does not hold: the baked floor stands');
+                await this._closeOtaConfig();
+                return;
+            }
+            await config.ready();
+            if (this.closing)
+                return;
+            config.on('update', () => {
+                this._logFloor(config, 'updated');
+                this.setMinSupportedVersion(config.minSupportedVersion);
+            });
+            this._logFloor(config, 'opened');
+            this.setMinSupportedVersion(config.minSupportedVersion);
+        }
+        catch (err) {
+            this._log?.warn(['p2p', 'config'], 'ota config unavailable', err);
+        }
+    }
+    _logFloor(config, event) {
+        const floor = config.minSupportedVersion;
+        const appVersion = this._app?.version;
+        const length = config.core.length;
+        this._log?.info(['p2p', 'config'], `ota config ${event}`, {
+            lane: this._app?.channel ?? null,
+            discoveryKey: config.core.discoveryKey.toString('hex').slice(0, 8),
+            length,
+            floor,
+            source: length > 0 && length >= (this._otaConfigCore?.minLength ?? 1) ? 'published' : 'vendored',
+            appVersion: appVersion ?? null,
+            withheld: updateRequired({ range: floor, appVersion })
+        });
+    }
+    _peerConfigCore() {
+        const config = this._otaConfig;
+        if (!config || this._configPeering || this._mesh || !this._swarm)
+            return;
+        const keys = this._resolveBlindPeerKeys();
+        if (keys.length === 0)
+            return;
+        this._configPeering = new BlindPeering(this._swarm.dht, this.store, {
+            pick: keys.length,
+            ...this._blindPeeringOpts
+        });
+        this._configPeering.addCoreBackground(config.core, { keys });
+        this._log?.info(['p2p', 'config'], 'blind peering the config core: no mesh to carry it');
+    }
+    async _closeConfigPeering() {
+        const peering = this._configPeering;
+        if (!peering)
+            return;
+        this._configPeering = null;
+        await peering.close();
+    }
+    async _closeOtaConfig() {
+        const config = this._otaConfig;
+        this._otaConfig = null;
+        await closeConfigReader(config);
+    }
+    _blockedByMinVersion() {
+        const range = this._minSupportedVersion;
+        const appVersion = this._app?.version;
+        if (!updateRequired({ range, appVersion })) {
+            if (this._upgradeRequired === 'floor')
+                this._setUpgradeRequired(null);
+            return false;
+        }
+        if (this._upgradeRequired)
+            return true;
+        this._log?.error(['p2p', 'mesh'], 'mesh requires a newer build — not opening', {
+            range,
+            appVersion
+        });
+        this._setUpgradeRequired('floor');
+        return true;
+    }
+    _setUpgradeRequired(reason) {
+        if (this._upgradeRequired === reason)
+            return;
+        this._upgradeRequired = reason;
+        this._notifyStatus();
+    }
+    setMinSupportedVersion(required) {
+        const next = required || undefined;
+        if (this._minSupportedVersion === next)
+            return;
+        this._minSupportedVersion = next;
+        if (this.closing)
+            return;
+        const withheld = this._upgradeRequired === 'floor';
+        if (!this._blockedByMinVersion()) {
+            if (withheld)
+                void this._reopenMesh();
+            return;
+        }
+        const mesh = this._mesh;
+        if (!mesh)
+            return;
+        this._mesh = null;
+        this._notifyStatus();
+        this._retireMesh(mesh).catch((err) => {
+            this._log?.warn(['p2p', 'mesh'], 'retiring a mesh above our floor failed', err);
+        });
+    }
+    async connect(stream) {
+        if (!this.opened)
+            await this.ready();
+        if (this.closing || !this._api)
+            throw new Error('core is closing');
+        const { bindApi, HRPC } = await this._spec();
+        const rpc = settleOnClose(new HRPC(stream));
+        bindApi(rpc, this._api);
+        this._rpcs.add(rpc);
+        this._clients.add(stream);
+        void this._pushIdentityPhrase();
+        stream.on('close', () => {
+            this._clients.delete(stream);
+            this._rpcs.delete(rpc);
+        });
+    }
+    async wakeup() {
+        if (this.closing)
+            return;
+        this.state = QvacState.WAKEUP;
+        logger.info('core', 'wakeup');
+        if (!this.opened)
+            await this.ready();
+        await this.resume();
+    }
+    async presuspend() {
+        if (this.closing)
+            return;
+        this.state = QvacState.PRESUSPEND;
+        logger.info('core', 'presuspend');
+        if (!this.opened)
+            await this.ready();
+    }
+    async suspend() {
+        logger.info('core', 'suspend called');
+        if (this.state === QvacState.SUSPEND)
+            return;
+        if (this.closing)
+            return;
+        this.state = QvacState.SUSPEND;
+        if (!this.opened)
+            await this.ready();
+        logger.info('core', 'suspending');
+        if (this._mesh)
+            await this._mesh.suspend();
+        if (this._departures)
+            await this._departures.suspend();
+        if (this._configPeering)
+            await this._configPeering.suspend();
+        if (this._swarm)
+            await this._swarm.suspend();
+        if (this._blobServer)
+            await this._blobServer.suspend();
+        await this.store.suspend();
+        this._log?.info('lifecycle', 'core suspend');
+    }
+    async resume() {
+        logger.info('core', 'resume called');
+        if (this.state === QvacState.RESUME)
+            return;
+        if (this.closing)
+            return;
+        if (this.state === QvacState.PRESUSPEND) {
+            this.state = QvacState.RESUME;
+            return;
+        }
+        this.state = QvacState.RESUME;
+        if (!this.opened)
+            await this.ready();
+        logger.info('core', 'resuming');
+        await this.store.resume();
+        if (this._blobServer)
+            await this._blobServer.resume();
+        if (this._swarm)
+            await this._swarm.resume();
+        if (this._configPeering)
+            await this._configPeering.resume();
+        if (this._mesh)
+            await this._mesh.resume();
+        if (this._departures)
+            await this._departures.resume();
+        this._departures?.flush(this._mesh?.key);
+        if (this._swarm)
+            void this._refreshTopics(this._swarm).catch(noop);
+        void this._pushIdentityPhrase();
+        this._log?.info('lifecycle', 'core resume');
+    }
+    async _refreshTopics(swarm) {
+        for (const discovery of swarm.topics()) {
+            await discovery.flushed();
+            await discovery.refresh();
+        }
+    }
+    async _close() {
+        logger.info('core', 'closing');
+        if (this.state === QvacState.SUSPEND)
+            await this.store.resume();
+        this._catalogHooks.destroy(new Error('core is closing'));
+        this._modelCatalogWatchSource.destroy(new Error('core is closing'));
+        this._offlineBoot.destroy(new Error('core is closing'));
+        this.onlineBoot.destroy(new Error('core is closing'));
+        this._signalClose();
+        this._notifyStatus();
+        if (this._stream)
+            this._stream.destroy();
+        for (const client of this._clients)
+            client.destroy();
+        this._clients.clear();
+        await this._stopHostedAgents();
+        await this._stopIndexing();
+        closeCollaboraWorker();
+        await this._blobServer?.close();
+        this._blobServer = null;
+        if (this._mesh) {
+            this._mesh.autobee.off('writable', this._onMeshWritable);
+            this._mesh.autobee.off('error', this._onMeshDead);
+            this._mesh.autobee.off('close', this._onMeshDead);
+            this._mesh.autobee.off('interrupt', this._onMeshStalled);
+            await this._mesh.close();
+        }
+        await this._discardCandidateMesh();
+        await this._departures?.close();
+        this._departures = null;
+        await this._closeConfigPeering();
+        await this._closeOtaConfig();
+        await this._fsDrives?.close();
+        this._fsDrives = null;
+        logger.info('core', 'closing swarm');
+        await this._closeSwarm();
+        this._mesh = null;
+        this._meshSecretSeed = null;
+        logger.info('core', 'closing local');
+        await this.local?.close();
+        this._systemInfo?.destroy();
+        this._systemInfo = null;
+        logger.info('core', 'closing storage');
+        await this.store?.close();
+        await this.rootCorestore?.close();
+        this._log?.info('lifecycle', 'core closed');
+    }
+    _openSwarm(keyPair) {
+        this._swarm = new Hyperswarm({
+            keyPair,
+            bootstrap: this._bootstrapNodes,
+            relayThrough: this._bootstrapNodes ? undefined : () => BLIND_RELAY_KEYS
+        });
+        this._swarm.on('connection', (conn) => this._onConnection(conn));
+        this._log?.info(['p2p', 'swarm'], 'swarm created', {
+            deviceKey: keyPair.publicKey.toString('hex').slice(0, 8)
+        });
+        for (const node of this._additionalNodes ?? [])
+            this._swarm.dht.addNode(node);
+    }
+    _resolveBlindPeerKeys(extra = []) {
+        const defaults = this._bootstrapNodes ? [] : BLIND_PEER_KEYS;
+        const merged = new Map(defaults.map((key) => [key.toString('hex'), key]));
+        for (const key of this._blindPeerKeys ?? [])
+            merged.set(key.toString('hex'), key);
+        for (const key of extra)
+            merged.set(key.toString('hex'), key);
+        return [...merged.values()];
+    }
+    async _startMesh(opts = {}) {
+        const mesh = await this._openMesh(opts);
+        this._bringMeshOnline(mesh, opts);
+        return mesh;
+    }
+    async _openMesh(opts = {}) {
+        if (this.closing)
+            throw new Error('core is closing');
+        if (this._blockedByMinVersion())
+            throw new Error(MESH_BELOW_FLOOR);
+        if (this._mesh) {
+            await this._retireMesh(this._mesh);
+        }
+        const deviceId = this._deviceKeyPair.publicKey;
+        const session = await this.local.resolveSession(deviceId, opts);
+        const mesh = new Mesh(this.store, {
+            seed: session.seed,
+            key: session.baseKey ?? null,
+            deviceId,
+            writerSeed: session.writerSeed,
+            logger: this._log,
+            blindPeerKeys: this._resolveBlindPeerKeys(opts.blindPeerKeys),
+            blindPeeringOpts: this._blindPeeringOpts,
+            wakeup: this._wakeup,
+            attachmentUrl: this._attachmentUrl
+        });
+        try {
+            await mesh.ready();
+            await raceResource(mesh.autobee, (async () => {
+                await mesh.appendBirthOp(deviceId, this._localDevice ?? undefined, await this._mintBirthMember(mesh, deviceId, session));
+                await this.local.recordMesh(deviceId, mesh.key, session.seed, session.creator, session.writerSeed);
+            })(), 'mesh');
+        }
+        catch (err) {
+            await mesh.close().catch(noop);
+            throw err;
+        }
+        if (this.closing) {
+            await mesh.close();
+            throw new Error('core is closing');
+        }
+        const halted = mesh.interrupted;
+        if (halted) {
+            this._withdrawFromMesh(mesh, halted);
+            throw halted;
+        }
+        this._activateMesh(mesh, session);
+        return mesh;
+    }
+    async _mintBirthMember(mesh, deviceId, session) {
+        const local = this._localDevice;
+        if (!local || session.baseKey || mesh.localLength > 0)
+            return undefined;
+        const now = Date.now();
+        const { identity, mnemonic } = await this.local.ensureIdentity(deviceId, now);
+        this._identityPublicKey = identity.publicKey.toString('hex');
+        this._holdIdentityPhrase(mnemonic);
+        return {
+            member: { id: identity.publicKey, name: local.name, joinedAt: now, updatedAt: now },
+            proof: identity.proof
+        };
+    }
+    _holdIdentityPhrase(mnemonic) {
+        if (!mnemonic)
+            return;
+        this._identityPhrase = mnemonic;
+        void this._pushIdentityPhrase();
+    }
+    async _pushIdentityPhrase() {
+        const phrase = this._identityPhrase;
+        if (!phrase || this._rpcs.size === 0 || this.closing)
+            return;
+        this._identityPhrase = null;
+        for (const rpc of this._rpcs) {
+            if (await this._offerIdentityPhrase(rpc, phrase))
+                return;
+        }
+        this._identityPhrase = phrase;
+        this._log?.warn(['api'], 'the host stored no recovery phrase');
+    }
+    async _offerIdentityPhrase(rpc, phrase) {
+        try {
+            return (await rpc.storeIdentityPhrase({ phrase })).ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    _bringMeshOnline(mesh, opts = {}) {
+        if (this.closing || mesh.closing || this._mesh !== mesh)
+            return;
+        if (this._swarm) {
+            this._swarm.join(mesh.discoveryKey, { server: true, client: true });
+            mesh.startBlindPeering(this._swarm.dht);
+            if (this.suspended)
+                void mesh.suspend().catch(noop);
+            this._log?.info(['p2p', 'swarm'], 'announced and peering the mesh');
+        }
+        if (!opts.new)
+            void this._ensureNotRevoked(mesh);
+        this._departures?.flush(mesh.key);
+        void this._advertiseAppVersion(mesh, this._deviceKeyPair.publicKey);
+        void this._advertiseDeviceProfile(mesh, this._deviceKeyPair.publicKey);
+        void this._settleMembership(mesh, { migrate: true });
+    }
+    async _advertiseDeviceProfile(mesh, deviceId) {
+        const local = this._localDevice;
+        if (!local?.platform)
+            return;
+        try {
+            await mesh.waitForWritable();
+            if (mesh.closing || this._mesh !== mesh)
+                return;
+            const snap = mesh.view.snapshot();
+            let existing;
+            try {
+                existing = await snap.get('@qvac/devices', { id: deviceId });
+            }
+            finally {
+                await snap.close();
+            }
+            if (existing?.platform === local.platform &&
+                existing.capabilityProfile === local.capabilityProfile &&
+                existing.recommendedModelName === local.recommendedModelName) {
+                return;
+            }
+            await mesh.dispatch('update-device-profile', {
+                deviceId,
+                capabilityProfile: local.capabilityProfile,
+                recommendedModelName: local.recommendedModelName,
+                platform: local.platform
+            });
+        }
+        catch (err) {
+            this._log?.warn(['p2p', 'mesh'], 'advertising the device profile failed', err);
+        }
+    }
+    async _advertiseAppVersion(mesh, deviceId) {
+        const app = this._app;
+        if (!app)
+            return;
+        try {
+            await mesh.waitForWritable();
+            if (mesh.closing || this._mesh !== mesh)
+                return;
+            const snap = mesh.view.snapshot();
+            let existing;
+            try {
+                existing = await snap.get('@qvac/devices', { id: deviceId });
+            }
+            finally {
+                await snap.close();
+            }
+            if (existing?.appVersion === app.version &&
+                (existing.appBuild || undefined) === app.build &&
+                existing.appChannel === app.channel) {
+                return;
+            }
+            await advertiseDeviceVersion(mesh, deviceId, app);
+        }
+        catch (err) {
+            this._log?.warn(['p2p', 'mesh'], 'advertising app version failed', err);
+        }
+    }
+    async _settleMembership(mesh, { migrate = false } = {}) {
+        if (!this._localDevice)
+            return;
+        if (!(await this._memberLock.lock()))
+            return;
+        try {
+            await mesh.waitForWritable();
+            if (mesh.closing || this._mesh !== mesh)
+                return;
+            await mesh.autobee.update();
+            if (mesh.closing || this._mesh !== mesh)
+                return;
+            const context = { deviceKeyPair: this._deviceKeyPair, log: this._log };
+            if (migrate)
+                await runMigrations(mesh, { ...context, ...this._migrationContext() });
+            await attestUnattestedDevices(mesh, context);
+        }
+        catch (err) {
+            this._log?.warn(['p2p', 'mesh'], 'settling membership failed', err);
+        }
+        finally {
+            this._memberLock.unlock();
+        }
+    }
+    _migrationContext() {
+        return {
+            device: {
+                id: this._deviceKeyPair.publicKey,
+                platform: this._device?.platform ?? this._localDevice.platform
+            },
+            deviceName: this._localDevice.name,
+            mintRoot: async (deviceId, at) => {
+                const { identity, mnemonic } = await this.local.ensureIdentity(deviceId, at);
+                this._identityPublicKey = identity.publicKey.toString('hex');
+                this._holdIdentityPhrase(mnemonic);
+                return { publicKey: identity.publicKey, proof: identity.proof };
+            }
+        };
+    }
+    async _recordMembership(own) {
+        try {
+            await this.local.recordMembership({
+                memberId: own.memberId,
+                proof: own.memberProof,
+                attestedAt: own.attestedAt || 0
+            });
+        }
+        catch (err) {
+            this._log?.warn(['p2p', 'mesh'], 'keeping our membership proof failed', err);
+        }
+    }
+    async _ensureNotRevoked(mesh) {
+        try {
+            const revocation = await mesh.checkResumedRevocation();
+            if (!revocation || this._mesh !== mesh)
+                return;
+            this._log?.info(['p2p', 'mesh'], `resumed already revoked (${revocation} while offline) — minting a fresh mesh`);
+            if (revocation === 'kicked')
+                this._kickedPending = true;
+            await this._requestFreshMesh();
+        }
+        catch (err) {
+            this._log?.warn(['p2p', 'mesh'], 'resumed revocation check failed', err);
+        }
+    }
+    async _retireMesh(mesh) {
+        if (this._mesh === mesh) {
+            this._mesh = null;
+            this._notifyStatus();
+        }
+        if (this._candidateMesh === mesh)
+            this._candidateMesh = null;
+        mesh.autobee.off('writable', this._onMeshWritable);
+        mesh.autobee.off('error', this._onMeshDead);
+        mesh.autobee.off('close', this._onMeshDead);
+        mesh.autobee.off('interrupt', this._onMeshStalled);
+        await this._stopHostedAgents();
+        try {
+            await this._stopIndexing();
+        }
+        finally {
+            if (this._swarm)
+                await this._swarm.leave(mesh.discoveryKey).catch(() => { });
+            await mesh.close();
+        }
+    }
+    _withdrawFromMesh(mesh, err) {
+        if (this.closing || this._upgradeRequired)
+            return;
+        this._log?.error(['p2p', 'mesh'], 'mesh needs a newer build — withdrawing from it', err);
+        this._setUpgradeRequired('halt');
+        this._retireMesh(mesh).catch((retireErr) => {
+            this._log?.warn(['p2p', 'mesh'], 'retiring the stalled mesh failed', retireErr);
+        });
+    }
+    _onKicked() {
+        if (this.closing || this._leaving)
+            return;
+        this._log?.info(['p2p', 'mesh'], 'our writer was revoked (kicked) — minting a fresh mesh');
+        this._kicked = true;
+        this._kickedPending = true;
+        this._requestFreshMesh().catch((err) => {
+            this._log?.error(['p2p', 'mesh'], 'kick-driven re-mint failed', err);
+        });
+    }
+    async _requestFreshMesh() {
+        if (this.closing || this._minting)
+            return;
+        this._minting = true;
+        this._notifyStatus();
+        try {
+            this.emit('mesh-changed', await this._startMesh({ new: true }));
+        }
+        catch (err) {
+            if (this.closing)
+                return;
+            if (!this._upgradeRequired) {
+                this._statusError = statusErrorMessage('creating a new mesh failed', err);
+            }
+            if (!this.emit('mesh-error', err))
+                throw err;
+        }
+        finally {
+            this._minting = false;
+            this._notifyStatus();
+        }
+    }
+    _onClose(listener) {
+        if (this._closeSignaled) {
+            listener();
+            return noop;
+        }
+        this._closeListeners.add(listener);
+        return () => void this._closeListeners.delete(listener);
+    }
+    _waitForMeshChange() {
+        return new Promise((resolve) => {
+            let offClose = noop;
+            const settle = (error) => {
+                this.off('mesh-changed', onChanged);
+                this.off('mesh-error', onError);
+                offClose();
+                resolve(error);
+            };
+            const onChanged = () => settle(null);
+            const onError = (error) => settle(error);
+            this.on('mesh-changed', onChanged);
+            this.on('mesh-error', onError);
+            offClose = this._onClose(onChanged);
+        });
+    }
+    async joinMesh(rawInvite) {
+        const invite = decodeMeshInvite(rawInvite);
+        if (!invite)
+            throw new Error('Invalid mesh invite');
+        await this._awaitMesh();
+        await this._meshTransitionLock.lock();
+        let ownsTransition = false;
+        try {
+            if (this.closing)
+                throw new Error('Core is closing');
+            if (this._leaving || this._minting)
+                throw new Error('Mesh transition already in progress');
+            if (this._mesh?.key.equals(invite.baseKey) && this._mesh.writable)
+                return;
+            ownsTransition = true;
+            this._minting = true;
+            this._notifyStatus();
+            await this._joinMesh(invite);
+        }
+        finally {
+            if (ownsTransition)
+                this._minting = false;
+            this._meshTransitionLock.unlock();
+            this._notifyStatus();
+            this._departures?.flush(this._mesh?.key);
+        }
+    }
+    cancelMeshJoin() {
+        if (this._joinCancellation?.accepting)
+            this._joinCancellation.canceled = true;
+        this._cancelCandidateJoin?.();
+    }
+    _throwIfJoinCanceled() {
+        if (this._joinCancellation?.canceled)
+            throw new Error(MESH_JOIN_CANCELED);
+    }
+    async _joinMesh(invite) {
+        const cancellation = { canceled: false, accepting: true };
+        this._joinCancellation = cancellation;
+        try {
+            await this._runJoinMesh(invite);
+        }
+        finally {
+            if (this._joinCancellation === cancellation)
+                this._joinCancellation = null;
+        }
+    }
+    async _runJoinMesh(invite) {
+        const deviceId = this._deviceKeyPair.publicKey;
+        const source = this._mesh;
+        for (const node of invite.additionalNodes ?? [])
+            this._swarm?.dht.addNode(node);
+        await this._departures?.park(invite.baseKey);
+        try {
+            await this._joinParkedMesh(invite, source, deviceId);
+        }
+        finally {
+            this._departures?.unpark(invite.baseKey);
+        }
+    }
+    async _joinParkedMesh(invite, source, deviceId) {
+        const session = this.local.createCandidateSession(invite.seed, invite.baseKey);
+        let candidate;
+        try {
+            candidate = await this._openCandidateMesh(invite, session);
+        }
+        catch (error) {
+            await this._discardCandidateMesh();
+            throw error;
+        }
+        this._throwIfJoinCanceled();
+        if (this._joinCancellation)
+            this._joinCancellation.accepting = false;
+        try {
+            if (source && (await this._departureHasAudience(source))) {
+                await this.local.recordDeparture(source.key);
+            }
+            await this.local.recordMesh(deviceId, candidate.key, session.seed, session.creator, session.writerSeed);
+        }
+        catch (error) {
+            await this._discardCandidateMesh();
+            throw error;
+        }
+        if (source) {
+            await this._announceDeparture(source);
+            await this._retireMesh(source).catch((error) => this._log?.warn(['p2p', 'mesh'], 'source mesh retirement failed', error));
+        }
+        if (this._blockedByMinVersion()) {
+            await this._retireMesh(candidate).catch((err) => this._log?.warn(['p2p', 'mesh'], 'withholding the joined mesh failed', err));
+            return;
+        }
+        this._activateMesh(candidate, session);
+        void this._departures?.drop(candidate.key).catch(noop);
+        void this._advertiseDeviceProfile(candidate, deviceId);
+        void this._settleMembership(candidate, { migrate: true });
+        this.emit('mesh-changed', candidate);
+    }
+    async _openCandidateMesh(invite, session) {
+        this._throwIfJoinCanceled();
+        const candidate = new Mesh(this.store, {
+            seed: session.seed,
+            key: session.baseKey ?? null,
+            deviceId: this._deviceKeyPair.publicKey,
+            writerSeed: session.writerSeed,
+            logger: this._log,
+            blindPeerKeys: this._resolveBlindPeerKeys(invite.blindPeers),
+            blindPeeringOpts: this._blindPeeringOpts,
+            bootFrom: invite.fastForward,
+            wakeup: this._wakeup,
+            attachmentUrl: this._attachmentUrl
+        });
+        this._candidateMesh = candidate;
+        if (this._swarm)
+            this._swarm.join(candidate.discoveryKey, { server: true, client: true });
+        const onOpenCanceled = () => candidate.interruptBoot();
+        this._cancelCandidateJoin = onOpenCanceled;
+        const disarm = () => {
+            if (this._cancelCandidateJoin === onOpenCanceled)
+                this._cancelCandidateJoin = null;
+        };
+        try {
+            await candidate.ready();
+        }
+        catch (error) {
+            disarm();
+            this._candidateMesh = null;
+            if (this._swarm)
+                await this._swarm.leave(candidate.discoveryKey).catch(noop);
+            await candidate.close().catch(noop);
+            throw this._joinCancellation?.canceled ? new Error(MESH_JOIN_CANCELED) : error;
+        }
+        if (this._swarm)
+            candidate.startBlindPeering(this._swarm.dht);
+        try {
+            this._throwIfJoinCanceled();
+            await candidate.appendBirthOp(this._deviceKeyPair.publicKey, this._localDevice ?? undefined);
+            this._throwIfJoinCanceled();
+            if (!candidate.key.equals(invite.baseKey)) {
+                throw new Error('Device is not permitted to join the invited mesh');
+            }
+            if ((await candidate.checkResumedRevocation()) === 'kicked') {
+                throw new Error('Device is not permitted to join the invited mesh');
+            }
+            this._throwIfJoinCanceled();
+            disarm();
+            await this._waitForCandidateWritable(candidate);
+            if (!candidate.writable)
+                throw new Error('Device is not permitted to join the invited mesh');
+            this._throwIfJoinCanceled();
+            return candidate;
+        }
+        catch (error) {
+            await this._discardCandidateMesh();
+            throw this._joinCancellation?.canceled ? new Error(MESH_JOIN_CANCELED) : error;
+        }
+        finally {
+            disarm();
+        }
+    }
+    async _waitForCandidateWritable(candidate) {
+        if (candidate.writable)
+            return;
+        await new Promise((resolve, reject) => {
+            let offClose = noop;
+            const cleanup = () => {
+                candidate.autobee.off('writable', onWritable);
+                candidate.autobee.off('interrupt', onInterrupt);
+                candidate.off('kicked', onKicked);
+                offClose();
+                if (this._cancelCandidateJoin === onCanceled)
+                    this._cancelCandidateJoin = null;
+            };
+            const onWritable = () => {
+                cleanup();
+                resolve();
+            };
+            const onKicked = () => {
+                cleanup();
+                reject(new Error('Device is not permitted to join the invited mesh'));
+            };
+            const onInterrupt = (reason) => {
+                cleanup();
+                reject(reason instanceof Error ? reason : new Error('Apply interrupted'));
+            };
+            const onCanceled = () => {
+                cleanup();
+                reject(new Error(MESH_JOIN_CANCELED));
+            };
+            this._cancelCandidateJoin = onCanceled;
+            candidate.autobee.on('writable', onWritable);
+            candidate.autobee.on('interrupt', onInterrupt);
+            candidate.on('kicked', onKicked);
+            offClose = this._onClose(onCanceled);
+        });
+    }
+    _activateMesh(mesh, session) {
+        if (this._candidateMesh === mesh)
+            this._candidateMesh = null;
+        this._mesh = mesh;
+        this._meshSecretSeed = session.seed;
+        this._statusError = null;
+        this._upgradeRequired = null;
+        void this._closeConfigPeering().catch(noop);
+        if (mesh.writable)
+            this._kicked = false;
+        mesh.on('kicked', () => this._onKicked());
+        mesh.on('unattested-device', () => void this._settleMembership(mesh));
+        mesh.on('membership', (own) => void this._recordMembership(own));
+        mesh.autobee.on('writable', this._onMeshWritable);
+        mesh.autobee.on('error', this._onMeshDead);
+        mesh.autobee.on('close', this._onMeshDead);
+        mesh.autobee.on('interrupt', this._onMeshStalled);
+        this._startMeshServices(mesh);
+        this._notifyStatus();
+    }
+    _currentMesh() {
+        return this._mesh;
+    }
+    async _awaitMesh() {
+        if (this.closing)
+            return null;
+        if (!this.opened)
+            await this.ready();
+        return this._currentMesh();
+    }
+    _startMeshServices(mesh) {
+        const deviceId = this._deviceKeyPair.publicKey;
+        mesh.on('notification', (event) => this.emit('notification', event));
+        void mesh.refreshMembership().catch((error) => {
+            this._log?.warn(['p2p', 'mesh'], 'tallying membership failed', error);
+        });
+        mesh.on('chat-tombstone', (chatId, deletedAt) => {
+            void this.local
+                .clearChatNotify(chatId)
+                .catch((error) => this._log?.warn(['p2p', 'mesh'], 'chat-tombstone notification reclaim failed', error));
+            void removeChatAttachments(mesh, deviceId, chatId, deletedAt).catch((error) => this._log?.warn(['p2p', 'mesh'], 'chat-tombstone attachment reclaim failed', error));
+            void removeChatKnowledge(mesh, chatId, deletedAt).catch((error) => this._log?.warn(['p2p', 'mesh'], 'chat-tombstone knowledge reclaim failed', error));
+        });
+        const sweepLock = new ScopeLock({ debounce: true });
+        const sweep = async () => {
+            if (!(await sweepLock.lock()))
+                return;
+            try {
+                if (!mesh.closing)
+                    await mesh.files.sweepTombstones(deviceId);
+            }
+            catch (error) {
+                this._log?.warn(['p2p', 'mesh'], 'blob sweep failed', error);
+            }
+            finally {
+                sweepLock.unlock();
+            }
+        };
+        void sweep();
+        mesh.autobee.on('move-to', () => void sweep());
+        this._startIndexing();
+        this._hostedAgents = new HostedAgents({
+            mesh,
+            local: this.local,
+            deviceId,
+            catalog: () => this._hostSkills(),
+            send: (host, request) => this._secretHandoff.send(host, request),
+            onmoved: () => this._skillCatalog?.(null, null, { refresh: true }) ?? Promise.resolve(),
+            log: this._log
+        });
+        this._hostedAgents.start();
+    }
+    async _stopHostedAgents() {
+        const hosted = this._hostedAgents;
+        this._hostedAgents = null;
+        await hosted?.close();
+    }
+    async _discardCandidateMesh() {
+        const candidate = this._candidateMesh;
+        if (!candidate)
+            return;
+        this._candidateMesh = null;
+        if (this._swarm)
+            await this._swarm.leave(candidate.discoveryKey).catch(noop);
+        await candidate.close().catch(noop);
+    }
+    async _departureHasAudience(mesh) {
+        if (!mesh.writable)
+            return false;
+        const deviceId = this._deviceKeyPair.publicKey;
+        const snap = mesh.view.snapshot();
+        try {
+            for await (const device of snap.find('@qvac/devices')) {
+                if (!device.revoked && !device.id.equals(deviceId))
+                    return true;
+            }
+            return false;
+        }
+        finally {
+            await snap.close();
+        }
+    }
+    async _announceDeparture(mesh = this._mesh, strict = false) {
+        if (!mesh?.writable) {
+            if (strict)
+                throw new Error('Mesh departure requires a writable source');
+            return;
+        }
+        try {
+            await mesh.dispatch('remove-writer', {
+                writerKey: mesh.localWriterKey,
+                deviceId: this._deviceKeyPair.publicKey,
+                revokedAt: Date.now()
+            });
+            await mesh.autobee.update();
+        }
+        catch (error) {
+            this._log?.warn(['p2p', 'mesh'], 'writer departure announcement failed', error);
+            if (strict)
+                throw error;
+        }
+    }
+    async leaveMesh() {
+        if (this.closing)
+            return;
+        const mesh = await this._awaitMesh();
+        if (!mesh)
+            return;
+        if (this._leaving)
+            return;
+        if (this._minting)
+            throw new Error('Mesh transition already in progress');
+        this._leaving = true;
+        this._notifyStatus();
+        const landed = this._waitForMeshChange();
+        try {
+            if (await this._departureHasAudience(mesh))
+                await this.local.recordDeparture(mesh.key);
+            await this._announceDeparture();
+            this._requestFreshMesh().catch(() => { });
+            const error = await landed;
+            if (error)
+                throw error;
+        }
+        finally {
+            this._leaving = false;
+            this._notifyStatus();
+        }
+    }
+    async removeDeviceWriter(writerKey, deviceId) {
+        const mesh = await this._awaitMesh();
+        if (!mesh)
+            throw new Error('No active mesh');
+        await mesh.dispatch('remove-writer', { writerKey, deviceId, revokedAt: Date.now() });
+    }
+    async renameLocalDevice(name) {
+        const publicKey = this.devicePublicKey;
+        if (publicKey)
+            await this.local.renameDevice(publicKey, name);
+        if (this._localDevice)
+            this._localDevice = { ...this._localDevice, name };
+    }
+    async saveDeviceProfileLocal(capabilityProfile, recommendedModelName, platform) {
+        const publicKey = this.devicePublicKey;
+        if (publicKey) {
+            await this.local.saveDeviceProfile(publicKey, capabilityProfile, recommendedModelName, platform);
+        }
+        if (this._localDevice) {
+            this._localDevice = {
+                ...this._localDevice,
+                capabilityProfile,
+                recommendedModelName,
+                platform: platform ?? this._localDevice.platform
+            };
+        }
+    }
+    async waitForWritable() {
+        if (this.closing)
+            return;
+        await this.ready();
+        const mesh = await this._awaitMesh();
+        if (this.closing || !mesh)
+            return;
+        await Promise.race([mesh.waitForWritable(), this._closeSignal]);
+    }
+    async getMeshInvite() {
+        const mesh = await this._awaitMesh();
+        if (!mesh || !this._meshSecretSeed)
+            return null;
+        const auto = mesh.autobee;
+        const info = await auto.system.getInfo();
+        const head = info && info.view.length > 0 ? await auto.trusted.mostRecentTrusted(auto.view, null) : null;
+        const additionalNodes = this._swarm
+            ? this._swarm.dht.toArray({ limit: INVITE_DHT_NODES_LIMIT })
+            : [];
+        const snap = mesh.view.snapshot();
+        let blindPeerRows;
+        try {
+            blindPeerRows = await snap
+                .find('@qvac/mesh-blind-peers', { limit: INVITE_BLIND_PEERS_LIMIT })
+                .toArray();
+        }
+        finally {
+            await snap.close();
+        }
+        return {
+            baseKey: mesh.key,
+            seed: this._meshSecretSeed,
+            fastForward: head ? { key: head.key, length: head.length } : null,
+            additionalNodes,
+            blindPeers: blindPeerRows.map((row) => row.key)
+        };
+    }
+    async _closeSwarm() {
+        this._wakeup.destroy();
+        this._secretHandoff.destroy();
+        this._skillOverlayHandoff.destroy();
+        if (!this._swarm)
+            return;
+        const swarm = this._swarm;
+        this._swarm = null;
+        for (const conn of swarm.connections)
+            conn.destroy?.();
+        await swarm.destroy();
+    }
+    async pushSkillSecret(request) {
+        if (!this.opened)
+            await this.ready();
+        const mesh = this._mesh;
+        const deviceId = this.devicePublicKey;
+        if (!mesh || !deviceId)
+            throw new Error(NOT_THE_HOST);
+        const agent = await getAgent(mesh, request.agentId);
+        if (!agent)
+            throw new Error(NO_SUCH_AGENT);
+        if (!agent.providerDeviceId)
+            throw new Error(NOT_THE_HOST);
+        if (agent.providerDeviceId.equals(deviceId)) {
+            return this._storeHandedOffSecret(request, deviceId);
+        }
+        const host = await mesh.view.get('@qvac/devices', { id: agent.providerDeviceId });
+        if (!host || host.revoked)
+            throw new Error(HOST_REVOKED);
+        return this._secretHandoff.send(agent.providerDeviceId, request);
+    }
+    async _storeHandedOffSecret(request, fromDeviceId) {
+        const mesh = this._mesh;
+        const deviceId = this.devicePublicKey;
+        if (!mesh || !deviceId)
+            throw new Error(NOT_THE_HOST);
+        const receive = createSkillSecretReceiver({
+            mesh,
+            local: this.local,
+            deviceId,
+            setupFields: (skillName) => this._setupFields(skillName),
+            onstored: () => this._skillCatalog?.(null, null, { refresh: true }) ?? Promise.resolve()
+        });
+        return receive(request, fromDeviceId);
+    }
+    async _skillOverlayOp(agentId, op) {
+        const host = await this._resolveSkillOverlayHost(agentId);
+        if (!host)
+            return this._runLocalSkillOverlayOp(op);
+        return this._skillOverlayHandoff.send(host, { ...op, agentId });
+    }
+    async _resolveSkillOverlayHost(agentId) {
+        if (!agentId)
+            return null;
+        if (!this.opened)
+            await this.ready();
+        const mesh = this._mesh;
+        const deviceId = this.devicePublicKey;
+        if (!mesh || !deviceId)
+            throw new Error(NOT_THE_HOST);
+        const agent = await getAgent(mesh, agentId);
+        if (!agent)
+            throw new Error(NO_SUCH_AGENT);
+        if (!agent.providerDeviceId)
+            throw new Error(NOT_THE_HOST);
+        if (agent.providerDeviceId.equals(deviceId))
+            return null;
+        const host = await mesh.view.get('@qvac/devices', { id: agent.providerDeviceId });
+        if (!host || host.revoked)
+            throw new Error(HOST_REVOKED);
+        return agent.providerDeviceId;
+    }
+    async _serveSkillOverlayOp(op, fromDeviceId) {
+        const mesh = this._mesh;
+        const deviceId = this.devicePublicKey;
+        if (!mesh || !deviceId)
+            throw new Error(NOT_THE_HOST);
+        const receive = createSkillOverlayReceiver({
+            mesh,
+            deviceId,
+            runLocal: (op) => this._runLocalSkillOverlayOp(op)
+        });
+        return receive(op, fromDeviceId);
+    }
+    async _runLocalSkillOverlayOp(op) {
+        const mgmt = this._skillManagement;
+        switch (op.op) {
+            case 'list':
+                return { skills: ((await mgmt?.listManagedSkills()) ?? { skills: [] }).skills };
+            case 'read': {
+                const res = (await mgmt?.readSkillFile(op.name ?? '')) ?? { found: false };
+                return { found: res.found ?? false, content: res.content, origin: res.origin };
+            }
+            case 'write':
+                return {
+                    ok: ((await mgmt?.writeSkillFile(op.name ?? '', op.content ?? '')) ?? { ok: false }).ok
+                };
+            case 'copy':
+                return {
+                    copied: ((await mgmt?.copySkillForEdit(op.name ?? '')) ?? { copied: false }).copied
+                };
+            case 'delete':
+                return {
+                    removed: ((await mgmt?.deleteOverlaySkill(op.name ?? '')) ?? { removed: false }).removed
+                };
+            default:
+                throw new Error(`unknown skill overlay op: ${op.op}`);
+        }
+    }
+    async _setupFields(skillName) {
+        const skills = await this._hostSkills();
+        if (skills.length === 0)
+            return null;
+        const skill = skills.find((entry) => entry.name === skillName);
+        if (!skill)
+            return new Map();
+        const fields = new Map();
+        for (const slot of skill.credentials ?? []) {
+            for (const key of slot.split('|')) {
+                fields.set(key, true);
+                const stateKey = oauthStateKeyFor(key);
+                if (stateKey)
+                    fields.set(stateKey, true);
+            }
+        }
+        for (const route of skill.setup?.routes ?? []) {
+            if (route.credentialKey)
+                fields.set(route.credentialKey, true);
+            for (const field of route.fields ?? [])
+                fields.set(field.key, field.secret === true);
+        }
+        return fields;
+    }
+    async _hostSkills() {
+        await this._waitForCatalogHooks();
+        const catalog = await this._skillCatalog?.(null, null, { skipCredentialProbe: true });
+        return catalog?.skills ?? [];
+    }
+    _onConnection(conn) {
+        if (this.closing) {
+            conn.on('error', noop);
+            return;
+        }
+        this._trackPeerConnection(conn);
+        const remoteId = conn.remotePublicKey.toString('hex').slice(0, 8);
+        const start = Date.now();
+        let bytes = 0;
+        let connErr = null;
+        this._log?.info(['p2p', 'peer'], `got ${conn.isInitiator ? 'client' : 'server'} connection to ${remoteId}`);
+        conn.once('error', (err) => {
+            connErr = err;
+        });
+        conn.once('close', () => {
+            this._log?.info(['p2p', 'peer'], `connection closed to ${remoteId}, with err: ${connErr} (${Date.now() - start} ms ${bytes} bytes recv)`);
+        });
+        conn.on('data', (data) => {
+            bytes += data.byteLength;
+        });
+        this._wakeup.addStream(conn);
+        this._secretHandoff.addStream(conn);
+        this._skillOverlayHandoff.addStream(conn);
+        this._hostedAgents?.kick();
+        this.rootCorestore.replicate(conn);
+        this._mesh?.files.reconnect();
+    }
+    _trackPeerConnection(conn) {
+        this._peers.add(conn);
+        this._onPeerChange();
+        let removed = false;
+        const remove = () => {
+            if (removed)
+                return;
+            removed = true;
+            this._peers.delete(conn);
+            this._onPeerChange();
+        };
+        conn.once('close', remove);
+        conn.once('error', remove);
+    }
+    _onPeerChange() {
+        this._log?.info(['p2p', 'peer'], 'peer connections changed', {
+            connections: this._peers.size,
+            peers: this.peerDeviceIds.length
+        });
+        this._notifyStatus();
+    }
+    _meshStatusSource() {
+        return {
+            watch: (listener) => void this._statusListeners.add(listener),
+            unwatch: (listener) => void this._statusListeners.delete(listener),
+            snapshot: () => this._statusSnapshot(),
+            leave: () => this.leaveMesh(),
+            acknowledgeKicked: () => this.acknowledgeKicked(),
+            join: (invite) => this.joinMesh(invite),
+            cancelJoin: () => this.cancelMeshJoin(),
+            invite: async () => {
+                const invite = await this.getMeshInvite();
+                return invite ? encodeMeshInvite(invite) : null;
+            }
+        };
+    }
+    _networkStatusSource() {
+        const listeners = new Set();
+        let timer = null;
+        return {
+            watch: (listener) => {
+                listeners.add(listener);
+                if (timer)
+                    return;
+                timer = setInterval(() => {
+                    for (const fn of listeners)
+                        fn();
+                }, DIAGNOSTICS_SAMPLE_MS);
+                unref(timer);
+            },
+            unwatch: (listener) => {
+                listeners.delete(listener);
+                if (listeners.size === 0 && timer) {
+                    clearInterval(timer);
+                    timer = null;
+                }
+            },
+            snapshot: () => this._networkSnapshot()
+        };
+    }
+    _networkSnapshot() {
+        const dht = this._swarm ? this._swarm.dht : null;
+        return {
+            state: this._networkState(dht),
+            peerCount: this.peerDeviceIds.length
+        };
+    }
+    _networkState(dht) {
+        if (!dht?.online)
+            return 'offline';
+        if (dht.degraded)
+            return 'degraded';
+        return 'online';
+    }
+    _logSource() {
+        const log = this._log;
+        if (!log)
+            return null;
+        return {
+            backfill: () => log.backfill(),
+            subscribe: (listener) => log.subscribe(listener),
+            unsubscribe: (listener) => log.unsubscribe(listener),
+            write: (input) => log.appendClient({ ...input, originDeviceId: this.devicePublicKey ?? undefined })
+        };
+    }
+    compact(force = false) {
+        if (!force) {
+            return this.storage.compact();
+        }
+        return this.storage.compact({
+            blobGarbageCollectionPolicy: RocksConstants.garbageCollectionPolicy.FORCE,
+            blobGarbageCollectionAgeCutoff: 1.0,
+            bottommostLevelCompaction: RocksConstants.bottommostLevelCompaction.FORCE
+        });
+    }
+    registerDiagnostics(provider) {
+        this._diagnosticsProviders.add(provider);
+        return () => void this._diagnosticsProviders.delete(provider);
+    }
+    registerListModels(hook) {
+        this._listModels = hook;
+        return () => {
+            if (this._listModels === hook)
+                this._listModels = null;
+        };
+    }
+    registerDeleteModel(hook) {
+        this._deleteModel = hook;
+        return () => {
+            if (this._deleteModel === hook)
+                this._deleteModel = null;
+        };
+    }
+    registerClearKvCache(hook) {
+        this._clearKvCache = hook;
+        return () => {
+            if (this._clearKvCache === hook)
+                this._clearKvCache = null;
+        };
+    }
+    registerDeleteChatKvCache(hook) {
+        this._deleteChatKvCache = hook;
+        return () => {
+            if (this._deleteChatKvCache === hook)
+                this._deleteChatKvCache = null;
+        };
+    }
+    registerCompactChat(hook) {
+        this._compactChat = hook;
+        return () => {
+            if (this._compactChat === hook)
+                this._compactChat = null;
+        };
+    }
+    registerModelCatalogWatch(hook) {
+        this._modelCatalogWatch = hook;
+        this._openModelCatalogWatchSource();
+        return () => {
+            if (this._modelCatalogWatch !== hook)
+                return;
+            this._modelCatalogWatch = null;
+            if (!this.closing)
+                this._resetModelCatalogWatchSource();
+        };
+    }
+    async *_watchModelCatalog() {
+        while (!this.closing) {
+            const source = this._modelCatalogWatchSource;
+            try {
+                await source.ready();
+            }
+            catch {
+                return;
+            }
+            const watch = this._modelCatalogWatch;
+            if (!watch)
+                continue;
+            yield* watch();
+            return;
+        }
+    }
+    _openModelCatalogWatchSource() {
+        if (!this._modelCatalogWatch || !this._modelCatalogWatchSource.enter())
+            return;
+        this._modelCatalogWatchSource.exit();
+    }
+    _resetModelCatalogWatchSource() {
+        this._modelCatalogWatchSource = new ReadyGuard();
+        void this._modelCatalogWatchSource.ready().catch(noop);
+    }
+    registerRetryModelDownload(hook) {
+        this._retryModelDownload = hook;
+        return () => {
+            if (this._retryModelDownload === hook)
+                this._retryModelDownload = null;
+        };
+    }
+    registerSkills(hook) {
+        this._skills = hook;
+        return () => {
+            if (this._skills === hook)
+                this._skills = null;
+        };
+    }
+    registerSkillCatalog(hook) {
+        this._skillCatalog = hook;
+        this._openCatalogHooks();
+        return () => {
+            if (this._skillCatalog === hook)
+                this._skillCatalog = null;
+        };
+    }
+    registerSkillManagement(hooks) {
+        this._skillManagement = hooks;
+        return () => {
+            if (this._skillManagement === hooks)
+                this._skillManagement = null;
+        };
+    }
+    async _waitForCatalogHooks() {
+        if (!this._hostsModelSource)
+            return;
+        await this._catalogHooks.ready();
+    }
+    _catalogHooksReady() {
+        if (!this._hostsModelSource)
+            return true;
+        return this._skillCatalog !== null && this._tools !== null;
+    }
+    _openCatalogHooks() {
+        if (!this._catalogHooksReady() || !this._catalogHooks.enter())
+            return;
+        this._catalogHooks.exit();
+    }
+    registerTools(hook) {
+        this._tools = hook;
+        this._openCatalogHooks();
+        return () => {
+            if (this._tools === hook)
+                this._tools = null;
+        };
+    }
+    registerEmbedder(embedder, extractors) {
+        this._embedder = embedder;
+        this._ragExtractors = extractors ?? this._ragExtractors;
+        this._vectorIndex = this._vectorIndex ?? new MemoryVectorIndex();
+        const settled = this._reconcileIndexing();
+        settled.catch((err) => this._log?.warn(['indexing'], 'reconcile failed', err));
+        return () => {
+            if (this._embedder !== embedder)
+                return settled;
+            this._embedder = null;
+            return this._reconcileIndexing();
+        };
+    }
+    async _reconcileIndexing() {
+        await this._indexingLock.lock();
+        try {
+            if (this.closing)
+                return;
+            if (this._indexedEmbedder && this._indexedEmbedder !== this._embedder) {
+                await this._stopIndexing();
+            }
+            this._startIndexing();
+        }
+        finally {
+            this._indexingLock.unlock();
+        }
+    }
+    _startIndexing() {
+        if (!this._mesh || !this._embedder || this._processingFiles)
+            return;
+        this._vectorIndex ??= new MemoryVectorIndex();
+        this._processingFiles = this._mesh.files;
+        this._processingFiles.startProcessing({
+            embedder: this._embedder,
+            index: this._vectorIndex,
+            deviceId: this.devicePublicKey,
+            extractors: this._ragExtractors
+        });
+        this._indexedEmbedder = this._embedder;
+    }
+    async _stopIndexing() {
+        this._indexedEmbedder = null;
+        if (this._processingFiles && !(await this._processingFiles.stopProcessing())) {
+            this._vectorIndex = null;
+        }
+        this._processingFiles = null;
+    }
+    registerTranscribe(hook) {
+        this._transcribe = hook;
+        return () => {
+            if (this._transcribe === hook)
+                this._transcribe = null;
+        };
+    }
+    registerSpeak(hook) {
+        this._speak = hook;
+        return () => {
+            if (this._speak === hook)
+                this._speak = null;
+        };
+    }
+    registerSpeakStream(hook) {
+        this._speakStream = hook;
+        return () => {
+            if (this._speakStream === hook)
+                this._speakStream = null;
+        };
+    }
+    _diagnosticsSource() {
+        const listeners = new Set();
+        let timer = null;
+        return {
+            watch: (listener) => {
+                listeners.add(listener);
+                if (timer)
+                    return;
+                timer = setInterval(() => {
+                    for (const fn of listeners)
+                        fn();
+                }, DIAGNOSTICS_SAMPLE_MS);
+                unref(timer);
+            },
+            unwatch: (listener) => {
+                listeners.delete(listener);
+                if (listeners.size === 0 && timer) {
+                    clearInterval(timer);
+                    timer = null;
+                }
+            },
+            snapshot: () => {
+                const merged = { ...this._diagnostics() };
+                for (const provider of this._diagnosticsProviders)
+                    Object.assign(merged, provider());
+                return merged;
+            }
+        };
+    }
+    _memberDiagnostics(mesh) {
+        const memberId = mesh.ourMemberId?.toString('hex') ?? null;
+        return {
+            ...mesh.membership,
+            memberId,
+            mintedOurRoot: memberId !== null && memberId === this._identityPublicKey
+        };
+    }
+    _diagnostics() {
+        const mesh = this._mesh;
+        const swarm = this._swarm;
+        const dht = swarm ? swarm.dht : null;
+        const system = this._systemInfo?.snapshot() ?? { cpu: null, gpu: null };
+        const publicKey = this.devicePublicKey?.toString('hex');
+        const device = this._localDevice;
+        return {
+            device: publicKey,
+            deviceInfo: device && publicKey
+                ? {
+                    publicKey,
+                    name: device.name,
+                    capabilityProfile: device.capabilityProfile,
+                    recommendedModelName: device.recommendedModelName
+                }
+                : null,
+            state: this._statusState(),
+            mesh: mesh
+                ? {
+                    key: mesh.key.toString('hex'),
+                    discoveryKey: mesh.discoveryKey.toString('hex'),
+                    writable: mesh.writable,
+                    localLength: mesh.localLength,
+                    systemLength: mesh.autobee.system.bee.head()?.length ?? 0,
+                    viewLength: mesh.view.db.head()?.length ?? 0,
+                    flushes: mesh.autobee.system.flushes,
+                    fastForwards: mesh.autobee.stats.fastForwards,
+                    member: this._memberDiagnostics(mesh),
+                    orphanedBlobSweep: mesh.orphanedBlobSweepStatus,
+                    blindPeerCount: mesh.blindPeerKeys.length,
+                    blindPeers: mesh.blindPeerStats()
+                }
+                : null,
+            network: dht
+                ? {
+                    online: dht.online ?? null,
+                    degraded: dht.degraded ?? null,
+                    nodes: dht.nodes?.length ?? 0,
+                    host: dht.host,
+                    port: dht.port,
+                    connections: this._peers.size,
+                    peers: this.peerDeviceIds.length,
+                    stats: dht.stats,
+                    health: dht.health?.stats ?? null,
+                    config: dht.config ?? null
+                }
+                : null,
+            process: top.toJSON(),
+            cpu: system.cpu,
+            gpu: system.gpu
+        };
+    }
+    _statusSnapshot() {
+        const peerDeviceIds = [...this.peerDeviceIds];
+        const mesh = this._mesh;
+        return {
+            state: this._statusState(),
+            writable: mesh?.writable ?? false,
+            peerCount: peerDeviceIds.length,
+            peerDeviceIds,
+            meshKey: mesh?.key,
+            discoveryKey: mesh?.discoveryKey,
+            kickedPending: this._kickedPending,
+            error: this._statusError ?? undefined
+        };
+    }
+    acknowledgeKicked() {
+        if (!this._kickedPending)
+            return;
+        this._kickedPending = false;
+        this._notifyStatus();
+    }
+    _statusState() {
+        if (this._statusError)
+            return 'error';
+        if (this.closing || this._leaving)
+            return 'leaving';
+        if (this._kicked)
+            return 'kicked';
+        if (this._upgradeRequired)
+            return 'needs-upgrade';
+        if (this._minting)
+            return 'joining';
+        if (this._mesh)
+            return this._mesh.writable ? 'joined' : 'joining';
+        return 'idle';
+    }
+    _notifyStatus() {
+        for (const listener of [...this._statusListeners])
+            listener();
+    }
+}
+function noop() { }
+async function closeConfigReader(reader) {
+    if (!reader)
+        return;
+    await reader.core.close().catch(noop);
+    await reader.close().catch(noop);
+}
+async function recordedBlockIsLocal(core) {
+    await raceResource(core, core.ready(), 'config core');
+    const length = Number((await raceResource(core, core.getUserData('hyperconf'), 'config core')) || '0');
+    if (length <= 0)
+        return true;
+    return raceResource(core, core.has(length - 1), 'config core');
+}
+function statusErrorMessage(context, err) {
+    const detail = err instanceof Error ? err.message : err ? String(err) : '';
+    return detail ? `${context}: ${detail}` : context;
+}