@platless/axom-cli 0.6.36 → 0.6.52

package/dist/workstation/runtime/deviceRuntime.js

@@ -0,0 +1,568 @@
+import { createHash } from 'node:crypto';
+import { LocalControlError } from '../control/protocol.js';
+import { assertRemovalNamespace } from '../registrations/migration.js';
+export class TargetAdmissionPendingError extends Error {
+    hold;
+    constructor(hold, cause) {
+        super(`Target admission disposition remains pending: ${cause instanceof Error ? cause.message : 'Verification unavailable'}`, { cause });
+        this.hold = hold;
+    }
+}
+export class DeviceRuntime {
+    options;
+    members = new Map();
+    shutdown = new AbortController();
+    queue = Promise.resolve();
+    closing = false;
+    settledMembers = new Map();
+    targetHolds = new WeakMap();
+    pins = new Map();
+    maintenance;
+    membershipMutation;
+    constructor(options) {
+        this.options = options;
+    }
+    desktopActivity() {
+        try {
+            const value = this.options.desktopActivity?.() ?? { known: true, consumers: 0 };
+            if (typeof value.known !== 'boolean' || !Number.isSafeInteger(value.consumers) || value.consumers < 0 || value.consumers > 65536)
+                throw Error('invalid_desktop_activity');
+            return { ...value };
+        }
+        catch {
+            return { known: false, consumers: 1 };
+        }
+    }
+    snapshot() {
+        const registrations = [...this.members.values()].map(member => {
+            const pending = [...this.pins.get(member) ?? []].find(pin => pin.diagnostic);
+            const diagnostic = member.diagnostic ?? pending?.diagnostic;
+            return { id: member.registration.id, revision: member.registration.revision, state: member.state, ...(diagnostic ? { diagnostic } : {}), ...(member.cleanupPending ? { cleanupPending: true } : {}), ...(pending ? { admissionPending: true } : {}) };
+        });
+        return { stopped: this.shutdown.signal.aborted, desktopActivity: this.desktopActivity(), deviceRevision: createHash('sha256').update(JSON.stringify(registrations.map(member => [member.id, member.revision]))).digest('hex'), registrations };
+    }
+    enqueue(work) {
+        const result = this.queue.then(work);
+        this.queue = result.catch(() => { });
+        return result;
+    }
+    assertMutationAllowed() {
+        if (this.maintenance)
+            throw new LocalControlError('BUSY', 'Device update or maintenance owns membership admission');
+    }
+    beginMembershipMutation() {
+        this.assertMutationAllowed();
+        if (this.membershipMutation)
+            throw new LocalControlError('BUSY', 'An original membership mutation is already pending');
+        const original = {};
+        this.membershipMutation = original;
+        return () => { if (this.membershipMutation === original)
+            this.membershipMutation = undefined; };
+    }
+    registrationIdentity(id) {
+        const member = this.members.get(id);
+        return member?.state === 'running' && !member.cleanupPending ? Object.freeze({ ...member.registration }) : undefined;
+    }
+    acquireMaintenance(input) {
+        this.assertMutationAllowed();
+        if (this.membershipMutation)
+            throw new LocalControlError('BUSY', 'Original membership mutation must settle before maintenance');
+        if (!input.transactionId || this.closing || this.shutdown.signal.aborted)
+            throw new LocalControlError('BUSY', 'Device is not available for maintenance');
+        if (input.origin && this.registrationIdentity(input.origin.registrationId)?.revision !== input.origin.revision)
+            throw new LocalControlError('BINDING_CONFLICT', 'Update origin changed');
+        const state = { transactionId: input.transactionId, members: [], holds: [], released: false };
+        this.maintenance = state;
+        const ready = state.ready = (async () => {
+            await this.enqueue(async () => {
+                if (this.maintenance !== state || this.closing || this.shutdown.signal.aborted)
+                    throw new LocalControlError('BUSY', 'Original maintenance reservation changed');
+                state.members = [...this.members.values()];
+                const inspection = await this.options.store.inspect();
+                if ((await this.options.store.removalIntents?.() ?? []).some(intent => !['completed', 'cancelled'].includes(intent.phase)))
+                    throw new LocalControlError('OUTCOME_UNKNOWN', 'An original persistent removal obligation prevents device maintenance');
+                if (!inspection.known || inspection.entries.length !== state.members.length || inspection.entries.some(entry => entry.state !== 'ready' || !state.members.some(member => member.registration.id === entry.id && member.registration.revision === entry.registration.revision)))
+                    throw new LocalControlError('OUTCOME_UNKNOWN', 'Original persistent membership and running members differ');
+                if (state.members.some(member => member.state !== 'running' || !member.runtime || member.cleanupPending || this.pins.get(member)?.size))
+                    throw new LocalControlError('OUTCOME_UNKNOWN', 'Original membership or admission is unsettled');
+            });
+            for (const member of state.members) {
+                let hold;
+                try {
+                    hold = await this.prepareAdmission({ id: member.registration.id, expectedRevision: member.registration.revision, operationId: state.transactionId }, undefined, state);
+                }
+                catch (error) {
+                    if (error instanceof TargetAdmissionPendingError)
+                        state.holds.push({ hold: error.hold });
+                    throw error;
+                }
+                const original = { hold };
+                state.holds.push(original);
+                original.resources = await this.prepareTargetResources(hold);
+                const pin = this.originalPin(hold);
+                if (!pin.inner || !pin.runtime.holdTargetEvidenceAdmission)
+                    throw new LocalControlError('OUTCOME_UNKNOWN', 'Original evidence maintenance admission is unavailable');
+                await pin.runtime.holdTargetEvidenceAdmission(pin.inner);
+            }
+            for (const member of state.members)
+                await member.runtime?.releaseStartupAdmission?.();
+        })();
+        void ready.catch(() => { });
+        return Object.freeze({ transactionId: input.transactionId, ready,
+            observe: async () => {
+                await ready;
+                if (this.maintenance !== state || state.released)
+                    throw new LocalControlError('BINDING_CONFLICT', 'Original maintenance lease is no longer current');
+                const outcomes = await Promise.allSettled(state.holds.map(original => this.observeTargetResources(original.hold, original.resources)));
+                const desktop = this.desktopActivity();
+                const diagnostics = outcomes.flatMap(result => result.status === 'rejected' ? ['Original resource observation remains unknown'] : result.value.diagnostics);
+                if (!desktop.known)
+                    diagnostics.push('Original device desktop obligations remain unknown');
+                const busy = desktop.consumers > 0 || outcomes.some(result => result.status === 'fulfilled' && result.value.status === 'busy');
+                const unknown = !desktop.known || outcomes.some(result => result.status === 'rejected' || result.value.status === 'unknown');
+                return { status: busy ? 'busy' : unknown || diagnostics.length ? 'unknown' : 'candidate', diagnostics };
+            },
+            release: complete => {
+                if (state.released)
+                    return Promise.resolve();
+                if (state.releasing)
+                    return state.releasing;
+                state.releasing = (async () => {
+                    await ready.catch(() => { });
+                    const failures = [];
+                    for (const original of state.holds) {
+                        if (original.released)
+                            continue;
+                        try {
+                            if (original.resources)
+                                await this.releaseTargetResources(original.hold, original.resources);
+                            else
+                                await this.releaseTargetAdmission(original.hold);
+                            original.released = true;
+                        }
+                        catch (error) {
+                            failures.push(error);
+                        }
+                    }
+                    if (failures.length)
+                        throw new AggregateError(failures, `Original maintenance restoration remains unknown; preserve the update reservation: ${failures.map(error => error instanceof Error ? error.message : 'Unknown original restoration failure').join('; ').slice(0, 512)}`);
+                    await complete?.();
+                    await this.enqueue(async () => {
+                        if (this.maintenance !== state)
+                            throw new LocalControlError('OUTCOME_UNKNOWN', 'Original maintenance reservation changed');
+                        state.released = true;
+                        this.maintenance = undefined;
+                    });
+                })().finally(() => { state.releasing = undefined; });
+                return state.releasing;
+            },
+            handoff: async () => {
+                await ready;
+                if (this.maintenance !== state || state.released)
+                    throw new LocalControlError('BINDING_CONFLICT', 'Original device handoff reservation changed');
+                for (const original of state.holds) {
+                    const observation = await this.observeTargetResources(original.hold, original.resources);
+                    if (observation.status !== 'candidate')
+                        throw new LocalControlError('OUTCOME_UNKNOWN', 'Original device handoff is not positively idle');
+                }
+                const before = this.desktopActivity();
+                if (!before.known || before.consumers)
+                    throw new LocalControlError('OUTCOME_UNKNOWN', 'Original desktop handoff remains unsettled');
+                await this.stop('detach');
+                const after = this.desktopActivity();
+                if (!after.known || after.consumers)
+                    throw new LocalControlError('OUTCOME_UNKNOWN', 'Original desktop cleanup did not confirm handoff');
+            },
+        });
+    }
+    reconcile() {
+        return this.enqueue(async () => {
+            this.assertMutationAllowed();
+            if (this.closing || this.shutdown.signal.aborted)
+                return;
+            const exclusions = new Set((await this.options.store.removalIntents?.() ?? []).filter(intent => !['completed', 'cancelled'].includes(intent.phase)).map(intent => intent.registration.id));
+            const inspection = await this.options.store.inspect();
+            if (!inspection.known)
+                throw new LocalControlError('OUTCOME_UNKNOWN', 'Registration collection needs verification');
+            const enrollments = await this.options.store.pendingEnrollments?.() ?? [];
+            if (enrollments.some(enrollment => enrollment.registrationId === null))
+                throw new LocalControlError('OUTCOME_UNKNOWN', 'Pending enrollment identity needs verification before runtime startup');
+            for (const enrollment of enrollments)
+                if (enrollment.registrationId)
+                    exclusions.add(enrollment.registrationId);
+            const desired = new Map(inspection.entries.filter(entry => entry.state === 'ready').map(entry => [entry.id, entry.registration]));
+            for (const [id, member] of this.members) {
+                if (exclusions.has(id))
+                    continue;
+                const sameRevision = desired.get(id)?.revision === member.registration.revision;
+                const pins = this.pins.get(member);
+                if (pins?.size) {
+                    // A disposed target disappears from the Store before its hold is finalized. Keep that
+                    // expected removal valid; a replacement identity or failed cleanup still invalidates it.
+                    if (!sameRevision || member.cleanupPending)
+                        for (const pin of pins) {
+                            if (!pin.disposed || desired.has(id) || member.cleanupPending)
+                                pin.stale = true;
+                        }
+                    continue;
+                }
+                if (sameRevision && !member.cleanupPending)
+                    continue;
+                try {
+                    await member.runtime?.pauseAdmission().catch(() => { });
+                    await member.runtime?.stop('detach');
+                    this.members.delete(id);
+                }
+                catch {
+                    member.state = 'failed';
+                    member.cleanupPending = true;
+                    member.diagnostic = 'Owned cleanup needs verification';
+                }
+            }
+            for (const registration of desired.values()) {
+                if (exclusions.has(registration.id))
+                    continue;
+                const previous = this.members.get(registration.id);
+                const now = (this.options.now ?? Date.now)();
+                if (previous && (this.pins.get(previous)?.size || previous.state === 'running' || previous.cleanupPending || (previous.retryAt ?? 0) > now))
+                    continue;
+                let runtime;
+                try {
+                    const identity = await this.options.store.read(registration.id);
+                    if (identity.registration.revision !== registration.revision)
+                        throw new LocalControlError('BINDING_CONFLICT', 'Registration changed during reconciliation');
+                    runtime = await this.options.factory(identity);
+                    await runtime.start();
+                    this.members.set(registration.id, { registration, runtime, state: 'running' });
+                }
+                catch (error) {
+                    let cleanupPending = false;
+                    try {
+                        await runtime?.stop('detach');
+                    }
+                    catch {
+                        cleanupPending = true;
+                    }
+                    const attempts = (previous?.attempts ?? 0) + 1;
+                    this.members.set(registration.id, { registration, ...(cleanupPending ? { runtime, cleanupPending } : {}), state: 'failed', attempts, retryAt: now + Math.min(30_000, 1_000 * 2 ** Math.min(attempts - 1, 5)), diagnostic: cleanupPending ? 'Owned startup cleanup needs verification' : error instanceof LocalControlError ? error.code : 'Registration startup failed' });
+                }
+            }
+        });
+    }
+    /** Adopt a pending removal's durable sessions with new work paused, without starting other excluded registrations. */
+    async recoverRemovalRuntime(target) {
+        let recovered;
+        await this.enqueue(async () => {
+            this.assertMutationAllowed();
+            if (this.closing || this.shutdown.signal.aborted)
+                throw new LocalControlError('BUSY', 'Device is stopping');
+            const intent = (await this.options.store.removalIntents?.() ?? []).find(entry => entry.operationId === target.operationId);
+            if (!intent || intent.registration.id !== target.id || intent.registration.revision !== target.expectedRevision
+                || !['intent', 'sealed'].includes(intent.phase))
+                throw new LocalControlError('BINDING_CONFLICT', 'Pending removal target changed');
+            const existing = this.members.get(target.id);
+            if (existing) {
+                if (existing.registration.revision !== target.expectedRevision || existing.state !== 'running' || existing.cleanupPending)
+                    throw new LocalControlError('OUTCOME_UNKNOWN', 'Target runtime cleanup remains pending');
+                return;
+            }
+            const identity = await this.options.store.read(target.id);
+            if (JSON.stringify(identity.registration) !== JSON.stringify(intent.registration))
+                throw new LocalControlError('BINDING_CONFLICT', 'Pending removal identity changed');
+            const runtime = await this.options.factory(identity);
+            try {
+                await runtime.pauseAdmission();
+                await runtime.start();
+                recovered = runtime;
+                this.members.set(target.id, { registration: identity.registration, runtime, state: 'running' });
+            }
+            catch (error) {
+                try {
+                    await runtime.stop('detach');
+                }
+                catch {
+                    this.members.set(target.id, { registration: identity.registration, runtime, state: 'failed', cleanupPending: true, diagnostic: 'Removal startup cleanup remains pending' });
+                }
+                throw error;
+            }
+        });
+        return async () => {
+            if (!recovered)
+                return;
+            await this.enqueue(async () => {
+                const member = this.members.get(target.id);
+                if (!member || member.runtime !== recovered || member.registration.revision !== target.expectedRevision || this.closing || this.shutdown.signal.aborted)
+                    throw new LocalControlError('BINDING_CONFLICT', 'Recovered target runtime changed');
+                await recovered.resumeAdmission();
+            });
+        };
+    }
+    async prepareTargetAdmission(target, beforeRestore) {
+        return this.prepareAdmission(target, beforeRestore);
+    }
+    async prepareAdmission(target, beforeRestore, maintenance) {
+        const hold = Object.freeze({});
+        let pin;
+        await this.enqueue(async () => {
+            if (this.maintenance && this.maintenance !== maintenance)
+                throw new LocalControlError('BUSY', 'Device maintenance owns target admission');
+            const member = this.members.get(target.id);
+            if (this.closing || this.shutdown.signal.aborted || !target.operationId || !member?.runtime?.prepareTargetAdmission || member.state !== 'running' || member.cleanupPending || member.registration.revision !== target.expectedRevision)
+                throw new LocalControlError('BINDING_CONFLICT', 'Target runtime is unavailable or changed');
+            pin = { member, runtime: member.runtime, id: target.id, revision: target.expectedRevision, operationId: target.operationId, active: true, stale: false, beforeRestore };
+            const pins = this.pins.get(member) ?? new Set();
+            pins.add(pin);
+            this.pins.set(member, pins);
+            this.targetHolds.set(hold, pin);
+        });
+        try {
+            pin.inner = await pin.runtime.prepareTargetAdmission(target);
+            const identity = await this.options.store.read(pin.id);
+            await this.enqueue(async () => {
+                if (identity.registration.revision !== pin.revision)
+                    pin.stale = true;
+                this.originalPin(hold);
+            });
+            return hold;
+        }
+        catch (error) {
+            await this.enqueue(async () => {
+                if (!pin.inner) {
+                    this.unpin(pin);
+                    return;
+                }
+                pin.diagnostic = 'Target admission identity needs verification';
+                if (pin.stale)
+                    this.retirePin(pin);
+            });
+            if (pin.inner)
+                throw new TargetAdmissionPendingError(hold, error);
+            throw error;
+        }
+    }
+    originalPin(hold) {
+        const pin = this.targetHolds.get(hold);
+        if (!pin || pin.stale || this.shutdown.signal.aborted || this.members.get(pin.id) !== pin.member || pin.member.runtime !== pin.runtime || pin.member.registration.revision !== pin.revision)
+            throw new LocalControlError('BINDING_CONFLICT', 'Invalid or stale target admission hold');
+        return pin;
+    }
+    unpin(pin) {
+        pin.active = false;
+        const pins = this.pins.get(pin.member);
+        pins?.delete(pin);
+        if (pins?.size === 0)
+            this.pins.delete(pin.member);
+    }
+    retirePin(pin) {
+        pin.stale = true;
+        if (this.members.get(pin.id) === pin.member) {
+            pin.member.state = 'failed';
+            pin.member.cleanupPending = true;
+            pin.member.diagnostic = 'Changed target admission requires original runtime cleanup';
+        }
+        this.unpin(pin);
+    }
+    observeTargetAdmission(hold) {
+        const pin = this.originalPin(hold);
+        if (!pin.active || !pin.inner || !pin.runtime.observeTargetAdmission)
+            throw new LocalControlError('OUTCOME_UNKNOWN', 'Target preparation is unavailable');
+        const observation = pin.runtime.observeTargetAdmission(pin.inner);
+        return pin.diagnostic ? { ...observation, status: 'unknown', diagnostics: [pin.diagnostic, ...observation.diagnostics] } : observation;
+    }
+    async prepareTargetResources(hold) {
+        const pin = this.originalPin(hold);
+        if (!pin.active || !pin.inner || !pin.runtime.prepareTargetResources)
+            throw new LocalControlError('OUTCOME_UNKNOWN', 'Original target resource preparation is unavailable');
+        if (pin.resources)
+            throw new LocalControlError('BUSY', 'Original target resources are already prepared');
+        const preparation = await pin.runtime.prepareTargetResources(pin.inner, () => this.releaseTargetAdmission(hold));
+        if (this.originalPin(hold) !== pin)
+            throw new LocalControlError('BINDING_CONFLICT', 'Original target changed during preparation');
+        pin.resources = preparation;
+        return preparation;
+    }
+    resourcePin(hold, preparation) {
+        const pin = this.originalPin(hold);
+        if (!pin.active || pin.disposed || pin.resources !== preparation)
+            throw new LocalControlError('BINDING_CONFLICT', 'Invalid or stale original target resources');
+        return pin;
+    }
+    async observeTargetResources(hold, preparation) {
+        const pin = this.resourcePin(hold, preparation);
+        if (!pin.runtime.observeTargetResources)
+            throw new LocalControlError('OUTCOME_UNKNOWN', 'Original resource observer is unavailable');
+        const observation = await pin.runtime.observeTargetResources(preparation);
+        this.resourcePin(hold, preparation);
+        return observation;
+    }
+    async sealTargetResources(hold, preparation, mode) {
+        const pin = this.resourcePin(hold, preparation);
+        if (!pin.runtime.sealTargetResources)
+            throw new LocalControlError('OUTCOME_UNKNOWN', 'Original birth boundary is unavailable');
+        await pin.runtime.sealTargetResources(preparation, mode);
+        this.resourcePin(hold, preparation);
+    }
+    async settleTargetResources(hold, preparation, namespace) {
+        const pin = this.resourcePin(hold, preparation);
+        assertRemovalNamespace(namespace);
+        if (namespace.registrationId !== pin.id || namespace.revision !== pin.revision || !pin.runtime.settleTargetResources)
+            throw new LocalControlError('BINDING_CONFLICT', 'Original resource namespace changed');
+        const settlement = await pin.runtime.settleTargetResources(preparation, namespace);
+        this.resourcePin(hold, preparation);
+        assertRemovalNamespace(namespace);
+        return settlement;
+    }
+    async disposeTargetResources(hold, preparation, settlement, namespace) {
+        const pin = this.resourcePin(hold, preparation);
+        assertRemovalNamespace(namespace);
+        if (namespace.registrationId !== pin.id || namespace.revision !== pin.revision || !pin.runtime.disposeTargetResources)
+            throw new LocalControlError('BINDING_CONFLICT', 'Original disposition namespace changed');
+        await pin.runtime.disposeTargetResources(settlement, namespace);
+        this.resourcePin(hold, preparation);
+        assertRemovalNamespace(namespace);
+        pin.disposed = true;
+        pin.diagnostic = 'Target resources disposed; durable removal remains pending';
+    }
+    async prepareTargetDisposition(hold, preparation, namespace) {
+        const pin = this.resourcePin(hold, preparation);
+        assertRemovalNamespace(namespace);
+        if (namespace.registrationId !== pin.id || namespace.revision !== pin.revision || !pin.runtime.prepareTargetDisposition)
+            throw new LocalControlError('BINDING_CONFLICT', 'Original target disposition preparation changed');
+        const settlement = await pin.runtime.prepareTargetDisposition(preparation, namespace);
+        this.resourcePin(hold, preparation);
+        assertRemovalNamespace(namespace);
+        return settlement;
+    }
+    async releaseTargetResources(hold, preparation) {
+        const pin = this.originalPin(hold);
+        if (pin.disposed || pin.resources !== preparation)
+            throw new LocalControlError('BINDING_CONFLICT', 'Invalid or stale original target resources');
+        if (pin.resourcesReleased)
+            return;
+        if (!pin.runtime.releaseTargetResources)
+            throw new LocalControlError('OUTCOME_UNKNOWN', 'Original resource restoration is unavailable');
+        await pin.runtime.releaseTargetResources(preparation);
+        if (this.originalPin(hold) !== pin || pin.active)
+            throw new LocalControlError('OUTCOME_UNKNOWN', 'Original target admission restoration is incomplete');
+        pin.resourcesReleased = true;
+    }
+    async releaseTargetAdmission(hold) {
+        const original = this.targetHolds.get(hold);
+        if (!original)
+            throw new LocalControlError('BINDING_CONFLICT', 'Invalid target admission hold');
+        if (!original.active && !original.stale) {
+            this.originalPin(hold);
+            return;
+        }
+        if (original.restoration)
+            return original.restoration;
+        let restoration;
+        let identity;
+        try {
+            identity = await this.options.store.read(original.id);
+        }
+        catch (error) {
+            await this.enqueue(async () => { original.diagnostic = 'Target admission identity needs verification'; });
+            throw new TargetAdmissionPendingError(hold, error);
+        }
+        await this.enqueue(async () => {
+            if (identity.registration.revision !== original.revision)
+                original.stale = true;
+            try {
+                const pin = this.originalPin(hold);
+                if (!pin.inner || !pin.runtime.releaseTargetAdmission)
+                    throw new LocalControlError('OUTCOME_UNKNOWN', 'Target restoration is unavailable');
+                restoration = pin.restoration ??= this.restorePin(pin, hold);
+            }
+            catch (error) {
+                if (original.stale || this.shutdown.signal.aborted)
+                    this.retirePin(original);
+                else
+                    original.diagnostic = 'Target admission restoration needs verification';
+                throw new TargetAdmissionPendingError(hold, error);
+            }
+        });
+        await restoration;
+    }
+    async restorePin(original, hold) {
+        try {
+            await original.beforeRestore?.();
+            await original.runtime.releaseTargetAdmission(original.inner);
+        }
+        catch (error) {
+            await this.enqueue(async () => { original.restoration = undefined; original.diagnostic = 'Target admission restoration needs verification'; });
+            throw new TargetAdmissionPendingError(hold, error);
+        }
+        await this.enqueue(async () => {
+            original.restoration = undefined;
+            if (original.stale || this.shutdown.signal.aborted) {
+                this.retirePin(original);
+                throw new TargetAdmissionPendingError(hold, new Error('Target changed during disposition'));
+            }
+            original.diagnostic = undefined;
+            this.unpin(original);
+        });
+    }
+    async finalizeTargetRemoval(hold) {
+        await this.enqueue(async () => {
+            const pin = this.originalPin(hold);
+            if (!pin.active || !pin.disposed)
+                throw new LocalControlError('OUTCOME_UNKNOWN', 'Original disposition is incomplete');
+            const inspection = await this.options.store.inspect();
+            if (!inspection.known || inspection.entries.some(entry => entry.id === pin.id))
+                throw new LocalControlError('OUTCOME_UNKNOWN', 'Original registration membership remains present');
+            this.members.delete(pin.id);
+            this.unpin(pin);
+            this.targetHolds.delete(hold);
+        });
+    }
+    async activities() {
+        const result = new Map();
+        for (const [id, member] of this.members)
+            result.set(id, member.runtime ? await member.runtime.activity().catch(() => null) : null);
+        return result;
+    }
+    async activitySnapshot() { return { registrations: await this.activities(), desktop: this.desktopActivity() }; }
+    async connections() {
+        const result = new Map();
+        for (const [id, member] of this.members)
+            result.set(id, await member.runtime?.connection?.().catch(() => 'unknown') ?? 'unknown');
+        return result;
+    }
+    stop(mode) {
+        this.closing = true;
+        return this.enqueue(async () => {
+            const members = [...this.members.values()];
+            const pauses = await Promise.allSettled(members.map(async (member) => member.runtime?.pauseAdmission()));
+            const failures = pauses.flatMap(result => result.status === 'rejected' ? [result.reason] : []);
+            for (const member of members) {
+                try {
+                    if (!member.runtime && mode === 'terminate')
+                        throw new LocalControlError('OUTCOME_UNKNOWN', 'Original registration shutdown authority is unavailable');
+                    await member.runtime?.stop(mode);
+                    this.settledMembers.set(member.registration.id, { revision: member.registration.revision, mode });
+                    this.members.delete(member.registration.id);
+                }
+                catch (error) {
+                    member.state = 'failed';
+                    member.cleanupPending = true;
+                    member.diagnostic = 'Owned shutdown needs verification';
+                    failures.push(error);
+                }
+            }
+            if (mode === 'terminate') {
+                try {
+                    const inspection = await this.options.store.inspect();
+                    if (!inspection.known || inspection.entries.some(entry => entry.state !== 'ready' || this.settledMembers.get(entry.id)?.revision !== entry.registration.revision || this.settledMembers.get(entry.id)?.mode !== 'terminate'))
+                        throw new LocalControlError('OUTCOME_UNKNOWN', 'Every registration requires its original shutdown settlement');
+                }
+                catch (error) {
+                    failures.push(error);
+                }
+            }
+            if (failures.length)
+                throw new AggregateError(failures, 'Original device shutdown remains pending');
+            this.shutdown.abort();
+        });
+    }
+}