handmux 0.23.0 → 0.25.0

package/dist/src/agent-runtime/conversationActivation.js

@@ -0,0 +1,75 @@
+export class ConversationActivationError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'ConversationActivationError';
+    }
+}
+export class AgentConversationActivationService {
+    #controllers;
+    #active = new Set();
+    #timeoutMs;
+    constructor(controllers, { timeoutMs = 15_000 } = {}) {
+        if (!controllers || typeof controllers !== 'object' || !Object.keys(controllers).length) {
+            throw new TypeError('AgentConversationActivationService requires controllers');
+        }
+        this.#controllers = new Map(Object.entries(controllers));
+        this.#timeoutMs = Math.max(1, timeoutMs);
+    }
+    async describe(run) {
+        const controller = this.#controllers.get(run.ref.agentId);
+        if (!controller)
+            throw new ConversationActivationError('Conversation activation unsupported', 'unsupported');
+        let value;
+        try {
+            value = await controller.describe(run);
+        }
+        catch {
+            throw new ConversationActivationError('Conversation activation is temporarily unavailable', 'unavailable');
+        }
+        if (value === null)
+            return null;
+        if (!value || value.effect !== 'replace-process-preserve-session') {
+            throw new ConversationActivationError('Invalid Conversation activation descriptor', 'contract_violation');
+        }
+        return structuredClone(value);
+    }
+    async activate(run, signal) {
+        const controller = this.#controllers.get(run.ref.agentId);
+        if (!controller)
+            throw new ConversationActivationError('Conversation activation unsupported', 'unsupported');
+        if (run.signal.aborted) {
+            throw new ConversationActivationError('The Agent run is no longer active', 'unavailable');
+        }
+        const key = `${run.ref.paneId}\0${run.ref.runId}`;
+        if (this.#active.has(key)) {
+            throw new ConversationActivationError('Conversation activation is already in progress', 'in_progress');
+        }
+        this.#active.add(key);
+        const operation = new AbortController();
+        const cancel = () => operation.abort(signal?.reason ?? new Error('Activation request cancelled'));
+        signal?.addEventListener('abort', cancel, { once: true });
+        if (signal?.aborted)
+            cancel();
+        const timer = setTimeout(() => operation.abort(new Error('Conversation activation timed out')), this.#timeoutMs);
+        try {
+            if (operation.signal.aborted)
+                throw operation.signal.reason;
+            const aborted = new Promise((_resolve, reject) => {
+                operation.signal.addEventListener('abort', () => reject(operation.signal.reason), { once: true });
+            });
+            await Promise.race([controller.activate(run, operation.signal), aborted]);
+        }
+        catch (error) {
+            if (error instanceof ConversationActivationError)
+                throw error;
+            throw new ConversationActivationError('Conversation activation could not finish; continue in the terminal or try again', 'unavailable');
+        }
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', cancel);
+            this.#active.delete(key);
+        }
+    }
+}

package/dist/src/agent-runtime/conversationActivity.js

