@songtonyli/dsh-cli 0.1.11 → 0.1.13

package/node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/client/sessions/service.js

@@ -1,8 +1,8 @@
 import { SessionSeq } from '@deepseek-ai/dsh-session/types';
 import { workspaceTitleOf } from '@deepseek-ai/dsh-util-workspace-path';
 import { SESSION_SEARCH_RESULT_LIMIT } from "../../types.js";
-import { createSnapshotStore, } from '@deepseek-ai/dsh-client-store';
-import { createScope, scopeOf as scopeTagOf } from "../scope.js";
+import { createSnapshotStore, notifySubscribers, } from '@deepseek-ai/dsh-client-store';
+import { createScope, scopeIdentityOf, scopeOf as scopeTagOf } from "../scope.js";
 import { SessionManager } from "./manager.js";
 /** Structured session-create failure. */
 export class SessionCreateError extends Error {
@@ -69,7 +69,74 @@ function increasedForkTitle(title) {
     }
     return `${title} (1)`;
 }
-/** Root sessions service: list store, current selection, object-layer manager, scope tree, bindings, and breadcrumb routes. */
+/** Source labels are dictionary keys, including names also present on Object.prototype. */
+function freezeRetainedBy(counts) {
+    Object.setPrototypeOf(counts, null);
+    return Object.freeze(counts);
+}
+const EMPTY_RETAIN_INFO = Object.freeze({ referenceCount: 0, retainedBy: freezeRetainedBy({}) });
+/** A cancelled waiter releases only its own reference, not the shared opening. */
+async function waitForOpen(opening, signal) {
+    if (signal === undefined)
+        return opening;
+    const aborted = Promise.withResolvers();
+    const onAbort = () => { aborted.reject(signal.reason); };
+    signal.addEventListener('abort', onAbort, { once: true });
+    try {
+        if (signal.aborted)
+            onAbort();
+        await Promise.race([opening, aborted.promise]);
+    }
+    finally {
+        signal.removeEventListener('abort', onAbort);
+    }
+}
+class ClientSessionReference {
+    sessionId;
+    record;
+    releaseReference;
+    released = new AbortController();
+    readiness = Promise.withResolvers();
+    ready = this.readiness.promise;
+    constructor(sessionId, record, releaseReference) {
+        this.sessionId = sessionId;
+        this.record = record;
+        this.releaseReference = releaseReference;
+        void this.ready.catch(() => { });
+    }
+    get binding() {
+        if (this.record === undefined || !this.record.live)
+            throw new Error(`Session reference "${this.sessionId}" is released`);
+        return this.record.binding;
+    }
+    attachOpening(opening, signal) {
+        const waitSignal = signal === undefined
+            ? this.released.signal
+            : AbortSignal.any([this.released.signal, signal]);
+        void waitForOpen(opening, waitSignal).then(() => {
+            try {
+                waitSignal.throwIfAborted();
+                this.readiness.resolve(this.binding);
+            }
+            catch (error) {
+                this.readiness.reject(error);
+            }
+        }, (error) => { this.readiness.reject(error); });
+    }
+    release() {
+        const reason = new Error(`Session reference "${this.sessionId}" is released`);
+        const release = this.releaseReference;
+        this.released.abort(reason);
+        this.readiness.reject(reason);
+        this.record = undefined;
+        this.releaseReference = undefined;
+        release?.();
+    }
+    [Symbol.dispose]() {
+        this.release();
+    }
+}
+/** Host catalog and local reference allocator; view selection remains outside the Controller. */
 export class ClientSessions {
     rootCtx;
     /**
@@ -79,85 +146,89 @@ export class ClientSessions {
      * reports the same number.
      */
     searchResultLimit = SESSION_SEARCH_RESULT_LIMIT;
-    /** List snapshot store (list RPC + host stream increments; re-pulled on reconnect) — the useSessions standard feed, current included. */
+    /** Catalog metadata and local reference-source projection. */
     list;
     /** The object-layer instance cluster and frame dispatch entry. */
     manager;
-    /**
-     * Persisted selection cell (the durable half of `list.current`). Private on
-     * purpose: reads go through the list snapshot; writes through {@link
-     * ClientSessions.open} / {@link ClientSessions.clear}. Projection
-     * validates it against the live list instead of destructively pruning, so a
-     * selection survives transient list states (reconnect re-pull) and
-     * resurfaces when its session returns.
-     */
-    selection;
     scopes = new Map();
-    /** In-flight scope drops remain here after records leave `scopes`, so root disposal can await quiescence. */
+    /** Stable per-id sources retained for the Client root lifetime, including across generation replacement. */
+    retainObservers = new Map();
     scopeDrops = new Set();
-    /**
-     * The staged session id — follows `list.current` exactly, holding its last
-     * defined value across masked gaps (a transiently absent selection blanks
-     * `current` without moving the stage, so reconnect re-pulls and removals
-     * keep the staged scope's frozen view alive until the stage moves on).
-     */
-    watched;
-    /** Removed-while-staged sessions whose teardown waits for the stage to move away. */
-    deferredRemovals = new Set();
+    closed = false;
     /**
      * @param ctx - client root context (scope fibers mount under it).
      * @param remote - generated Remote namespaces shared with every Session.
      */
     constructor(rootCtx, remote) {
         this.rootCtx = rootCtx;
-        this.selection = createSnapshotStore({}, { persist: { name: 'dsh.sessions.current' } });
-        const restored = this.selection.getSnapshot();
-        this.manager = new SessionManager(remote, restored.sessionId, restored.subagentAddress);
+        this.manager = new SessionManager(remote);
         this.list = createSnapshotStore({
-            ids: [], byId: {}, current: undefined, phase: 'pending',
-            subagentsByParent: {}, jobsBySession: {}, currentAddress: undefined,
-        });
-        // The manager owns wire truth; the store is its projection. Manager
-        // notifications are already microtask-batched.
-        const disposeManagerProjection = this.manager.subscribe(() => {
-            this.projectList();
-        });
-        // Stage follower: every current write (open() and projection alike)
-        // re-evaluates staging, so startup restore (persisted selection validated
-        // by the projection) and reconnect resurfacing open their window with no
-        // dedicated code path. Safe to run synchronously inside the store notify:
-        // the follower writes no list state — session.open()'s synchronous prefix
-        // touches only session-side state and its own microtask-batched notifier.
-        const disposeStageFollower = this.list.subscribe(() => {
-            this.followCurrent();
+            ids: [], byId: {}, phase: 'pending', subagentsByParent: {}, jobsBySession: {},
         });
+        const disposeManagerProjection = this.manager.subscribe(() => { this.projectList(); });
         rootCtx.effect(() => async () => {
-            disposeStageFollower();
+            this.closed = true;
             disposeManagerProjection();
             const scopes = [...this.scopes];
             this.scopes.clear();
-            this.deferredRemovals.clear();
-            this.watched = undefined;
-            for (const [id, record] of scopes)
+            for (const [, record] of scopes) {
+                record.live = false;
+                record.session.unbindScope();
+            }
+            const managerDisposal = this.manager.dispose();
+            for (const [id, record] of scopes) {
                 this.startScopeDrop(id, record);
+                this.publishRetention(id);
+            }
             await this.drainScopeDrops();
-            await this.manager.dispose();
+            await managerDisposal;
         }, 'session-controller.client.sessions');
         rootCtx.reflect.provide('sessions', this, undefined);
     }
-    /**
-     * Select a listed or retained catalog-addressed session as current.
-     * @param id - listed or addressed session id.
-     */
-    open(id) {
-        this.manager.select(id);
+    retain(target, options) {
+        const { source, signal } = options;
+        signal?.throwIfAborted();
+        if (this.closed)
+            throw new Error('Session Controller is disposed');
+        const id = this.manager.resolveTarget(target);
+        const reference = this.retainScope(id, source);
+        try {
+            reference.attachOpening(this.manager.get(id).open(), signal);
+            return reference;
+        }
+        catch (error) {
+            reference.release();
+            throw error;
+        }
     }
-    /**
-     * Open a healthy catalog child through its direct-parent address.
-     * @param address - catalog-derived parent and child ids.
-     */
-    openSubagent(address) {
-        this.manager.selectSubagent(address);
+    async using(target, options, operation) {
+        const reference = this.retain(target, options);
+        try {
+            await reference.ready;
+            return await operation(reference);
+        }
+        finally {
+            reference.release();
+        }
+    }
+    retainInfo(id) {
+        let observer = this.retainObservers.get(id);
+        if (observer === undefined) {
+            const listeners = new Set();
+            observer = {
+                listeners,
+                published: this.retentionSnapshot(id),
+                source: {
+                    getSnapshot: () => this.retentionSnapshot(id),
+                    subscribe: (listener) => {
+                        listeners.add(listener);
+                        return () => { listeners.delete(listener); };
+                    },
+                },
+            };
+            this.retainObservers.set(id, observer);
+        }
+        return observer.source;
     }
     /**
      * Resolve an already discovered direct-parent address without opening it.
@@ -183,16 +254,6 @@ export class ClientSessions {
     refreshSubagents(parentSessionId) {
         return this.manager.refreshSubagents(parentSessionId);
     }
-    /**
-     * Clear the current selection so the layout shows the no-session empty
-     * state (new-session affordance and the workspace preselection flow).
-     * Wipes the persisted selection too — a reload stays on empty until the
-     * user opens or starts a session. The staged scope keeps its frozen view
-     * per the masked-gap contract until the next open() moves the stage.
-     */
-    clear() {
-        this.manager.clearSelection();
-    }
     /**
      * Refresh the real Session baseline, reusing an in-flight pull.
      * @returns completion of the current or newly started baseline pull.
@@ -257,12 +318,8 @@ export class ClientSessions {
         this.manager.handleConnected();
     }
     /**
-     * Create a session on the host. Resolution guarantee: by the time the
-     * promise resolves, the created session is in the list store and
-     * {@link ClientSessions.binding} resolves it — callers (New Session
-     * draft hand-off) may address the scope synchronously, without waiting a
-     * notifier flush. The synchronous projection below makes this structural
-     * rather than an accident of microtask ordering.
+     * Create a Host Session and publish its catalog row before resolving.
+     * Callers retain the returned identity before borrowing its binding.
      * @param opts - target workspace or directory and an optional preallocated id.
      * @returns the new session id.
      * @throws {SessionCreateError} with the requested id.
@@ -275,9 +332,8 @@ export class ClientSessions {
         return result.value.sessionId;
     }
     /**
-     * Fork a session from a completed-turn prefix of the source (same
-     * synchronous-addressability guarantee as {@link ClientSessions.create}:
-     * on resolution the child is in the list store and open() can target it).
+     * Fork a Session from a completed-turn prefix of the source and publish
+     * the child in the catalog before resolving.
      * @param opts - source session id, the optional event seq anchoring the
      *   cut (the boundary is the first turn/end at or after it; an in-log
      *   anchor in an open turn is unavailable rather than clipped backward),
@@ -305,33 +361,36 @@ export class ClientSessions {
         this.projectList();
         const childId = result.value.sessionId;
         if (sourceTitle !== undefined) {
-            const child = this.binding(childId)?.session;
-            if (child === undefined)
-                throw new Error(`fork child "${childId}" is not locally addressable`);
-            const renamed = await child.rename(increasedForkTitle(sourceTitle));
-            if (!renamed.ok)
-                throw new Error(`fork child rename failed: ${renamed.error.code}: ${renamed.error.message}`);
+            const reference = this.retain(childId, { source: 'controllerOperation' });
+            try {
+                await reference.ready;
+                const renamed = await reference.binding.session.rename(increasedForkTitle(sourceTitle));
+                if (!renamed.ok)
+                    throw new Error(`fork child rename failed: ${renamed.error.code}: ${renamed.error.message}`);
+            }
+            finally {
+                reference.release();
+            }
         }
         return childId;
     }
     /**
-     * Resolve an Agent-scoped context view (use-and-discard).
+     * Borrow an already-retained Agent-scoped Context.
      * @param id - session id (the agent identity — 1:1 same axis).
-     * @returns scoped ctx, or undefined for a session neither listed nor already scoped.
+     * @returns the scoped Context, or undefined without a retained generation.
      */
     scope(id) {
-        return this.resolve(id)?.ctx;
+        return this.scopes.get(id)?.ctx;
     }
     /**
-     * Materialize the Agent scope named by a validated Host Remote Event.
-     * The first successful Session-list baseline becomes authoritative for its
-     * lifetime; until then, transport streams may address the scope in either
-     * arrival order.
-     * @param id - Host-projected Agent identity (the matching Session id).
-     * @returns the identity-stable Agent Context.
+     * Retain a validated Gateway identity synchronously, without history or catalog I/O.
+     * @param id - Host-projected Session identity, possibly not yet catalogued.
+     * @returns a Gateway-source reference owned by the invocation.
      */
-    resolveAgentScope(id) {
-        return (this.scopes.get(id) ?? this.materializeScope(id)).ctx;
+    retainAgentScope(id) {
+        if (this.closed)
+            throw new Error('Session Controller is disposed');
+        return this.retainScope(id, 'gateway');
     }
     /**
      * Read the Agent scope tag off a context. Service-method boundary: fetch
@@ -351,62 +410,79 @@ export class ClientSessions {
      * `agent.session`). Same service-method boundary as
      * {@link ClientSessions.scopeOf}.
      * @param ctx - an Agent-scoped context.
-     * @returns the session face, or undefined when the ctx is untagged or its scope was pruned.
+     * @returns the matching live Session, or undefined for an untagged or ended generation.
      */
     sessionOf(ctx) {
         const id = scopeTagOf(ctx);
         if (id === undefined)
             return undefined;
-        return this.scopes.get(id)?.binding.session;
+        const record = this.scopes.get(id);
+        return record !== undefined && scopeIdentityOf(record.ctx) === scopeIdentityOf(ctx)
+            ? record.binding.session
+            : undefined;
     }
     /**
-     * Resolve the stable session binding (scope-addressed assembly feed). Pure
-     * resolution — no staging, no window side effects.
-     * @param id - session id.
-     * @returns binding, or undefined for a session neither listed nor already scoped.
+     * Borrow an already-retained binding without extending its lifetime.
+     * @param id - Session identity.
+     * @returns the live binding, or undefined without a retained generation.
      */
     binding(id) {
-        return this.resolve(id)?.binding;
-    }
-    /**
-     * Move the stage to the list's current session: sweep teardowns deferred
-     * behind the previous occupant and pull the new occupant's history window.
-     * Staging IS the open signal — the window opens ⟺ the session is on stage
-     * — and open() is idempotent (an in-flight or completed open no-ops; a
-     * failed one retries the next time current is touched).
-     */
-    followCurrent() {
-        const snapshot = this.list.getSnapshot();
-        const current = snapshot.current;
-        // A masked gap (current blanked while the selection's session is
-        // transiently absent) holds the stage: tearing down on the gap would
-        // destroy exactly the frozen scope the mask exists to preserve.
-        if (current === undefined || snapshot.byId[current] === undefined || current === this.watched)
-            return;
-        this.watched = current;
-        this.sweepDeferred();
-        const record = this.resolve(current);
-        /* v8 ignore next 3 -- defensive: current is always a listed id (open()
-         * validates and the projection masks absent selections), so resolve
-         * cannot miss; kept so a future current writer cannot crash the notify. */
-        if (record !== undefined) {
-            void record.session.open();
-            void this.manager.refreshSubagents(current);
+        return this.scopes.get(id)?.binding;
+    }
+    retainScope(id, source) {
+        const record = this.scopes.get(id) ?? this.materializeScope(id);
+        const previous = record.retention;
+        record.retention = Object.freeze({
+            referenceCount: previous.referenceCount + 1,
+            retainedBy: freezeRetainedBy({ ...previous.retainedBy, [source]: (previous.retainedBy[source] ?? 0) + 1 }),
+        });
+        const reference = new ClientSessionReference(id, record, () => {
+            if (!record.live)
+                return;
+            const count = record.retention.referenceCount - 1;
+            const { [source]: sourceCount = 0, ...otherSources } = record.retention.retainedBy;
+            const retainedBy = sourceCount > 1 ? { ...otherSources, [source]: sourceCount - 1 } : otherSources;
+            record.retention = count === 0
+                ? EMPTY_RETAIN_INFO
+                : Object.freeze({ referenceCount: count, retainedBy: freezeRetainedBy(retainedBy) });
+            if (count === 0)
+                this.retireScope(id, record);
+            else
+                this.publishRetention(id);
+        });
+        if (this.list.getSnapshot().byId[id] === undefined)
+            this.projectList();
+        this.publishRetention(id);
+        return reference;
+    }
+    retentionSnapshot(id) {
+        return this.scopes.get(id)?.retention ?? EMPTY_RETAIN_INFO;
+    }
+    publishRetention(id) {
+        const state = this.list.getSnapshot();
+        const row = state.byId[id];
+        const retainedBy = this.retentionSnapshot(id).retainedBy;
+        if (row !== undefined && row.retainedBy !== retainedBy) {
+            this.list.set({ ...state, byId: { ...state.byId, [id]: { ...row, retainedBy } } });
         }
+        const observer = this.retainObservers.get(id);
+        const snapshot = this.retentionSnapshot(id);
+        if (observer === undefined || observer.published === snapshot)
+            return;
+        observer.published = snapshot;
+        notifySubscribers(observer.listeners, '[session-controller] reference sources');
     }
-    /**
-     * Lazily mint the scope + binding for an eligible session. Eligibility and
-     * prune share one predicate: listed on the host or selected
-     * through a retained subagent address. Breadcrumb-only ancestors remain
-     * summary data and do not keep scopes alive.
-     */
-    resolve(id) {
-        const existing = this.scopes.get(id);
-        if (existing !== undefined)
-            return existing;
-        if (!this.eligible(id))
-            return undefined;
-        return this.materializeScope(id);
+    retireScope(id, record, disposeFiber = true) {
+        if (!record.live)
+            return;
+        record.live = false;
+        if (this.scopes.get(id) === record)
+            this.scopes.delete(id);
+        record.session.unbindScope();
+        const sessionDisposal = this.manager.drop(id, record.session);
+        this.projectList();
+        this.publishRetention(id);
+        this.startScopeDrop(id, record, disposeFiber, sessionDisposal);
     }
     /** Materialize one scope after its caller establishes that the id may be addressed. */
     materializeScope(id) {
@@ -421,18 +497,17 @@ export class ClientSessions {
             ctx,
             binding,
             session,
+            retention: EMPTY_RETAIN_INFO,
+            live: true,
         };
         this.scopes.set(id, record);
+        ctx.effect(() => () => { this.retireScope(id, record, false); }, 'session-controller: exact generation');
         return record;
     }
-    /** The one aliveness predicate shared by scope mint and prune: host-listed or currently addressed. */
-    eligible(id) {
-        const { ids, current } = this.list.getSnapshot();
-        return current === id || ids.includes(id);
-    }
     /** Project the manager's list snapshot into the store (title derivation is display-only). */
     projectList() {
-        const { items, current, phase, subagentsByParent, jobsBySession, currentAddress, } = this.manager.getListSnapshot();
+        const previousById = this.list.getSnapshot().byId;
+        const { items, phase, subagentsByParent, jobsBySession, } = this.manager.getListSnapshot();
         const ids = [];
         const byId = {};
         for (const entry of items) {
@@ -441,7 +516,7 @@ export class ClientSessions {
                 id: entry.sessionId,
                 displayTitle: displayTitleOf(entry.title, entry.cwd, entry.sessionId),
                 running: entry.running,
-                ...(entry.completed ? { completed: true } : {}),
+                retainedBy: this.retentionSnapshot(entry.sessionId).retainedBy,
                 blank: entry.blank,
                 updatedAt: entry.updatedAt,
                 ...(entry.projectionValues === undefined
@@ -453,76 +528,52 @@ export class ClientSessions {
                 ...(entry.origin !== undefined ? { origin: entry.origin } : {}),
             };
         }
-        if (current !== undefined && currentAddress !== undefined) {
-            const seen = new Set();
-            let address = currentAddress;
-            while (address !== undefined && !seen.has(address.childSessionId)) {
-                const childId = address.childSessionId;
-                seen.add(childId);
-                const child = subagentsByParent[address.parentSessionId]?.entries
-                    .find(entry => entry.kind === 'child' && entry.id === childId);
-                if (child?.kind !== 'child')
-                    break;
-                const displayTitle = child.label ?? childId;
+        for (const [parentId, catalog] of Object.entries(subagentsByParent)) {
+            for (const child of catalog.entries) {
+                if (child.kind !== 'child')
+                    continue;
+                const childId = child.id;
                 const summary = byId[childId];
+                const projectionValues = summary?.projectionValues ?? this.manager.projectionValues(childId);
+                const projectedTitle = projectionValues?.title;
+                const title = typeof projectedTitle === 'string' && projectedTitle !== '' ? projectedTitle : undefined;
+                const displayTitle = title ?? child.label ?? childId;
                 if (summary === undefined) {
                     byId[childId] = {
-                        id: childId,
-                        displayTitle,
-                        parentId: address.parentSessionId,
-                        origin: 'subagent',
-                        running: child.activity === 'running',
-                        blank: false,
-                        updatedAt: 0,
+                        id: childId, displayTitle, parentId: parentId,
+                        origin: 'subagent', running: child.activity === 'running', blank: false, updatedAt: 0,
+                        retainedBy: this.retentionSnapshot(childId).retainedBy,
+                        ...(projectionValues === undefined ? {} : { projectionValues }),
+                        ...(title === undefined ? {} : { title }),
                     };
                 }
-                else if (summary.displayTitle !== displayTitle) {
-                    byId[childId] = { ...summary, displayTitle };
+                else if (summary.displayTitle !== displayTitle || summary.projectionValues !== projectionValues) {
+                    byId[childId] = {
+                        ...summary,
+                        displayTitle,
+                        ...(projectionValues === undefined ? {} : { projectionValues }),
+                    };
                 }
-                const parent = byId[address.parentSessionId];
-                if (parent !== undefined && parent.origin !== 'subagent')
-                    break;
-                address = this.manager.navigationAddress(address.parentSessionId);
             }
         }
-        const persisted = this.selection.getSnapshot().sessionId;
-        // No current (cleared, or masked gap) wipes the persisted cell — a reload
-        // stays on empty; the in-memory selection still resurfaces a masked id.
-        if (current === undefined) {
-            if (persisted !== undefined)
-                this.selection.set({});
-        }
-        else if (byId[current] !== undefined
-            && (persisted !== current
-                || this.selection.getSnapshot().subagentAddress?.childSessionId !== currentAddress?.childSessionId
-                || this.selection.getSnapshot().subagentAddress?.parentSessionId !== currentAddress?.parentSessionId
-                || this.selection.getSnapshot().subagentAddress?.mode !== currentAddress?.mode)) {
-            this.selection.set({
-                sessionId: current,
-                ...(currentAddress === undefined ? {} : { subagentAddress: currentAddress }),
-            });
-        }
-        this.list.set({ ids, byId, current, phase, subagentsByParent, jobsBySession, currentAddress });
-        this.pruneScopes();
-    }
-    /** Tear down scope + instance for no-longer-eligible sessions off stage; the staged one defers until the stage moves. */
-    pruneScopes() {
-        if (this.list.getSnapshot().phase === 'pending')
-            return;
         for (const [id, record] of this.scopes) {
-            if (this.eligible(id))
+            if (byId[id] !== undefined)
                 continue;
-            if (id === this.watched) {
-                this.deferredRemovals.add(id);
-                continue;
-            }
-            this.scopes.delete(id);
-            this.deferredRemovals.delete(id);
-            this.startScopeDrop(id, record);
+            const previous = previousById[id];
+            const snapshot = record.session.getSnapshot();
+            const address = this.manager.subagentAddress(id);
+            byId[id] = {
+                ...(previous ?? { id, displayTitle: id, updatedAt: 0 }),
+                running: snapshot.running,
+                retainedBy: record.retention.retainedBy,
+                blank: snapshot.blank,
+                ...(address === undefined ? {} : { parentId: address.parentSessionId, origin: 'subagent' }),
+            };
         }
+        this.list.set({ ids, byId, phase, subagentsByParent, jobsBySession });
     }
-    startScopeDrop(id, record) {
-        const drop = this.dropScope(id, record);
+    startScopeDrop(id, record, disposeFiber = true, sessionDisposal = this.manager.drop(id, record.session)) {
+        const drop = this.dropScope(record, disposeFiber, sessionDisposal);
         this.scopeDrops.add(drop);
         void drop.then(() => { this.scopeDrops.delete(drop); }, () => { this.scopeDrops.delete(drop); });
     }
@@ -531,45 +582,9 @@ export class ClientSessions {
             await Promise.allSettled([...this.scopeDrops]);
         }
     }
-    /**
-     * One teardown for the whole per-session axis: the scope
-     * fiber (cascading every actx-registered effect: input shell, slash
-     * controller, popup, plugin stores, listeners), the session-keyed slot
-     * registrations and the Session instance itself — the host session log is the
-     * durable truth, a reopen lazily rebuilds and backfills via open().
-     */
-    async dropScope(id, record) {
-        // Release the Session's dispatch point with the scope it belongs to (a
-        // surviving instance — the live Intent — rebinds when resolve re-mints).
-        record.session.unbindScope();
-        await Promise.allSettled([
-            record.fiber.dispose(),
-            this.manager.drop(id),
-        ]);
-    }
-    /** Run deferred teardowns whose session is no longer staged (called when the stage moves). */
-    sweepDeferred() {
-        for (const id of [...this.deferredRemovals]) {
-            /* v8 ignore next -- defensive: only the staged id ever defers, and every
-             * stage move sweeps first, so the set cannot contain the id the stage just
-             * moved to; kept as a guard against future extra sweep call sites. */
-            if (id === this.watched)
-                continue;
-            // Eligible again? (A re-added id cancels the deferred teardown.)
-            if (this.eligible(id)) {
-                this.deferredRemovals.delete(id);
-                continue;
-            }
-            const record = this.scopes.get(id);
-            this.deferredRemovals.delete(id);
-            /* v8 ignore next -- defensive: prune deletes a scope and its deferral
-             * together, so a deferred id always still owns its record; kept so a
-             * future teardown path cannot double-dispose. */
-            if (record !== undefined) {
-                this.scopes.delete(id);
-                this.startScopeDrop(id, record);
-            }
-        }
+    /** Await the already-withdrawn Session and scoped cleanup to quiescence. */
+    async dropScope(record, disposeFiber, sessionDisposal) {
+        await Promise.allSettled([sessionDisposal, ...disposeFiber ? [record.fiber.dispose()] : []]);
     }
 }
 //# sourceMappingURL=service.js.map