poly-weaver 0.15.3 → 1.0.0

package/dist/offscreen/controller.js

@@ -3,6 +3,7 @@ import { builtinStrategies, resolveProvider } from "../providers/registry.js";
 import { Fork } from "./fork.js";
 import { foldAltMetaKeys, isPrimaryIssueKey, isPrimaryShowKey, isSecondaryIssueKey, isSecondaryShowKey, isSummarizeKey, } from "./keys.js";
 import { InquiryPaneController } from "./inquiry-pane.js";
+import { StartingInquiryPane } from "./starting-pane.js";
 import { ArtifactPaneController } from "./artifact-pane.js";
 import { registerOffscreenDisposer } from "./registry.js";
 import { SplitInquiryCoordinator } from "./split-inquiry.js";
@@ -19,6 +20,7 @@ export class OffscreenController {
     host;
     workdir;
     inquiry;
+    observerRuns;
     slots = new Map();
     artifactConfigs;
     turnPollMs;
@@ -26,6 +28,9 @@ export class OffscreenController {
     tracksTurns;
     forks = new Map();
     pending = new Map();
+    pendingForks = new Map();
+    pendingQuestions = new Map();
+    launchAbort = new AbortController();
     sendPending = new Set();
     turnInProgress = new Set();
     turnMonitors = new Map();
@@ -41,14 +46,17 @@ export class OffscreenController {
     forkSubmitFloorReads = new Map();
     forkLocateWarned = new Set();
     activeArtifactIndexes = new Map();
+    artifactPanes = new Map();
     unregister;
     split;
     shown;
     disposed = false;
-    constructor(host, workdir, slots, artifactConfigs = {}, inquiry) {
+    disposal;
+    constructor(host, workdir, slots, artifactConfigs = {}, inquiry, observerRuns) {
         this.host = host;
         this.workdir = workdir;
         this.inquiry = inquiry;
+        this.observerRuns = observerRuns;
         for (const slot of slots) {
             this.slots.set(slot.binding, slot);
         }
@@ -66,7 +74,7 @@ export class OffscreenController {
     }
     selectionDelegate() {
         return {
-            fork: this.shown ? this.forks.get(this.shown) : undefined,
+            fork: this.shown ? this.presentedFork(this.shown) : undefined,
             layout: this.host.getLayout(),
             coordinator: this.activeCoordinator(),
         };
@@ -74,15 +82,16 @@ export class OffscreenController {
     wrap(base) {
         return {
             getSurface: () => {
-                const fork = this.shown ? this.forks.get(this.shown) : undefined;
-                if (!fork)
+                const fork = this.shown ? this.presentedFork(this.shown) : undefined;
+                if (!this.shown)
                     return base.getSurface();
                 const layout = this.host.getLayout();
                 const coordinator = this.activeCoordinator();
                 if (coordinator) {
                     return coordinator.getSurface(layout.columns, layout.childRows);
                 }
-                return new InquiryPaneController(fork).render(layout.columns, layout.childRows);
+                return (fork ? new InquiryPaneController(fork, this.forks.has(this.shown)) : this.startingPane(this.shown))
+                    .render(layout.columns, layout.childRows);
             },
             selectionRegionAt: (column, row) => {
                 const { fork, layout, coordinator } = this.selectionDelegate();
@@ -90,7 +99,7 @@ export class OffscreenController {
                     return coordinator.selectionRegionAt(column, row, layout.columns, layout.childRows);
                 }
                 if (!fork)
-                    return base.selectionRegionAt?.(column, row);
+                    return this.shown ? null : base.selectionRegionAt?.(column, row);
                 if (row < 2 || row > layout.childRows)
                     return null;
                 return fork.vt.isAlternate === true
@@ -103,7 +112,7 @@ export class OffscreenController {
                     return coordinator.selectionTargetAt(column, row, layout.columns, layout.childRows);
                 }
                 if (!fork)
-                    return base.selectionTargetAt?.(column, row) ?? null;
+                    return this.shown ? null : base.selectionTargetAt?.(column, row) ?? null;
                 if (fork.vt.isAlternate === true)
                     return null;
                 if (column < 1 || column > layout.columns || row < 2 || row > layout.childRows)
@@ -116,7 +125,7 @@ export class OffscreenController {
                     return coordinator.scrollSelectableSurfaceAt(column, row, direction, layout.columns, layout.childRows);
                 }
                 if (!fork || fork.vt.isAlternate === true) {
-                    return base.scrollSelectableSurfaceAt?.(column, row, direction) ?? 0;
+                    return this.shown ? 0 : base.scrollSelectableSurfaceAt?.(column, row, direction) ?? 0;
                 }
                 if (column < 1 || column > layout.columns)
                     return 0;
@@ -134,7 +143,7 @@ export class OffscreenController {
                     return placement ? { region: placement.region, vt: fork.vt } : undefined;
                 }
                 if (!fork || fork.vt.isAlternate === true || layout.childRows < 2) {
-                    return base.forkSelectionPlacement?.();
+                    return this.shown ? undefined : base.forkSelectionPlacement?.();
                 }
                 return {
                     region: { rowStart: 2, rowEnd: layout.childRows, colStart: 1, colEnd: layout.columns },
@@ -146,7 +155,7 @@ export class OffscreenController {
                 if (coordinator) {
                     return coordinator.artifactPlacementAt(column, row, layout.columns, layout.childRows);
                 }
-                if (fork)
+                if (this.shown)
                     return undefined;
                 return base.docSurfaceSelectionPlacementAt?.(column, row);
             },
@@ -156,7 +165,7 @@ export class OffscreenController {
                     const placement = coordinator.artifactPlacement(layout.columns, layout.childRows);
                     return placement ? [placement] : [];
                 }
-                if (fork)
+                if (this.shown)
                     return [];
                 return base.docSurfaceSelectionPlacements?.() ?? [];
             },
@@ -165,11 +174,13 @@ export class OffscreenController {
                 if (coordinator) {
                     return coordinator.artifactPlacement(layout.columns, layout.childRows);
                 }
-                if (fork)
+                if (this.shown)
                     return undefined;
                 return base.artifactSelectionPlacement?.();
             },
             onEvents: (keys) => {
+                if (this.disposed)
+                    return true;
                 const events = this.inquiry ? foldAltMetaKeys(keys) : keys;
                 if (keys.some(isSummarizeKey) && this.canSummarize("primary")) {
                     return this.summarize("primary");
@@ -201,41 +212,60 @@ export class OffscreenController {
             onResize: (cols, rows) => {
                 if (this.disposed)
                     return;
-                const fork = this.shown ? this.forks.get(this.shown) : undefined;
-                if (fork && this.shown)
+                const fork = this.shown ? this.presentedFork(this.shown) : undefined;
+                if (this.shown)
                     this.configurePresentation(this.shown, fork, cols, rows);
                 this.updateForkState();
             },
         };
     }
     dispose() {
-        if (this.disposed)
-            return;
+        if (this.disposal)
+            return this.disposal;
         this.disposed = true;
+        this.launchAbort.abort();
         this.unregister();
         for (const binding of Array.from(this.sendControllers.keys())) {
             this.abortIssueSend(binding);
         }
         this.clearForkSessionWatchers();
-        for (const fork of this.forks.values()) {
-            fork.kill();
-        }
+        const releases = [...this.forks.values(), ...this.pendingForks.values()].map((fork) => fork.kill());
+        const pending = Array.from(this.pending.values());
         this.forks.clear();
         this.pending.clear();
+        this.pendingForks.clear();
+        this.pendingQuestions.clear();
+        this.artifactPanes.clear();
         this.sendPending.clear();
         this.sendLocks.clear();
         this.shown = undefined;
         this.clearSplitCoordinator();
         this.host.clearMouseModeSource(OFFSCREEN_MOUSE_SOURCE);
         this.updateForkState();
+        return this.disposal = Promise.all([...releases, ...pending]).then(() => { });
     }
     handleForkEvents(keys) {
         const binding = this.shown;
         const fork = binding ? this.forks.get(binding) : undefined;
         if (!fork) {
-            this.shown = undefined;
-            this.clearSplitCoordinator();
-            this.updateForkState();
+            if (!binding)
+                return true;
+            if (keys.some((key) => key.kind === "control" && key.byte === 0x03)) {
+                this.hideFork(this.pendingForks.get(binding));
+                return true;
+            }
+            for (const key of keys) {
+                if (isArtifactViewerKey(key) && this.cycleCompanionArtifact(binding))
+                    continue;
+                const shortcut = this.inquiry ? inquiryShortcutForKey(key) : undefined;
+                if (shortcut?.kind === "issue" && shortcut.binding === binding) {
+                    this.openInquiry(shortcut);
+                }
+            }
+            const layout = this.host.getLayout();
+            const result = this.activeCoordinator()?.handleArtifactScroll(keys, layout.columns, layout.childRows);
+            if (result)
+                this.applyPaneResult(undefined, result);
             return true;
         }
         if (binding && this.sendLocks.has(binding)) {
@@ -335,14 +365,17 @@ export class OffscreenController {
             this.hideFork(fork);
         }
     }
+    presentedFork(binding) {
+        return this.forks.get(binding) ?? this.pendingForks.get(binding);
+    }
     hideFork(fork) {
         if (this.shown)
             this.abortIssueSend(this.shown);
         if (this.activeCoordinator()) {
             const layout = this.host.getLayout();
-            fork.resize(layout.columns, layout.childRows);
+            fork?.resize(layout.columns, layout.childRows);
         }
-        fork.setVisible(false);
+        fork?.setVisible(false);
         this.shown = undefined;
         this.clearSplitCoordinator();
         this.host.clearMouseModeSource(OFFSCREEN_MOUSE_SOURCE);
@@ -375,7 +408,7 @@ export class OffscreenController {
         ];
     }
     nextCompanionArtifactHint(binding) {
-        if (this.shown !== binding || !this.forks.has(binding))
+        if (this.shown !== binding)
             return undefined;
         const config = this.artifactConfigs[binding];
         if (!config)
@@ -388,8 +421,8 @@ export class OffscreenController {
     }
     cycleCompanionArtifact(binding) {
         const primary = this.artifactConfigs[binding];
-        const fork = this.forks.get(binding);
-        if (!primary || !fork)
+        const fork = this.presentedFork(binding);
+        if (!primary)
             return false;
         const count = this.companionArtifacts(primary).length;
         if (count <= 1)
@@ -405,21 +438,33 @@ export class OffscreenController {
     configurePresentation(binding, fork, cols, rows) {
         const artifact = this.activeArtifactConfig(binding);
         if (artifact && (cols >= SPLIT_COLLAPSE_AT_COLS || artifact.collapseWhenNarrow)) {
+            const index = this.activeArtifactIndexes.get(binding) ?? 0;
+            let panes = this.artifactPanes.get(binding);
+            if (!panes)
+                this.artifactPanes.set(binding, panes = new Map());
+            let artifactPane = panes.get(index);
+            if (!artifactPane) {
+                artifactPane = new ArtifactPaneController(artifact.renderArtifact, artifact.styleVersion);
+                panes.set(index, artifactPane);
+            }
             this.split = {
                 binding,
                 coordinator: new SplitInquiryCoordinator({
                     inquirySide: artifact.inquirySide,
-                    inquiryPane: new InquiryPaneController(fork),
-                    artifactPane: new ArtifactPaneController(artifact.renderArtifact, artifact.styleVersion),
+                    inquiryPane: fork ? new InquiryPaneController(fork, this.forks.has(binding)) : this.startingPane(binding),
+                    artifactPane,
                     collapseAt: SPLIT_COLLAPSE_AT_COLS,
                     collapseArtifact: artifact.collapseWhenNarrow,
                 }),
             };
-            fork.resize(this.split.coordinator.inquiryWidth(cols), this.split.coordinator.inquiryHeight(cols, rows));
+            fork?.resize(this.split.coordinator.inquiryWidth(cols), this.split.coordinator.inquiryHeight(cols, rows));
             return;
         }
         this.clearSplitCoordinator();
-        fork.resize(cols, rows);
+        fork?.resize(cols, rows);
+    }
+    startingPane(binding) {
+        return new StartingInquiryPane(this.slots.get(binding).roleLabel);
     }
     focusArtifactForCurrentIssue(binding) {
         if (this.shown !== binding)
@@ -445,60 +490,98 @@ export class OffscreenController {
             this.host.scheduleParentUiRender();
             return;
         }
-        void this.ensureFork(binding, slot)
-            .then((fork) => {
-            if (this.disposed) {
-                fork.kill();
-                return;
-            }
-            for (const [key, other] of this.forks) {
-                if (key !== binding)
-                    other.setVisible(false);
-            }
-            const layout = this.host.getLayout();
-            this.shown = binding;
-            this.configurePresentation(binding, fork, layout.columns, layout.childRows);
-            if (focusIssueArtifact)
-                this.focusArtifactForCurrentIssue(binding);
-            fork.setVisible(true);
-            this.updateForkState();
-            this.host.scheduleRender();
+        if (this.shown && this.shown !== binding)
+            this.abortIssueSend(this.shown);
+        for (const [key, other] of [...this.forks, ...this.pendingForks]) {
+            if (key !== binding)
+                other.setVisible(false);
+        }
+        const fork = this.forks.get(binding);
+        const presented = this.presentedFork(binding);
+        const layout = this.host.getLayout();
+        this.shown = binding;
+        this.configurePresentation(binding, presented, layout.columns, layout.childRows);
+        if (focusIssueArtifact)
+            this.focusArtifactForCurrentIssue(binding);
+        presented?.setVisible(true);
+        this.updateForkState();
+        this.host.scheduleRender();
+        if (fork) {
             if (question)
                 this.startInquirySend(binding, fork, question);
-        })
-            .catch((err) => {
-            this.clearSendPending(binding);
-            const reason = err instanceof Error ? err.message : String(err);
-            this.host.output.warn(`offscreen ${slot.roleLabel} fork failed: ${reason}`);
-            this.updateForkState();
-            this.host.scheduleParentUiRender();
-        });
+        }
+        else {
+            if (question)
+                this.pendingQuestions.set(binding, question);
+            this.ensureFork(binding, slot);
+        }
     }
     ensureFork(binding, slot) {
-        const existing = this.forks.get(binding);
-        if (existing)
-            return Promise.resolve(existing);
-        const pending = this.pending.get(binding);
-        if (pending)
-            return pending;
-        const layout = this.host.getLayout();
-        const created = Fork.spawn(slot, this.workdir, this.host, layout.columns, layout.childRows, () => this.updateForkState()).then((fork) => {
-            this.pending.delete(binding);
-            if (this.disposed) {
-                fork.kill();
-                return fork;
+        if (this.pending.has(binding))
+            return;
+        let constructed;
+        // The host's coalesced first frame must run before any provider preparation.
+        const created = new Promise((resolve) => setImmediate(resolve)).then(async () => {
+            this.launchAbort.signal.throwIfAborted();
+            const layout = this.host.getLayout();
+            return Fork.spawn(slot, this.workdir, this.host, layout.columns, layout.childRows, () => {
+                if (!this.disposed && constructed && this.presentedFork(binding) === constructed) {
+                    this.updateForkState();
+                }
+            }, this.observerRuns, this.launchAbort.signal, (fork) => {
+                constructed = fork;
+                if (this.disposed || this.pending.get(binding) !== created) {
+                    void fork.kill();
+                    return;
+                }
+                this.pendingForks.set(binding, fork);
+                if (this.shown !== binding)
+                    return;
+                const layout = this.host.getLayout();
+                this.configurePresentation(binding, fork, layout.columns, layout.childRows);
+                fork.setVisible(true);
+                this.updateForkState();
+                this.host.scheduleParentUiRender();
+            });
+        }).then(async (fork) => {
+            if (this.disposed || this.pending.get(binding) !== created) {
+                await fork.kill();
+                return;
             }
+            constructed = fork;
+            this.pendingForks.delete(binding);
             this.forks.set(binding, fork);
             if (this.tracksTurns) {
                 void this.ensureForkSession(binding, fork);
             }
-            return fork;
+            if (this.shown === binding) {
+                const layout = this.host.getLayout();
+                this.configurePresentation(binding, fork, layout.columns, layout.childRows);
+                fork.setVisible(true);
+                this.updateForkState();
+                this.host.scheduleRender();
+            }
+            const question = this.pendingQuestions.get(binding);
+            this.pendingQuestions.delete(binding);
+            if (question)
+                this.startInquirySend(binding, fork, question);
         }).catch((err) => {
-            this.pending.delete(binding);
-            throw err;
+            if (this.disposed && err === this.launchAbort.signal.reason)
+                return;
+            const reason = err instanceof Error ? err.message : String(err);
+            this.host.output.warn(`offscreen ${slot.roleLabel} fork failed: ${reason}`);
+            if (this.disposed || this.pending.get(binding) !== created)
+                return;
+            this.pendingQuestions.delete(binding);
+            this.clearSendPending(binding);
+            this.pendingForks.delete(binding);
+            if (this.shown === binding)
+                this.hideFork();
+        }).finally(() => {
+            if (this.pending.get(binding) === created)
+                this.pending.delete(binding);
         });
         this.pending.set(binding, created);
-        return created;
     }
     startInquirySend(binding, fork, question) {
         if (this.disposed || this.sendControllers.has(binding))
@@ -515,13 +598,16 @@ export class OffscreenController {
             composer,
             beforeSubmit: async () => {
                 await this.turnMonitors.get(binding)?.refreshExpiredAttempts();
+                controller.signal.throwIfAborted();
+                this.launchAbort.signal.throwIfAborted();
                 receipt = this.reserveTurn(binding);
             },
             onSubmitWritten: () => receipt?.markWritten(),
             onSubmitted: () => {
                 submitted = true;
                 receipt?.confirm();
-                this.clearSendPending(binding);
+                if (!this.disposed && this.sendControllers.get(binding) === controller)
+                    this.clearSendPending(binding);
             },
         }).catch((err) => {
             if (!controller.signal.aborted) {
@@ -530,6 +616,8 @@ export class OffscreenController {
             }
         }).finally(() => {
             receipt?.release();
+            if (this.disposed)
+                return;
             if (receipt?.settlement === "released") {
                 const remaining = (this.pendingTurns.get(binding) ?? []).filter((pending) => pending !== receipt);
                 if (remaining.length > 0)
@@ -538,9 +626,9 @@ export class OffscreenController {
                     this.pendingTurns.delete(binding);
                 this.refreshStagedActivity(binding);
             }
-            if (this.sendControllers.get(binding) === controller) {
-                this.sendControllers.delete(binding);
-            }
+            if (this.sendControllers.get(binding) !== controller)
+                return;
+            this.sendControllers.delete(binding);
             this.sendLocks.delete(binding);
             if (!submitted)
                 this.clearSendPending(binding);
@@ -556,7 +644,8 @@ export class OffscreenController {
     clearSendPending(binding) {
         if (!this.sendPending.delete(binding))
             return;
-        this.host.scheduleParentUiRender();
+        if (!this.disposed)
+            this.host.scheduleParentUiRender();
     }
     reserveTurn(binding, rawAttempt = false) {
         const pendingChanged = this.sendPending.delete(binding);
@@ -619,8 +708,9 @@ export class OffscreenController {
         const turnChanged = !this.turnInProgress.has(binding);
         this.turnInProgress.add(binding);
         const fork = this.forks.get(binding);
-        if (!this.forkSessionFiles.has(binding)
-            || (fork && this.needsSubmitFloor(binding, fork))) {
+        if (!this.turnMonitors.has(binding)
+            && (!this.forkSessionFiles.has(binding)
+                || (fork && this.needsSubmitFloor(binding, fork)))) {
             if (fork) {
                 this.forkLocateAborts.get(binding)?.abort();
                 this.forkSession.delete(binding);
@@ -649,6 +739,17 @@ export class OffscreenController {
         const abort = new AbortController();
         this.forkLocateAborts.set(binding, abort);
         const promise = (async () => {
+            const liveMonitor = fork.createTurnMonitor?.(this.forkMonitorOptions(binding));
+            if (liveMonitor) {
+                this.installForkTurnMonitor(binding, liveMonitor);
+                return;
+            }
+            const policy = resolveProvider(fork.driver).forkSubmitFloor;
+            if (!policy) {
+                if (this.turnInProgress.has(binding))
+                    this.warnForkSessionUnavailable(binding);
+                return;
+            }
             await this.captureForkSubmitFloor(binding, fork, abort.signal);
             if (this.disposed || abort.signal.aborted)
                 return;
@@ -673,7 +774,6 @@ export class OffscreenController {
                 }
             }
             else {
-                const policy = resolveProvider(fork.driver).forkSubmitFloor;
                 while (!this.disposed && !abort.signal.aborted && this.needsTurnObservation(binding)) {
                     let lines;
                     try {
@@ -711,7 +811,8 @@ export class OffscreenController {
         return promise;
     }
     async captureForkSubmitFloor(binding, fork, signal) {
-        if (resolveProvider(fork.driver).forkSubmitFloor.from !== "source")
+        const policy = resolveProvider(fork.driver).forkSubmitFloor;
+        if (!policy || policy.from !== "source")
             return;
         if (this.forkSubmitFloors.has(binding))
             return;
@@ -775,6 +876,8 @@ export class OffscreenController {
             void this.ensureForkSession(binding, fork);
             return;
         }
+        if (!resolveProvider(fork.driver).forkSubmitFloor)
+            return;
         const providerFork = resolveProvider(fork.driver).fork;
         const effectiveSubmitCount = providerFork.forkFileSubmitFloor
             ? (lines) => Math.max(0, submitCount(fork.driver, lines) -
@@ -786,6 +889,14 @@ export class OffscreenController {
             submitFloor: this.forkSubmitFloors.get(binding),
             submitCount: effectiveSubmitCount,
             readResult: readSessionFileWithStatus,
+            ...this.forkMonitorOptions(binding),
+        });
+        this.installForkTurnMonitor(binding, monitor);
+    }
+    forkMonitorOptions(binding) {
+        return {
+            pollMs: this.turnPollMs,
+            attemptTimeoutMs: this.turnAttemptTimeoutMs,
             onReadFailure: () => this.warnForkSessionUnavailable(binding),
             onHistorySnapshot: (snapshot) => {
                 this.forkBaselines.set(binding, snapshot.lineCount);
@@ -802,27 +913,36 @@ export class OffscreenController {
                     }
                     return;
                 }
-                this.forkBaselines.set(binding, monitor.lineBaseline);
-                const submitFloor = monitor.currentSubmitFloor;
-                if (submitFloor !== undefined) {
-                    this.forkSubmitFloors.set(binding, submitFloor);
+                const monitor = this.turnMonitors.get(binding);
+                if (monitor) {
+                    this.forkBaselines.set(binding, monitor.lineBaseline);
+                    const submitFloor = monitor.currentSubmitFloor;
+                    if (submitFloor !== undefined) {
+                        this.forkSubmitFloors.set(binding, submitFloor);
+                    }
                 }
                 this.releaseTurn(binding);
             },
-        });
+        };
+    }
+    installForkTurnMonitor(binding, monitor, initialLines) {
         this.turnMonitors.set(binding, monitor);
         const pending = this.pendingTurns.get(binding) ?? [];
         this.clearStagedAttemptTimers(binding);
         this.pendingTurns.delete(binding);
         monitor.attachTurns(pending, initialLines);
     }
-    needsSubmitFloor(binding, _fork) {
+    needsSubmitFloor(binding, fork) {
+        if (!resolveProvider(fork.driver).forkSubmitFloor)
+            return false;
         return !this.forkSubmitFloors.has(binding);
     }
     clearTurnPoll(binding) {
         const monitor = this.turnMonitors.get(binding);
         if (monitor) {
-            if (monitor.supportsHistoryRegression || monitor.hasUnobservedExpiredAttempts)
+            if (monitor.supportsHistoryRegression
+                || monitor.hasUnobservedExpiredAttempts
+                || monitor.classifyDeliverySince)
                 return;
             monitor.dispose();
             this.turnMonitors.delete(binding);
@@ -855,6 +975,7 @@ export class OffscreenController {
         this.host.output.warn(`offscreen inquiry fork session unavailable for ${binding}; inquiry remains busy`);
     }
     abortIssueSend(binding) {
+        this.pendingQuestions.delete(binding);
         const controller = this.sendControllers.get(binding);
         if (controller) {
             controller.abort(new Error("Inquiry send aborted"));
@@ -889,7 +1010,7 @@ export class OffscreenController {
     }
     updateVisibleMouseModes() {
         const fork = this.shown ? this.forks.get(this.shown) : undefined;
-        if (!fork) {
+        if (!this.shown) {
             this.host.clearMouseModeSource(OFFSCREEN_MOUSE_SOURCE);
             return;
         }
@@ -901,7 +1022,7 @@ export class OffscreenController {
         this.updateVisibleMouseModes();
     }
     visibleMouseModes(fork) {
-        const modes = fork.mouseModes();
+        const modes = fork?.mouseModes() ?? [];
         const coordinator = this.activeCoordinator();
         if (!coordinator)
             return modes;