@@ -0,0 +1,69 @@
+function key(run) {
+    return `${run.ref.agentId}\0${run.ref.sessionId ?? ''}`;
+}
+function validActivity(value) {
+    return value === 'idle' || value === 'working' || value === 'waiting'
+        || value === 'compacting' || value === 'unknown';
+}
+function normalizeActiveTurn(value) {
+    if (!value || typeof value !== 'object')
+        return { state: 'unknown' };
+    const record = value;
+    if (record.state === 'none')
+        return { state: 'none' };
+    if (record.state === 'active' && typeof record.nativeTurnId === 'string' && record.nativeTurnId) {
+        return { state: 'active', nativeTurnId: record.nativeTurnId };
+    }
+    return { state: 'unknown' };
+}
+/** Runtime-owned normalization: provider readers never own revisions or dispatch state. */
+export class RuntimeConversationActivitySource {
+    #readers;
+    #snapshots = new Map();
+    #readGenerations = new Map();
+    constructor(readers) {
+        this.#readers = new Map(Object.entries(readers));
+    }
+    async read(run) {
+        const owner = key(run);
+        const epoch = run.ref.runId;
+        const generation = (this.#readGenerations.get(owner) ?? 0) + 1;
+        this.#readGenerations.set(owner, generation);
+        const reader = this.#readers.get(run.ref.agentId);
+        let activity = 'unknown';
+        let activeTurn = { state: 'unknown' };
+        let completionToken;
+        try {
+            const raw = await reader?.read(run);
+            if (raw && validActivity(raw.activity)) {
+                activity = raw.activity;
+                activeTurn = normalizeActiveTurn(raw.activeTurn);
+                if (typeof raw.completionToken === 'string' && raw.completionToken
+                    && raw.completionToken.length <= 1024)
+                    completionToken = raw.completionToken;
+            }
+        }
+        catch { /* an unreadable provider snapshot is explicitly unknown */ }
+        const current = this.#snapshots.get(owner);
+        if (run.signal.aborted || run.ref.runId !== epoch || key(run) !== owner
+            || this.#readGenerations.get(owner) !== generation) {
+            return structuredClone(current ?? {
+                activity: 'unknown', activeTurn: { state: 'unknown' }, revision: 1, epoch,
+            });
+        }
+        const previous = current;
+        const semantic = `${activity}\0${activeTurn.state}\0${activeTurn.state === 'active' ? activeTurn.nativeTurnId : ''}\0${completionToken ?? ''}`;
+        const previousSemantic = previous
+            ? `${previous.activity}\0${previous.activeTurn.state}\0${previous.activeTurn.state === 'active'
+                ? previous.activeTurn.nativeTurnId : ''}\0${previous.completionToken ?? ''}` : '';
+        const revision = previous?.epoch === epoch
+            ? previous.revision + (semantic === previousSemantic ? 0 : 1)
+            : 1;
+        const snapshot = {
+            activity, activeTurn, revision, epoch,
+            ...(completionToken === undefined ? {} : { completionToken }),
+        };
+        this.#snapshots.set(owner, snapshot);
+        return structuredClone(snapshot);
+    }
+}

package/dist/src/agent-runtime/conversationControls.js

@@ -0,0 +1,206 @@
+export class ConversationControlError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'ConversationControlError';
+    }
+}
+const MAX_OBJECTIVE = 4_000;
+function text(value, max) {
+    return typeof value === 'string' && value.trim().length > 0 && value.length <= max;
+}
+function finite(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+function goal(value) {
+    if (value === null)
+        return null;
+    if (!value || !text(value.objective, MAX_OBJECTIVE) || !text(value.status, 64))
+        return undefined;
+    const numeric = ['createdAt', 'updatedAt', 'tokensUsed', 'timeUsedSeconds'];
+    if (numeric.some((key) => value[key] !== undefined && !finite(value[key])))
+        return undefined;
+    if (value.tokenBudget !== undefined && value.tokenBudget !== null && !finite(value.tokenBudget)) {
+        return undefined;
+    }
+    return structuredClone(value);
+}
+function plan(value) {
+    if (value === null)
+        return null;
+    if (!value || !Array.isArray(value.steps) || value.steps.length > 100
+        || (value.explanation !== undefined && !text(value.explanation, 16_384))
+        || (value.turnId !== undefined && !text(value.turnId, 256))
+        || (value.waiting !== undefined && typeof value.waiting !== 'boolean'))
+        return undefined;
+    const statuses = new Set(['pending', 'inProgress', 'completed']);
+    if (value.steps.some((step) => !step || !text(step.step, 4_096) || !statuses.has(step.status))) {
+        return undefined;
+    }
+    return structuredClone(value);
+}
+function context(value) {
+    if (value === null)
+        return null;
+    if (!value || !['idle', 'working', 'waiting', 'compacting', 'unknown'].includes(value.activity)
+        || (value.usedTokens !== undefined && !finite(value.usedTokens))
+        || (value.totalTokens !== undefined && (!finite(value.totalTokens) || value.totalTokens <= 0))
+        || (value.cwd !== undefined && !text(value.cwd, 4_096))
+        || (value.branch !== undefined && !text(value.branch, 1_024))
+        || (value.access !== undefined && !['read-only', 'workspace-write', 'full-access'].includes(value.access))) {
+        return undefined;
+    }
+    return structuredClone(value);
+}
+function permission(value) {
+    if (value === null)
+        return null;
+    const validModes = ['default', 'auto-review', 'full-access', 'custom'];
+    if (!value || !validModes.includes(value.mode) || !Array.isArray(value.options)
+        || value.options.length === 0 || value.options.length > 3
+        || value.options.some((mode) => !['default', 'auto-review', 'full-access'].includes(mode))
+        || new Set(value.options).size !== value.options.length)
+        return undefined;
+    return structuredClone(value);
+}
+export class AgentConversationControlService {
+    #bindings;
+    constructor(bindings) {
+        if (!bindings || typeof bindings !== 'object' || !Object.keys(bindings).length) {
+            throw new TypeError('AgentConversationControlService requires controller bindings');
+        }
+        this.#bindings = new Map(Object.entries(bindings));
+    }
+    slots(agentId) {
+        const binding = this.#bindings.get(agentId);
+        return {
+            goal: binding?.goal?.apiVersion === 1,
+            plan: binding?.plan?.apiVersion === 1,
+            context: binding?.context?.apiVersion === 1,
+            permission: binding?.permission?.apiVersion === 1,
+            commands: binding?.commands?.apiVersion === 1,
+        };
+    }
+    async read(run) {
+        const binding = this.#bindings.get(run.ref.agentId);
+        if (!binding)
+            throw new ConversationControlError('Conversation controls unsupported', 'unsupported');
+        const [goalResult, planResult, contextResult, permissionResult] = await Promise.allSettled([
+            binding.goal?.read(run), binding.plan?.read(run), binding.context?.read(run),
+            binding.permission?.read(run),
+        ]);
+        const slotErrors = {};
+        const resultValue = (slot, result) => {
+            if (result.status === 'fulfilled')
+                return result.value;
+            // Provider failures may contain RPC payloads, credentials, or local paths. The facade exposes only a
+            // stable slot-level recovery signal; adapter diagnostics belong in Runtime health/logging.
+            slotErrors[slot] = 'temporarily unavailable';
+            return undefined;
+        };
+        const goalValue = resultValue('goal', goalResult);
+        const planValue = resultValue('plan', planResult);
+        const contextValue = resultValue('context', contextResult);
+        const permissionValue = resultValue('permission', permissionResult);
+        const normalizedGoal = goalValue === undefined ? undefined : goal(goalValue);
+        const normalizedPlan = planValue === undefined ? undefined : plan(planValue);
+        const normalizedContext = contextValue === undefined ? undefined : context(contextValue);
+        const normalizedPermission = permissionValue === undefined ? undefined : permission(permissionValue);
+        if (goalValue !== undefined && normalizedGoal === undefined)
+            slotErrors.goal = 'temporarily unavailable';
+        if (planValue !== undefined && normalizedPlan === undefined)
+            slotErrors.plan = 'temporarily unavailable';
+        if (contextValue !== undefined && normalizedContext === undefined) {
+            slotErrors.context = 'temporarily unavailable';
+        }
+        if (permissionValue !== undefined && normalizedPermission === undefined) {
+            slotErrors.permission = 'temporarily unavailable';
+        }
+        return {
+            ...(normalizedGoal === undefined ? {} : { goal: normalizedGoal }),
+            ...(binding.goal?.apiVersion === 1 ? { goalActions: [
+                    ...(binding.goal.start ? ['start'] : []),
+                    ...(binding.goal.update ? ['update'] : []),
+                    ...(binding.goal.clear ? ['clear'] : []),
+                ] } : {}),
+            ...(normalizedPlan === undefined ? {} : { plan: normalizedPlan }),
+            ...(normalizedContext === undefined ? {} : { context: normalizedContext }),
+            ...(normalizedPermission === undefined ? {} : { permission: normalizedPermission }),
+            ...(binding.permission?.apiVersion === 1 ? {
+                permissionCanUpdate: typeof binding.permission.update === 'function',
+            } : {}),
+            ...(binding.commands?.apiVersion === 1 ? { commands: [...binding.commands.commands] } : {}),
+            ...(Object.keys(slotErrors).length ? { slotErrors } : {}),
+        };
+    }
+    async goalAction(run, request) {
+        const control = this.#bindings.get(run.ref.agentId)?.goal;
+        if (!control)
+            throw new ConversationControlError('Conversation goal unsupported', 'unsupported');
+        let raw;
+        if (request.action === 'clear') {
+            if (!control.clear)
+                throw new ConversationControlError('Goal clear unsupported', 'unsupported');
+            await control.clear(run);
+            return null;
+        }
+        if (request.action === 'start' && text(request.objective, MAX_OBJECTIVE)) {
+            if (!control.start)
+                throw new ConversationControlError('Goal start unsupported', 'unsupported');
+            raw = await control.start(run, request.objective.trim());
+        }
+        else if (request.action === 'update') {
+            const patch = {};
+            if (request.objective !== undefined) {
+                if (!text(request.objective, MAX_OBJECTIVE)) {
+                    throw new ConversationControlError('Invalid goal objective', 'invalid_request');
+                }
+                patch.objective = request.objective.trim();
+            }
+            if (request.status !== undefined) {
+                if (request.status !== 'active' && request.status !== 'paused') {
+                    throw new ConversationControlError('Invalid goal status', 'invalid_request');
+                }
+                patch.status = request.status;
+            }
+            if (!Object.keys(patch).length) {
+                throw new ConversationControlError('Empty goal update', 'invalid_request');
+            }
+            if (!control.update)
+                throw new ConversationControlError('Goal update unsupported', 'unsupported');
+            raw = await control.update(run, patch);
+        }
+        else {
+            throw new ConversationControlError('Invalid goal action', 'invalid_request');
+        }
+        const normalized = goal(raw);
+        if (!normalized)
+            throw new ConversationControlError('Invalid goal response', 'contract_violation');
+        return normalized;
+    }
+    async permissionAction(run, request) {
+        const control = this.#bindings.get(run.ref.agentId)?.permission;
+        if (!control)
+            throw new ConversationControlError('Conversation permission unsupported', 'unsupported');
+        if (!control.update) {
+            throw new ConversationControlError('Permission update unsupported', 'unsupported');
+        }
+        const mode = request.permissionMode;
+        if (request.action !== 'set_permission'
+            || !['default', 'auto-review', 'full-access'].includes(String(mode))) {
+            throw new ConversationControlError('Invalid permission action', 'invalid_request');
+        }
+        const normalized = permission(await control.update(run, mode));
+        if (!normalized)
+            throw new ConversationControlError('Invalid permission response', 'contract_violation');
+        return normalized;
+    }
+    async command(run, value) {
+        const control = this.#bindings.get(run.ref.agentId)?.commands;
+        if (!control || (value !== 'compact' && value !== 'clear') || !control.commands.includes(value)) {
+            throw new ConversationControlError('Conversation command unsupported', 'unsupported');
+        }
+        await control.execute(run, value);
+    }
+}

package/dist/src/agent-runtime/conversationLiveHub.js

@@ -0,0 +1,276 @@
+const DEFAULT_MAX_BUFFERED_EVENTS = 512;
+const DEFAULT_MAX_REPLAY_EVENTS = 2_048;
+const DEFAULT_IDLE_GRACE_MS = 5_000;
+export class ConversationLiveHubError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'ConversationLiveHubError';
+    }
+}
+class EventQueue {
+    checkpoint;
+    #maxBufferedEvents;
+    #detach;
+    #values = [];
+    #waiting;
+    #closed = false;
+    #finishWhenEmpty = false;
+    #detached = false;
+    #lastReadSequence;
+    constructor(checkpoint, maxBufferedEvents, detach) {
+        this.checkpoint = Object.freeze(structuredClone(checkpoint));
+        this.#lastReadSequence = checkpoint.streamSequence;
+        this.#maxBufferedEvents = maxBufferedEvents;
+        this.#detach = detach;
+    }
+    [Symbol.asyncIterator]() { return this; }
+    next() {
+        const value = this.#values.shift();
+        if (value) {
+            this.#lastReadSequence = value.sequence;
+            return Promise.resolve({ value: structuredClone(value), done: false });
+        }
+        if (this.#closed || this.#finishWhenEmpty) {
+            this.#closed = true;
+            this.#detachOnce();
+            return Promise.resolve({ value: undefined, done: true });
+        }
+        return new Promise((resolve) => { this.#waiting = resolve; });
+    }
+    push(event, finish = false) {
+        if (this.#closed || this.#finishWhenEmpty)
+            return;
+        const cloned = structuredClone(event);
+        const waiting = this.#waiting;
+        if (waiting) {
+            this.#waiting = undefined;
+            this.#lastReadSequence = cloned.sequence;
+            if (finish) {
+                this.#finishWhenEmpty = true;
+                this.#detachOnce();
+            }
+            waiting({ value: cloned, done: false });
+            return;
+        }
+        if (this.#values.length >= this.#maxBufferedEvents) {
+            this.#values.splice(0);
+            this.#values.push({
+                type: 'stream.gap',
+                sequence: cloned.sequence,
+                afterSequence: this.#lastReadSequence,
+            });
+            this.#finishWhenEmpty = true;
+            this.#detachOnce();
+            return;
+        }
+        this.#values.push(cloned);
+        if (finish) {
+            this.#finishWhenEmpty = true;
+            this.#detachOnce();
+        }
+    }
+    finishAfterDrain() {
+        if (this.#closed || this.#finishWhenEmpty)
+            return;
+        this.#finishWhenEmpty = true;
+        this.#detachOnce();
+        if (!this.#values.length && this.#waiting) {
+            const waiting = this.#waiting;
+            this.#waiting = undefined;
+            this.#closed = true;
+            waiting({ value: undefined, done: true });
+        }
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#values.splice(0);
+        this.#detachOnce();
+        if (this.#waiting) {
+            const waiting = this.#waiting;
+            this.#waiting = undefined;
+            waiting({ value: undefined, done: true });
+        }
+    }
+    #detachOnce() {
+        if (this.#detached)
+            return;
+        this.#detached = true;
+        this.#detach();
+    }
+}
+// App-level fan-out only. ConversationService still owns provider ordering, reconciliation, and durable
+// truth; this hub owns one shared observation plus bounded per-client delivery queues.
+export class ConversationLiveHub {
+    #conversation;
+    #maxBufferedEvents;
+    #maxReplayEvents;
+    #idleGraceMs;
+    #observations = new Map();
+    #closed = false;
+    constructor({ conversation, maxBufferedEvents = DEFAULT_MAX_BUFFERED_EVENTS, maxReplayEvents = DEFAULT_MAX_REPLAY_EVENTS, idleGraceMs = DEFAULT_IDLE_GRACE_MS, }) {
+        if (!conversation || typeof conversation.open !== 'function'
+            || !Number.isSafeInteger(maxBufferedEvents) || maxBufferedEvents <= 0
+            || !Number.isSafeInteger(maxReplayEvents) || maxReplayEvents <= 0
+            || !Number.isSafeInteger(idleGraceMs) || idleGraceMs < 0) {
+            throw new TypeError('Conversation live hub requires a service and bounded queues');
+        }
+        this.#conversation = conversation;
+        this.#maxBufferedEvents = maxBufferedEvents;
+        this.#maxReplayEvents = maxReplayEvents;
+        this.#idleGraceMs = idleGraceMs;
+    }
+    async subscribe(run, request = {}) {
+        if (this.#closed)
+            throw new ConversationLiveHubError('closed', 'Conversation live hub is closed');
+        let shared = this.#observations.get(run.ref.runId);
+        if (!shared)
+            shared = this.#create(run);
+        if (shared.run !== run || shared.terminated) {
+            throw new ConversationLiveHubError('stale_run', 'Conversation live run is no longer current');
+        }
+        if (shared.idleTimer) {
+            clearTimeout(shared.idleTimer);
+            shared.idleTimer = undefined;
+        }
+        await shared.ready;
+        const checkpoint = shared.checkpoint;
+        const baseline = shared.baseline;
+        if (!checkpoint || !baseline || shared.terminated) {
+            throw new ConversationLiveHubError('unavailable', 'Conversation live observation is unavailable');
+        }
+        if (request.expectedViewId !== undefined && request.expectedViewId !== checkpoint.viewId) {
+            this.#idle(shared);
+            throw new ConversationLiveHubError('stale_view', 'Conversation view is stale');
+        }
+        let subscription;
+        subscription = new EventQueue(baseline, this.#maxBufferedEvents, () => {
+            this.#detach(shared, subscription);
+        });
+        shared.subscribers.add(subscription);
+        for (const event of shared.replay)
+            subscription.push(event);
+        return subscription;
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        for (const shared of [...this.#observations.values()])
+            this.#terminate(shared, false);
+    }
+    #create(run) {
+        const shared = {
+            run,
+            ready: Promise.resolve(),
+            subscribers: new Set(),
+            replay: [],
+            idleTimer: undefined,
+            detachAbort: () => { },
+            terminated: false,
+        };
+        const abort = () => this.#terminate(shared, false);
+        run.signal.addEventListener('abort', abort, { once: true });
+        shared.detachAbort = () => run.signal.removeEventListener('abort', abort);
+        this.#observations.set(run.ref.runId, shared);
+        shared.ready = this.#conversation.open(run, {}, (event) => {
+            this.#publish(shared, event);
+        }).then((handle) => {
+            if (shared.terminated) {
+                try {
+                    void Promise.resolve(handle.close()).catch(() => { });
+                }
+                catch { /* best effort */ }
+                throw new Error('Conversation live run was revoked during open');
+            }
+            shared.handle = handle;
+            shared.baseline = structuredClone(handle.checkpoint);
+            shared.checkpoint = structuredClone(handle.checkpoint);
+        }).catch((error) => {
+            this.#terminate(shared, false);
+            throw error;
+        });
+        return shared;
+    }
+    #publish(shared, event) {
+        if (shared.terminated || !shared.checkpoint
+            || !Number.isSafeInteger(event.sequence)
+            || event.sequence <= shared.checkpoint.streamSequence)
+            return;
+        const previousSequence = shared.checkpoint.streamSequence;
+        if (shared.replay.length >= this.#maxReplayEvents
+            && event.type !== 'history.changed' && event.type !== 'stream.gap') {
+            const gap = {
+                type: 'stream.gap', sequence: event.sequence, afterSequence: previousSequence,
+            };
+            shared.checkpoint = { ...shared.checkpoint, streamSequence: event.sequence };
+            for (const subscriber of [...shared.subscribers])
+                subscriber.push(gap, true);
+            this.#terminate(shared, true);
+            return;
+        }
+        shared.checkpoint = {
+            viewId: event.type === 'history.changed' ? event.viewId : shared.checkpoint.viewId,
+            historyVersion: event.type === 'history.changed'
+                ? event.historyVersion : shared.checkpoint.historyVersion,
+            streamSequence: event.sequence,
+        };
+        const terminal = event.type === 'stream.gap';
+        shared.replay.push(structuredClone(event));
+        for (const subscriber of [...shared.subscribers])
+            subscriber.push(event, terminal);
+        if (event.type === 'history.changed') {
+            // A durable barrier advances the baseline without ending the native observation. Existing clients
+            // receive the barrier and reconcile their page; later subscribers start directly from the new
+            // checkpoint, so pre-barrier replay can be released immediately.
+            shared.baseline = structuredClone(shared.checkpoint);
+            shared.replay = [];
+        }
+        if (terminal)
+            this.#terminate(shared, true);
+    }
+    #detach(shared, subscription) {
+        shared.subscribers.delete(subscription);
+        this.#idle(shared);
+    }
+    #idle(shared) {
+        if (shared.terminated || shared.subscribers.size || shared.idleTimer)
+            return;
+        if (this.#idleGraceMs === 0) {
+            this.#terminate(shared, false);
+            return;
+        }
+        shared.idleTimer = setTimeout(() => {
+            shared.idleTimer = undefined;
+            if (!shared.subscribers.size)
+                this.#terminate(shared, false);
+        }, this.#idleGraceMs);
+        shared.idleTimer.unref?.();
+    }
+    #terminate(shared, drain) {
+        if (shared.terminated)
+            return;
+        shared.terminated = true;
+        if (this.#observations.get(shared.run.ref.runId) === shared) {
+            this.#observations.delete(shared.run.ref.runId);
+        }
+        if (shared.idleTimer)
+            clearTimeout(shared.idleTimer);
+        shared.idleTimer = undefined;
+        shared.detachAbort();
+        for (const subscriber of [...shared.subscribers]) {
+            if (drain)
+                subscriber.finishAfterDrain();
+            else
+                subscriber.close();
+        }
+        shared.subscribers.clear();
+        try {
+            void Promise.resolve(shared.handle?.close()).catch(() => { });
+        }
+        catch { /* close is best effort */ }
+    }
+}