@khorsheed/dsh-room 0.2.1 → 0.2.3

package/lib/types/client/nodes.d.ts

@@ -11,12 +11,15 @@
  * RoomService.postMessage) and renders through the official user node.
  * @module @khorsheed/dsh-room/client/nodes
  */
+import type { RoomDecisionEvent, RoomHelp, RoomQuestionAnswer, RoomQuestionItem } from '../types.ts';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { ConversationNodeDefinition } from '@deepseek-ai/dsh-client-ui-conversation/client';
 /** Chat node data of one member speech row. */
 export interface RoomSpeechData {
     /** Partial output from a stopped or failed run; never a completed answer. */
     readonly interrupted?: 'cancelled' | 'failed';
+    /** The member this reply was also reported to. */
+    readonly reportedTo?: string;
     /** Seq of the room/speech event. */
     readonly seq: number;
     /** Unix epoch ms from the event. */
@@ -27,6 +30,10 @@ export interface RoomSpeechData {
     readonly childSessionId?: SessionId;
     /** Dispatch→settle milliseconds, when measured. */
     readonly durationMs?: number;
+    /** The run this speech closed: its execution metadata (tokens) is keyed by it. */
+    readonly runId?: string;
+    /** The member's closing message in its own session. */
+    readonly messageId?: string;
 }
 /** Chat node data of one member run row. */
 export interface RoomRunData {
@@ -57,6 +64,55 @@ export interface RoomEventData {
     readonly invitedBy?: 'human' | 'agent';
 }
 /** Chat node data of one member-to-member notification relay row. */
+/** Chat node data of a member's tool approval (the 允许 / 拒绝 line). */
+export interface RoomApprovalData {
+    readonly seq: number;
+    readonly time: number;
+    readonly approvalId: string;
+    readonly member: string;
+    readonly tool: string;
+    readonly reason?: string;
+    readonly state: 'pending' | 'allowed-once' | 'rejected' | 'cancelled';
+}
+/** Chat node data of one decision the room made on its own (a timeline row). */
+export interface RoomDecisionData {
+    readonly seq: number;
+    readonly time: number;
+    readonly decision: RoomDecisionEvent;
+}
+/** Chat node data of a cross-session help thread, in the asking room. */
+export interface RoomHelpData {
+    readonly seq: number;
+    readonly time: number;
+    readonly help: RoomHelp;
+}
+/** Chat node data of a help request (or a follow-up on it), in the helper's own session. */
+export interface RoomHelpRequestData {
+    readonly seq: number;
+    readonly time: number;
+    readonly help: string;
+    /** The asking room's session and title. */
+    readonly room: string;
+    readonly roomTitle: string;
+    /** The asking member. */
+    readonly from: string;
+    readonly op: 'request' | 'message';
+    /** The asker's own words. */
+    readonly text: string;
+    /** Another room asked this room: the member it went to, and whether the paused room holds it. */
+    readonly member?: string;
+    readonly held?: boolean;
+}
+/** Chat node data of a member's question card (pick-to-answer). */
+export interface RoomQuestionData {
+    readonly seq: number;
+    readonly time: number;
+    readonly questionId: string;
+    readonly member: string;
+    readonly questions: readonly RoomQuestionItem[];
+    readonly state: 'pending' | 'answered' | 'cancelled';
+    readonly answers?: readonly RoomQuestionAnswer[];
+}
 export interface RoomRelayData {
     /** Seq of the relay's latest journal event. */
     readonly seq: number;
@@ -68,17 +124,19 @@ export interface RoomRelayData {
     readonly to: string;
     readonly content: string;
     readonly state: 'pending' | 'confirmed' | 'dismissed' | 'sent';
+    /** Why the message waits (absent on legacy relays). */
+    readonly reason?: 'confirm' | 'hop-limit' | 'paused';
 }
-/** Chat node data of one task-advance line (the dim "✓ ada 完成了「…」" row). */
-export interface RoomTaskLineData {
-    /** Seq of the task's LATEST journal event (add or the closing update). */
+/** Chat node data of the held-reports line for one member. */
+export interface RoomInboxData {
+    /** Seq of the latest hold (the line sits there). */
     readonly seq: number;
-    /** Unix epoch ms of that event. */
     readonly time: number;
-    readonly taskId: string;
     readonly member: string;
-    readonly title: string;
-    readonly status: 'pending' | 'in_progress' | 'done' | 'cancelled' | 'failed';
+    /** Held dispatch seqs not yet released. */
+    readonly held: readonly number[];
+    /** The model's yes-probability on the latest hold, when it answered. */
+    readonly probability?: number;
 }
 declare module '@deepseek-ai/dsh-client-ui-chat/client' {
     interface ChatNodeDataMap {
@@ -90,8 +148,18 @@ declare module '@deepseek-ai/dsh-client-ui-chat/client' {
         'room-event': RoomEventData;
         /** room: a member-to-member notification relay (gate row). */
         'room-relay': RoomRelayData;
-        /** room: a task closure's advance line (visible only once done). */
-        'room-task-line': RoomTaskLineData;
+        /** room: a member's mode tool waiting for the human's approval. */
+        'room-approval': RoomApprovalData;
+        /** room: a decision the room made on its own (rule or decision model). */
+        'room-decision': RoomDecisionData;
+        /** room: a member's questions for the human (pick-to-answer card). */
+        'room-question': RoomQuestionData;
+        /** room: a help thread this room opened with another session. */
+        'room-help': RoomHelpData;
+        /** room: a help request another session's room sent this session. */
+        'room-help-request': RoomHelpRequestData;
+        /** room: reports the gate holds in a member's inbox. */
+        'room-inbox': RoomInboxData;
     }
 }
 /**
@@ -117,6 +185,18 @@ export declare const roomRunDefinition: ConversationNodeDefinition<RoomRunData>;
  * through the official user node (it is also appended as `user/message`).
  */
 export declare const roomEventDefinition: ConversationNodeDefinition<RoomEventData>;
+/** A room decision: one single-event Context per `room/decision`. */
+export declare const roomDecisionDefinition: ConversationNodeDefinition<RoomDecisionData>;
+/**
+ * A member's tool approval: one Context per approval, started by
+ * `room/approval` and settled in place by `room/approval-resolved`.
+ */
+export declare const roomApprovalDefinition: ConversationNodeDefinition<RoomApprovalData>;
+/**
+ * A member's question card: one Context per card, started by `room/question`
+ * and settled in place (with the answers) by `room/question-resolved`.
+ */
+export declare const roomQuestionDefinition: ConversationNodeDefinition<RoomQuestionData>;
 /**
  * The relay Definition: one Context per relay (matched on the relay id),
  * started by the `room/relay` event (pending) and updated by each
@@ -124,13 +204,28 @@ export declare const roomEventDefinition: ConversationNodeDefinition<RoomEventDa
  */
 export declare const roomRelayDefinition: ConversationNodeDefinition<RoomRelayData>;
 /**
- * The task-advance Definition: one Context per task (matched on the task id),
- * started by the `room/task-added` event and updated by each
- * `room/task-updated` edge. The node stays HIDDEN while the task is open or
- * cancelled and materializes — at the closing event's seq, so the line sits
- * at the moment of completion — only when the task closes done: the dim
- * advance line `✓ ada 完成了「API 定稿」── 目标进度 2/5`. (The goal progress
- * suffix is computed by the renderer from the room store, not folded here.)
+ * The held-reports line: one Context per member (its gate verdicts), visible
+ * while the gate holds reports for it — 「📥 dsh 的收件箱里有 2 条回报，先攒着」
+ * with a 现在交给 button — and hidden once they are released. It moves to the
+ * latest hold, so it always sits after the reply that was held.
+ */
+export declare const roomInboxDefinition: ConversationNodeDefinition<RoomInboxData>;
+/**
+ * A help thread in the asking room: one Context per thread, started by
+ * `room/help` and folded in place by its `room/help-message` and
+ * `room/help-state` events (one row whose state and messages update).
+ */
+export declare const roomHelpDefinition: ConversationNodeDefinition<RoomHelpData>;
+/**
+ * A help request in the helper's session: the `user/message` the room queued
+ * there (its `room-help` source) renders as a card naming the asking room
+ * instead of a plain injected-context row.
+ */
+export declare const roomHelpRequestDefinition: ConversationNodeDefinition<RoomHelpRequestData>;
+/**
+ * Another room asked this room for help (`room/help-in`): the same request
+ * card, naming the member it went to (and that it waits while this room is
+ * paused), with a jump back to the asking room.
  */
-export declare const roomTaskLineDefinition: ConversationNodeDefinition<RoomTaskLineData>;
+export declare const roomHelpInDefinition: ConversationNodeDefinition<RoomHelpRequestData>;
 //# sourceMappingURL=nodes.d.ts.map

package/lib/types/client/nodes.js

@@ -1,3 +1,4 @@
+import { isAppendSurfaceEvent } from '@deepseek-ai/dsh-session/surface';
 /** The shared final-node materialization (single shape across the three kinds). */
 function viewNode(context, kind, visibility = 'visible') {
     if (context.state === undefined)
@@ -33,8 +34,11 @@ export const roomSpeechDefinition = {
             member: event.data.member,
             text: event.data.text,
             ...event.data.interrupted === undefined ? {} : { interrupted: event.data.interrupted },
+            ...event.data.reportedTo === undefined ? {} : { reportedTo: event.data.reportedTo },
             ...event.data.childSessionId === undefined ? {} : { childSessionId: event.data.childSessionId },
             ...event.data.durationMs === undefined ? {} : { durationMs: event.data.durationMs },
+            ...event.data.runId === undefined ? {} : { runId: event.data.runId },
+            ...event.data.messageId === undefined ? {} : { messageId: event.data.messageId },
         };
     },
     update: context => context.state,
@@ -127,6 +131,86 @@ export const roomEventDefinition = {
     update: context => context.state,
     buildViewNode: context => viewNode(context, 'room-event'),
 };
+/** A room decision: one single-event Context per `room/decision`. */
+export const roomDecisionDefinition = {
+    kind: 'room-decision',
+    target: 'chat',
+    match: event => event.type === 'room/decision' ? { id: event.data.id, role: 'start' } : null,
+    start: (_context, match) => {
+        const event = match.event;
+        if (event.type !== 'room/decision')
+            throw new Error('room-decision start requires a room/decision event');
+        return { seq: event.seq, time: event.time, decision: event.data };
+    },
+    update: context => context.state,
+    buildViewNode: context => viewNode(context, 'room-decision'),
+};
+/**
+ * A member's tool approval: one Context per approval, started by
+ * `room/approval` and settled in place by `room/approval-resolved`.
+ */
+export const roomApprovalDefinition = {
+    kind: 'room-approval',
+    target: 'chat',
+    match: (event) => {
+        switch (event.type) {
+            case 'room/approval':
+                return { id: event.data.id, role: 'start' };
+            case 'room/approval-resolved':
+                return { id: event.data.id, role: 'update' };
+            default:
+                return null;
+        }
+    },
+    start: (_context, match) => {
+        const event = match.event;
+        if (event.type !== 'room/approval')
+            throw new Error('room-approval start requires a room/approval event');
+        return {
+            seq: event.seq, time: event.time, approvalId: event.data.id, member: event.data.member, tool: event.data.tool,
+            ...event.data.reason === undefined ? {} : { reason: event.data.reason },
+            state: 'pending',
+        };
+    },
+    update: (context, match) => {
+        const event = match.event;
+        if (event.type !== 'room/approval-resolved')
+            return context.state;
+        return { ...context.state, state: event.data.outcome };
+    },
+    buildViewNode: context => viewNode(context, 'room-approval'),
+};
+/**
+ * A member's question card: one Context per card, started by `room/question`
+ * and settled in place (with the answers) by `room/question-resolved`.
+ */
+export const roomQuestionDefinition = {
+    kind: 'room-question',
+    target: 'chat',
+    match: (event) => {
+        switch (event.type) {
+            case 'room/question':
+                return { id: event.data.id, role: 'start' };
+            case 'room/question-resolved':
+                return { id: event.data.id, role: 'update' };
+            default:
+                return null;
+        }
+    },
+    start: (_context, match) => {
+        const event = match.event;
+        if (event.type !== 'room/question')
+            throw new Error('room-question start requires a room/question event');
+        return { seq: event.seq, time: event.time, questionId: event.data.id, member: event.data.member, questions: event.data.questions, state: 'pending' };
+    },
+    update: (context, match) => {
+        const event = match.event;
+        if (event.type !== 'room/question-resolved')
+            return context.state;
+        return { ...context.state, state: event.data.outcome, ...event.data.answers === undefined ? {} : { answers: event.data.answers } };
+    },
+    buildViewNode: context => viewNode(context, 'room-question'),
+};
 /**
  * The relay Definition: one Context per relay (matched on the relay id),
  * started by the `room/relay` event (pending) and updated by each
@@ -156,6 +240,7 @@ export const roomRelayDefinition = {
             from: event.data.from,
             to: event.data.to,
             content: event.data.content,
+            ...event.data.reason === undefined ? {} : { reason: event.data.reason },
             state: 'pending',
         };
     },
@@ -168,45 +253,131 @@ export const roomRelayDefinition = {
     buildViewNode: context => viewNode(context, 'room-relay'),
 };
 /**
- * The task-advance Definition: one Context per task (matched on the task id),
- * started by the `room/task-added` event and updated by each
- * `room/task-updated` edge. The node stays HIDDEN while the task is open or
- * cancelled and materializes — at the closing event's seq, so the line sits
- * at the moment of completion — only when the task closes done: the dim
- * advance line `✓ ada 完成了「API 定稿」── 目标进度 2/5`. (The goal progress
- * suffix is computed by the renderer from the room store, not folded here.)
+ * The held-reports line: one Context per member (its gate verdicts), visible
+ * while the gate holds reports for it — 「📥 dsh 的收件箱里有 2 条回报，先攒着」
+ * with a 现在交给 button — and hidden once they are released. It moves to the
+ * latest hold, so it always sits after the reply that was held.
  */
-export const roomTaskLineDefinition = {
-    kind: 'room-task-line',
+export const roomInboxDefinition = {
+    kind: 'room-inbox',
+    target: 'chat',
+    match: (event) => {
+        if (event.type !== 'room/report-gate' || event.data.verdict === 'deliver')
+            return null;
+        return { id: event.data.memberId, role: event.data.verdict === 'hold' ? 'start' : 'update' };
+    },
+    start: (context, match) => {
+        const event = match.event;
+        if (event.type !== 'room/report-gate')
+            throw new Error('room-inbox requires a room/report-gate event');
+        const previous = context.state?.held ?? [];
+        return {
+            seq: event.seq, time: event.time, member: event.data.member,
+            held: [...previous.filter(seq => seq !== event.data.dispatchSeq), event.data.dispatchSeq],
+            ...event.data.probability === undefined ? {} : { probability: event.data.probability },
+        };
+    },
+    update: (context, match) => {
+        const event = match.event;
+        if (event.type !== 'room/report-gate' || context.state === undefined)
+            return context.state;
+        if (event.data.verdict === 'hold') {
+            return { ...context.state, seq: event.seq, time: event.time, held: [...context.state.held.filter(seq => seq !== event.data.dispatchSeq), event.data.dispatchSeq],
+                ...event.data.probability === undefined ? {} : { probability: event.data.probability } };
+        }
+        return { ...context.state, held: context.state.held.filter(seq => seq !== event.data.dispatchSeq) };
+    },
+    buildViewNode: context => viewNode(context, 'room-inbox', context.state !== undefined && context.state.held.length > 0 ? 'visible' : 'hidden'),
+};
+/**
+ * A help thread in the asking room: one Context per thread, started by
+ * `room/help` and folded in place by its `room/help-message` and
+ * `room/help-state` events (one row whose state and messages update).
+ */
+export const roomHelpDefinition = {
+    kind: 'room-help',
     target: 'chat',
     match: (event) => {
         switch (event.type) {
-            case 'room/task-added':
+            case 'room/help':
                 return { id: event.data.id, role: 'start' };
-            case 'room/task-updated':
-                return { id: event.data.id, role: 'update' };
+            case 'room/help-message':
+            case 'room/help-state':
+                return { id: event.data.help, role: 'update' };
             default:
                 return null;
         }
     },
     start: (_context, match) => {
         const event = match.event;
-        if (event.type !== 'room/task-added')
-            throw new Error('room-task-line start requires a room/task-added event');
-        return {
-            seq: event.seq,
-            time: event.time,
-            taskId: event.data.id,
-            member: event.data.member,
-            title: event.data.title,
-            status: event.data.status,
-        };
+        if (event.type !== 'room/help')
+            throw new Error('room-help start requires a room/help event');
+        return { seq: event.seq, time: event.time, help: { ...event.data, state: 'queued', since: event.time, messages: [], time: event.time } };
     },
     update: (context, match) => {
         const event = match.event;
-        if (event.type !== 'room/task-updated')
-            return context.state;
-        return { ...context.state, seq: event.seq, time: event.time, status: event.data.status };
+        const help = context.state.help;
+        if (event.type === 'room/help-message') {
+            return { ...context.state, help: { ...help, messages: [...help.messages, { ...event.data, time: event.time }] } };
+        }
+        if (event.type === 'room/help-state') {
+            const { error: _previous, ...rest } = help;
+            return { ...context.state, help: { ...rest, state: event.data.state, since: help.state === event.data.state ? help.since : event.time, ...event.data.error === undefined ? {} : { error: event.data.error } } };
+        }
+        return context.state;
+    },
+    buildViewNode: context => viewNode(context, 'room-help'),
+};
+/** A message source's help fields, when it is a room help source. */
+function helpSourceOf(source) {
+    const value = source;
+    if (value?.kind !== 'room-help' || typeof value.help !== 'string' || typeof value.room !== 'string')
+        return undefined;
+    const text = (key) => typeof value[key] === 'string' ? value[key] : '';
+    return { help: value.help, room: value.room, roomTitle: text('roomTitle'), from: text('from'), op: value.op === 'message' ? 'message' : 'request', text: text('text') };
+}
+/**
+ * A help request in the helper's session: the `user/message` the room queued
+ * there (its `room-help` source) renders as a card naming the asking room
+ * instead of a plain injected-context row.
+ */
+export const roomHelpRequestDefinition = {
+    kind: 'room-help-request',
+    target: 'chat',
+    match: (event) => {
+        if (event.type !== 'user/message' || !isAppendSurfaceEvent(event) || helpSourceOf(event.data.source) === undefined)
+            return null;
+        return { id: String(event.seq), role: 'start' };
+    },
+    start: (_context, match) => {
+        const event = match.event;
+        const source = event.type === 'user/message' ? helpSourceOf(event.data.source) : undefined;
+        if (source === undefined)
+            throw new Error('room-help-request start requires a room-help message');
+        return { seq: event.seq, time: event.time, ...source };
     },
-    buildViewNode: context => viewNode(context, 'room-task-line', context.state !== undefined && context.state.status === 'done' ? 'visible' : 'hidden'),
+    update: context => context.state,
+    buildViewNode: context => viewNode(context, 'room-help-request'),
+};
+/**
+ * Another room asked this room for help (`room/help-in`): the same request
+ * card, naming the member it went to (and that it waits while this room is
+ * paused), with a jump back to the asking room.
+ */
+export const roomHelpInDefinition = {
+    kind: 'room-help-in',
+    target: 'chat',
+    match: event => event.type === 'room/help-in' ? { id: String(event.seq), role: 'start' } : null,
+    start: (_context, match) => {
+        const event = match.event;
+        if (event.type !== 'room/help-in')
+            throw new Error('room-help-in start requires a room/help-in event');
+        const data = event.data;
+        return {
+            seq: event.seq, time: event.time, help: data.id, room: data.room, roomTitle: data.roomTitle, from: data.from,
+            op: data.op, text: data.text, member: data.member, ...data.held === true ? { held: true } : {},
+        };
+    },
+    update: context => context.state,
+    buildViewNode: context => viewNode(context, 'room-help-request'),
 };

package/lib/types/client/preset-visibility.d.ts

@@ -72,20 +72,30 @@ export declare class RoomPresetVisibility implements RoomChromeVisibility {
  * session and disposes otherwise; the slot's own subscription re-renders the
  * strip (the same re-registration mechanism the composer takeover's
  * promotion bump uses).
+ *
+ * Criterion-driven switches apply on the NEXT frame (see {@link nextFrame}),
+ * coalesced — repeated syncs collapse into the one scheduled frame, which
+ * reads the LATEST decision. The readiness gate's teardown arm is the
+ * exception: setReady(false) cancels a pending frame and unmounts a live
+ * registration SYNCHRONOUSLY, so nothing can register after it. (The plan
+ * tab-type toggle on sidebarRightTabs shares this class — its registry never
+ * fed refreshViews, and the same deferral is harmless there.)
  */
 export declare class RegistrationToggle {
     private readonly register;
     private readonly show;
     private dispose;
     private ready;
+    /** The coalesced pending re-evaluation's canceler; undefined when no frame is scheduled. */
+    private pending;
     /**
      * @param register - mounts the entry and returns its disposer.
-     * @param show - the current decision (re-read on every sync).
+     * @param show - the current decision (re-read when the scheduled frame runs).
      */
     constructor(register: () => () => void, show: () => boolean);
     /** The slot declaration appeared (slots.inject's arm) — decisions may register now. */
     setReady(ready: boolean): void;
-    /** Re-evaluate: register while shown and ready, dispose otherwise. */
+    /** Re-evaluate on the next frame: register while shown and ready, dispose otherwise. */
     sync(): void;
 }
 //# sourceMappingURL=preset-visibility.d.ts.map

package/lib/types/client/preset-visibility.js

@@ -66,6 +66,27 @@ export class RoomPresetVisibility {
             listener();
     }
 }
+/**
+ * The register/unregister beat: the NEXT animation frame (a zero timeout
+ * where no rAF exists — headless tests), cancellable.
+ *
+ * Why not synchronous: every change of a `conversation.view` registration
+ * re-triggers ui-conversation's `refreshViews`, which re-reads every mounted
+ * session binding and throws UNCAUGHT on one whose session record is already
+ * released — the window a session switch opens, and this toggle's sync() rides
+ * exactly that flush (upstream proposal
+ * docs/upstream-proposals/2026-10-20-refreshviews-stale-binding-robustness.md;
+ * the production incident killed the message timeline, which shared the
+ * aborted flush). One frame later the flush has settled.
+ */
+function nextFrame(callback) {
+    if (typeof requestAnimationFrame === 'function') {
+        const id = requestAnimationFrame(callback);
+        return () => { cancelAnimationFrame(id); };
+    }
+    const id = setTimeout(callback, 0);
+    return () => { clearTimeout(id); };
+}
 /**
  * The members tab's registration toggle: the `conversation.view` tab strip's
  * BUTTONS enumerate the slot's registrations (ui-conversation's `viewTabs()`
@@ -75,15 +96,25 @@ export class RoomPresetVisibility {
  * session and disposes otherwise; the slot's own subscription re-renders the
  * strip (the same re-registration mechanism the composer takeover's
  * promotion bump uses).
+ *
+ * Criterion-driven switches apply on the NEXT frame (see {@link nextFrame}),
+ * coalesced — repeated syncs collapse into the one scheduled frame, which
+ * reads the LATEST decision. The readiness gate's teardown arm is the
+ * exception: setReady(false) cancels a pending frame and unmounts a live
+ * registration SYNCHRONOUSLY, so nothing can register after it. (The plan
+ * tab-type toggle on sidebarRightTabs shares this class — its registry never
+ * fed refreshViews, and the same deferral is harmless there.)
  */
 export class RegistrationToggle {
     register;
     show;
     dispose;
     ready = false;
+    /** The coalesced pending re-evaluation's canceler; undefined when no frame is scheduled. */
+    pending;
     /**
      * @param register - mounts the entry and returns its disposer.
-     * @param show - the current decision (re-read on every sync).
+     * @param show - the current decision (re-read when the scheduled frame runs).
      */
     constructor(register, show) {
         this.register = register;
@@ -92,22 +123,32 @@ export class RegistrationToggle {
     /** The slot declaration appeared (slots.inject's arm) — decisions may register now. */
     setReady(ready) {
         this.ready = ready;
-        if (!ready && this.dispose !== undefined) {
-            this.dispose();
-            this.dispose = undefined;
+        if (!ready) {
+            this.pending?.();
+            this.pending = undefined;
+            if (this.dispose !== undefined) {
+                this.dispose();
+                this.dispose = undefined;
+            }
+            return;
         }
         this.sync();
     }
-    /** Re-evaluate: register while shown and ready, dispose otherwise. */
+    /** Re-evaluate on the next frame: register while shown and ready, dispose otherwise. */
     sync() {
-        if (!this.ready)
+        if (!this.ready || this.pending !== undefined)
             return;
-        if (this.show()) {
-            this.dispose ??= this.register();
-        }
-        else if (this.dispose !== undefined) {
-            this.dispose();
-            this.dispose = undefined;
-        }
+        this.pending = nextFrame(() => {
+            this.pending = undefined;
+            if (!this.ready)
+                return;
+            if (this.show()) {
+                this.dispose ??= this.register();
+            }
+            else if (this.dispose !== undefined) {
+                this.dispose();
+                this.dispose = undefined;
+            }
+        });
     }
 }