@fdcn/sourcefed 0.3.5 → 0.3.7

package/dist/opencode.js

@@ -7,7 +7,7 @@ import {
   daemonCommand,
   daemonEnvironment,
   spawnLocalDaemon
-} from "./chunk-X3BZSHKZ.js";
+} from "./chunk-E6J3BAXP.js";
 import "./chunk-MLKGABMK.js";
 
 // packages/sourcefed/src/server.ts
@@ -22,9 +22,193 @@ import { Plugin } from "@opencode/plugin";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { Rpc } from "@opencode/plugin";
+
+// adapters/opencode/subscriptions.ts
+var REFRESH_MS = 15e3;
+var OpenCodeSubscriptions = class {
+  constructor(connect) {
+    this.connect = connect;
+  }
+  owners = /* @__PURE__ */ new Set();
+  subscriptions = /* @__PURE__ */ new Map();
+  lifetime = new AbortController();
+  daemon;
+  connecting;
+  refreshing;
+  dirty = false;
+  lastAttemptAt = -Infinity;
+  timer;
+  get closed() {
+    return this.lifetime.signal.aborted;
+  }
+  async add(owner) {
+    if (this.closed) throw new Error("sourcefed subscription hub is closed");
+    this.owners.add(owner);
+    if (!this.timer) {
+      this.timer = setInterval(() => void this.refresh(), REFRESH_MS);
+      this.timer.unref?.();
+    }
+    await this.refresh();
+  }
+  async remove(owner) {
+    this.owners.delete(owner);
+    const closing = [];
+    for (const [id, subscription] of this.subscriptions) {
+      if (this.ownerFor(subscription.info)) continue;
+      this.subscriptions.delete(id);
+      closing.push(this.closeSubscription(subscription));
+    }
+    if (this.owners.size > 0) {
+      await Promise.all(closing);
+      await this.refresh();
+      return;
+    }
+    this.lifetime.abort();
+    clearInterval(this.timer);
+    this.timer = void 0;
+    await Promise.all(closing);
+    await this.daemon?.close();
+    this.daemon = void 0;
+    await this.connecting;
+    await this.refreshing;
+  }
+  async request(method, params) {
+    const daemon = await this.ensureDaemon();
+    if (!daemon || this.closed) throw new Error("sourcefed daemon unavailable or bridge closed");
+    return daemon.request(method, params);
+  }
+  refresh() {
+    if (this.closed) return Promise.resolve();
+    this.dirty = true;
+    if (!this.refreshing) {
+      this.refreshing = this.refreshLoop();
+    }
+    return this.refreshing;
+  }
+  async refreshLoop() {
+    try {
+      do {
+        this.dirty = false;
+        try {
+          const daemon = await this.ensureDaemon();
+          if (daemon && !this.closed) await this.reconcile(daemon);
+        } catch (error) {
+          if (!this.closed) console.error(`[sourcefed] refresh failed: ${String(error)}`);
+        }
+      } while (this.dirty && !this.closed);
+    } finally {
+      this.refreshing = void 0;
+    }
+  }
+  async ensureDaemon() {
+    if (this.closed) return void 0;
+    if (this.daemon) return this.daemon;
+    if (this.connecting) return this.connecting;
+    if (Date.now() - this.lastAttemptAt < REFRESH_MS) return void 0;
+    this.lastAttemptAt = Date.now();
+    this.connecting = this.connect().then(async (daemon) => {
+      if (this.closed) {
+        await daemon.close();
+        return void 0;
+      }
+      this.daemon = daemon;
+      return daemon;
+    }).catch((error) => {
+      console.error(`[sourcefed] daemon unavailable: ${String(error)}`);
+      return void 0;
+    }).finally(() => {
+      this.connecting = void 0;
+    });
+    return this.connecting;
+  }
+  async reconcile(daemon) {
+    const result = await daemon.request("monitor.targets", { kind: "opencode-session" });
+    const targets = enabledSessions(result);
+    for (const [id, subscription] of this.subscriptions) {
+      if (targets.has(id)) continue;
+      this.subscriptions.delete(id);
+      await this.closeSubscription(subscription);
+    }
+    for (const id of targets) {
+      if (this.closed) return;
+      const reader = this.owners.values().next().value;
+      if (!reader) return;
+      let info;
+      try {
+        info = await reader.getSession(id, this.lifetime.signal);
+      } catch (error) {
+        if (!error || typeof error !== "object" || !("_tag" in error) || error._tag !== "SessionNotFoundError") {
+          if (!this.closed) console.error(`[sourcefed] session ${id} lookup failed: ${String(error)}`);
+          continue;
+        }
+      }
+      if (this.closed) return;
+      const owner = info && this.ownerFor(info);
+      const existing = this.subscriptions.get(id);
+      if (!owner || !info) {
+        if (existing) {
+          this.subscriptions.delete(id);
+          await this.closeSubscription(existing);
+        }
+      } else if (existing) {
+        existing.info = info;
+      } else {
+        await this.subscribe(daemon, id, info);
+      }
+    }
+  }
+  ownerFor(info) {
+    const candidates = [...this.owners].filter((owner) => owner.location.project.id === info.projectID);
+    return candidates.find((owner) => owner.location.directory === info.location.directory) ?? candidates[0];
+  }
+  async subscribe(daemon, id, info) {
+    const controller = new AbortController();
+    const subscription = {
+      info,
+      controller,
+      listener: daemon.subscribe({ kind: "opencode-session", id }, async (events) => {
+        await this.route(id, subscription, events);
+      }, { signal: controller.signal })
+    };
+    this.subscriptions.set(id, subscription);
+    try {
+      await subscription.listener;
+    } catch (error) {
+      if (this.subscriptions.get(id) === subscription) this.subscriptions.delete(id);
+      if (!controller.signal.aborted) console.error(`[sourcefed] subscribe ${id} failed: ${String(error)}`);
+    }
+  }
+  async route(id, subscription, events) {
+    const reader = this.owners.values().next().value;
+    if (!reader) throw new Error("sourcefed session owner unloaded");
+    const info = await reader.getSession(id, this.lifetime.signal);
+    const owner = this.ownerFor(info);
+    if (!owner) throw new Error("sourcefed session has no loaded project owner");
+    subscription.info = info;
+    await owner.routeEvents(events);
+  }
+  async closeSubscription(subscription) {
+    subscription.controller.abort();
+    await subscription.listener.then((listener) => listener.close(), () => void 0);
+  }
+};
+function enabledSessions(result) {
+  if (!result || typeof result !== "object" || !("targets" in result) || !Array.isArray(result.targets)) {
+    throw new Error("invalid monitor.targets response");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const target of result.targets) {
+    if (!target || target.kind !== "opencode-session" || typeof target.id !== "string") {
+      throw new Error("invalid opencode-session target");
+    }
+    ids.add(target.id);
+  }
+  return ids;
+}
+
+// adapters/opencode/bridge.ts
 var TARGET_KIND = "opencode-session";
 var GATE_TIMEOUT_MS = 3e3;
-var RESUBSCRIBE_MS = 15e3;
 var ChauffeurGate = Rpc.define({
   id: "chauffeur",
   methods: {
@@ -52,97 +236,53 @@ var ChauffeurGate = Rpc.define({
   },
   events: {}
 });
-var activeBridge;
+var HUB = Symbol.for("sourcefed.opencode.subscriptions.v1");
+var shared = globalThis;
+function subscriptions() {
+  if (!shared[HUB] || shared[HUB].closed) shared[HUB] = new OpenCodeSubscriptions(connectDaemon);
+  return shared[HUB];
+}
 var OpenCodeBridge = class {
-  constructor(session, rpc) {
+  constructor(session, rpc, location, hub = subscriptions()) {
     this.session = session;
     this.rpc = rpc;
+    this.location = location;
+    this.hub = hub;
   }
-  daemon;
-  listeners = /* @__PURE__ */ new Map();
-  lastAttemptAt = 0;
-  lastError;
-  timer;
+  started;
+  closed = false;
+  closing;
   /**
    * Chauffeur or the CLI can create a monitor for a session here at any time,
    * without this bridge's tools, so check for new targets periodically too.
    */
   async start() {
-    await this.ensureDaemon();
-    this.timer = setInterval(() => void this.refresh(), RESUBSCRIBE_MS);
-    this.timer.unref?.();
+    if (this.closed) throw new Error("sourcefed bridge is closed");
+    this.started ??= this.hub.add(this);
+    await this.started;
   }
-  async ensureTarget(sessionID) {
-    await this.ensureDaemon();
-    const existing = this.listeners.get(sessionID);
-    if (existing) {
-      await existing;
-      return;
-    }
-    const pending = this.daemon.subscribe(this.target(sessionID), async (events) => {
-      await this.routeEvents(events);
-    });
-    this.listeners.set(sessionID, pending);
+  async callTool(name, arguments_, sessionID) {
     try {
-      await pending;
+      await this.start();
+      const method = name.replace(/_/g, ".");
+      const result = await this.hub.request(method, { ...arguments_, target: this.target(sessionID) });
+      if (["monitor.create", "monitor.start", "monitor.stop", "monitor.remove"].includes(method)) await this.hub.refresh();
+      return result;
     } catch (error) {
-      this.listeners.delete(sessionID);
-      throw error;
-    }
-  }
-  async callTool(name, arguments_, sessionID) {
-    await this.ensureDaemon();
-    if (!this.daemon) {
-      return { ok: false, error: `sourcefed daemon unavailable: ${this.lastError ?? "not started"}` };
+      return { ok: false, error: String(error) };
     }
-    await this.ensureTarget(sessionID);
-    return this.daemon.request(name.replace(/_/g, "."), { ...arguments_, target: this.target(sessionID) });
   }
-  async close() {
-    clearInterval(this.timer);
-    this.timer = void 0;
-    for (const pending of this.listeners.values()) await pending.then((listener) => listener.close(), () => void 0);
-    this.listeners.clear();
-    await this.daemon?.close();
-    this.daemon = void 0;
+  close() {
+    if (this.closing) return this.closing;
+    this.closed = true;
+    this.closing = this.started ? this.hub.remove(this) : Promise.resolve();
+    return this.closing;
   }
   async refresh() {
-    if (!this.daemon) return this.ensureDaemon();
-    await this.resubscribe();
+    if (!this.closed) await this.hub.refresh();
   }
-  async ensureDaemon() {
-    if (this.daemon) return;
-    if (Date.now() - this.lastAttemptAt < 15e3) return;
-    this.lastAttemptAt = Date.now();
-    try {
-      this.daemon = await connectDaemon();
-      void this.resubscribe();
-    } catch (error) {
-      this.lastError = error instanceof Error ? error.message : String(error);
-      console.error(`[sourcefed] daemon unavailable: ${this.lastError}`);
-    }
-  }
-  /**
-   * Monitors outlive this process, so after a restart nothing listens for their
-   * sessions until something subscribes. Subscribe every session that has an
-   * enabled monitor and still exists here; a deleted session is skipped, since
-   * delivering to it would fail and retry forever.
-   */
-  async resubscribe() {
-    try {
-      const { targets } = await this.daemon.request("monitor.targets", { kind: TARGET_KIND });
-      await Promise.all(targets.map((target) => this.resubscribeTarget(target.id)));
-    } catch (error) {
-      console.error(`[sourcefed] resubscribe failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  async resubscribeTarget(sessionID) {
-    if (this.listeners.has(sessionID)) return;
-    const exists = await this.session.get({ sessionID }).then(() => true, () => false);
-    if (!exists) return;
-    await this.ensureTarget(sessionID).catch((error) => {
-      console.error(`[sourcefed] subscribe ${sessionID} failed: ${error instanceof Error ? error.message : String(error)}`);
-    });
+  getSession(sessionID, signal) {
+    return this.session.get({ sessionID }, { signal: AbortSignal.any([signal, AbortSignal.timeout(3e3)]) });
   }
   // Every event arrives as a synthetic message, never as a user prompt, so it is
   // not mistaken for the user's own words. Actionable events resume an idle
@@ -182,7 +322,7 @@ var OpenCodeBridge = class {
         },
         { signal: AbortSignal.timeout(GATE_TIMEOUT_MS) }
       );
-      return reply.deliver !== false;
+      return !(reply && typeof reply === "object" && "deliver" in reply && reply.deliver === false);
     } catch {
       return true;
     }
@@ -207,22 +347,15 @@ function cliEntry() {
   if (existsSync(bundled)) return bundled;
   return fileURLToPath(import.meta.resolve("@sourcefed/cli"));
 }
-function setOpenCodeBridge(bridge) {
-  activeBridge = bridge;
-}
-function getOpenCodeBridge() {
-  if (!activeBridge) throw new Error("Sourcefed OpenCode bridge is not initialized");
-  return activeBridge;
-}
 
 // adapters/opencode/tool-result.ts
-async function callMonitorTool(name, arguments_, sessionID) {
-  const result = await getOpenCodeBridge().callTool(name, arguments_, sessionID);
+async function callMonitorTool(bridge, name, arguments_, sessionID) {
+  const result = await bridge.callTool(name, arguments_, sessionID);
   return JSON.stringify(result);
 }
 
 // adapters/opencode/tools/monitor_create.ts
-var definition = {
+var monitor_create_default = (bridge) => ({
   name: "monitor_create",
   description: "Create a detect-only monitor that watches a Jira issue, GitHub PR, Slack thread, or Slack DM and routes NEW events into the current session. Slack monitors only read and notify; they never reply. GitHub and Slack use webhooks when configured and polling otherwise; Jira uses polling.",
   input: {
@@ -242,13 +375,12 @@ var definition = {
     additionalProperties: false
   },
   async execute(input, context) {
-    return { content: await callMonitorTool("monitor_create", input ?? {}, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_create", input ?? {}, context.sessionID) };
   }
-};
-var monitor_create_default = definition;
+});
 
 // adapters/opencode/tools/monitor_list.ts
-var definition2 = {
+var monitor_list_default = (bridge) => ({
   name: "monitor_list",
   description: "List monitors created by the current session (id, name, source, delivery, enabled).",
   input: {
@@ -257,13 +389,12 @@ var definition2 = {
     additionalProperties: false
   },
   async execute(_input, context) {
-    return { content: await callMonitorTool("monitor_list", {}, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_list", {}, context.sessionID) };
   }
-};
-var monitor_list_default = definition2;
+});
 
 // adapters/opencode/tools/monitor_status.ts
-var definition3 = {
+var monitor_status_default = (bridge) => ({
   name: "monitor_status",
   description: "Get the status of a monitor created by the current session.",
   input: {
@@ -276,13 +407,12 @@ var definition3 = {
   },
   async execute(input, context) {
     const args = input ?? {};
-    return { content: await callMonitorTool("monitor_status", { id: args.id }, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_status", { id: args.id }, context.sessionID) };
   }
-};
-var monitor_status_default = definition3;
+});
 
 // adapters/opencode/tools/monitor_start.ts
-var definition4 = {
+var monitor_start_default = (bridge) => ({
   name: "monitor_start",
   description: "Start (re-enable) a stopped monitor created by the current session.",
   input: {
@@ -295,13 +425,12 @@ var definition4 = {
   },
   async execute(input, context) {
     const args = input ?? {};
-    return { content: await callMonitorTool("monitor_start", { id: args.id }, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_start", { id: args.id }, context.sessionID) };
   }
-};
-var monitor_start_default = definition4;
+});
 
 // adapters/opencode/tools/monitor_stop.ts
-var definition5 = {
+var monitor_stop_default = (bridge) => ({
   name: "monitor_stop",
   description: "Stop a monitor created by the current session.",
   input: {
@@ -314,23 +443,26 @@ var definition5 = {
   },
   async execute(input, context) {
     const args = input ?? {};
-    return { content: await callMonitorTool("monitor_stop", { id: args.id }, context.sessionID) };
+    return { content: await callMonitorTool(bridge, "monitor_stop", { id: args.id }, context.sessionID) };
   }
-};
-var monitor_stop_default = definition5;
+});
 
 // adapters/opencode/index.ts
 async function setupSourcefed(ctx) {
-  const bridge = new OpenCodeBridge(ctx.session, ctx.rpc);
-  setOpenCodeBridge(bridge);
-  await bridge.start();
-  await ctx.tool.transform((editor) => {
-    editor.add(monitor_create_default);
-    editor.add(monitor_list_default);
-    editor.add(monitor_status_default);
-    editor.add(monitor_start_default);
-    editor.add(monitor_stop_default);
-  });
+  const bridge = new OpenCodeBridge(ctx.session, ctx.rpc, ctx.location);
+  try {
+    await bridge.start();
+    await ctx.tool.transform((editor) => {
+      editor.add(monitor_create_default(bridge));
+      editor.add(monitor_list_default(bridge));
+      editor.add(monitor_status_default(bridge));
+      editor.add(monitor_start_default(bridge));
+      editor.add(monitor_stop_default(bridge));
+    });
+  } catch (error) {
+    await bridge.close();
+    throw error;
+  }
   return () => bridge.close();
 }
 var opencode_default = Plugin.define({
@@ -345,11 +477,16 @@ var server_default = Plugin2.define({
   id: "sourcefed",
   async setup(ctx) {
     const cleanup = await setupSourcefed(ctx);
-    await ctx.session.hook("context", (event) => {
-      if (!event.system.some((part) => part.type === "text" && part.text.includes(heading))) {
-        event.system.push({ type: "text", text: guidance });
-      }
-    });
+    try {
+      await ctx.session.hook("context", (event) => {
+        if (!event.system.some((part) => part.type === "text" && part.text.includes(heading))) {
+          event.system.push({ type: "text", text: guidance });
+        }
+      });
+    } catch (error) {
+      await cleanup?.();
+      throw error;
+    }
     return cleanup;
   }
 });

package/dist/pi.js

@@ -6,7 +6,7 @@ import {
   daemonCommand,
   daemonEnvironment,
   spawnLocalDaemon
-} from "./chunk-X3BZSHKZ.js";
+} from "./chunk-E6J3BAXP.js";
 import "./chunk-MLKGABMK.js";
 
 // adapters/pi/src/index.ts

package/dist/tui-compiled.mjs

@@ -59,38 +59,43 @@ function Sidebar(props) {
   void refresh();
   const timer = setInterval(() => void refresh(), REFRESH_MS);
   onCleanup(() => clearInterval(timer));
-  return (() => {
-    var _el$ = _$createElement("box"), _el$2 = _$createElement("box"), _el$3 = _$createElement("text"), _el$5 = _$createElement("text"), _el$6 = _$createTextNode(` (`), _el$7 = _$createTextNode(`)`);
-    _$insertNode(_el$, _el$2);
-    _$setProp(_el$, "flexDirection", "column");
-    _$setProp(_el$, "width", "100%");
-    _$setProp(_el$, "marginTop", 1);
-    _$insertNode(_el$2, _el$3);
-    _$insertNode(_el$2, _el$5);
-    _$setProp(_el$2, "flexDirection", "row");
-    _$setProp(_el$2, "width", "100%");
-    _$insertNode(_el$3, _$createTextNode(`Sourcefed`));
-    _$insertNode(_el$5, _el$6);
-    _$insertNode(_el$5, _el$7);
-    _$insert(_el$5, () => active().length, _el$7);
-    _$insert(_el$, _$createComponent(MonitorRows, {
-      monitors: active,
-      get tone() {
-        return palette();
-      },
-      compact: true
-    }), null);
-    _$effect((_p$) => {
-      var _v$ = palette().accent, _v$2 = palette().textMuted;
-      _v$ !== _p$.e && (_p$.e = _$setProp(_el$3, "fg", _v$, _p$.e));
-      _v$2 !== _p$.t && (_p$.t = _$setProp(_el$5, "fg", _v$2, _p$.t));
-      return _p$;
-    }, {
-      e: void 0,
-      t: void 0
-    });
-    return _el$;
-  })();
+  return _$createComponent(Show, {
+    get when() {
+      return active().length > 0;
+    },
+    get children() {
+      var _el$ = _$createElement("box"), _el$2 = _$createElement("box"), _el$3 = _$createElement("text"), _el$5 = _$createElement("text"), _el$6 = _$createTextNode(` (`), _el$7 = _$createTextNode(`)`);
+      _$insertNode(_el$, _el$2);
+      _$setProp(_el$, "flexDirection", "column");
+      _$setProp(_el$, "width", "100%");
+      _$setProp(_el$, "marginTop", 1);
+      _$insertNode(_el$2, _el$3);
+      _$insertNode(_el$2, _el$5);
+      _$setProp(_el$2, "flexDirection", "row");
+      _$setProp(_el$2, "width", "100%");
+      _$insertNode(_el$3, _$createTextNode(`Sourcefed`));
+      _$insertNode(_el$5, _el$6);
+      _$insertNode(_el$5, _el$7);
+      _$insert(_el$5, () => active().length, _el$7);
+      _$insert(_el$, _$createComponent(MonitorRows, {
+        monitors: active,
+        get tone() {
+          return palette();
+        },
+        compact: true
+      }), null);
+      _$effect((_p$) => {
+        var _v$ = palette().accent, _v$2 = palette().textMuted;
+        _v$ !== _p$.e && (_p$.e = _$setProp(_el$3, "fg", _v$, _p$.e));
+        _v$2 !== _p$.t && (_p$.t = _$setProp(_el$5, "fg", _v$2, _p$.t));
+        return _p$;
+      }, {
+        e: void 0,
+        t: void 0
+      });
+      return _el$;
+    }
+  });
 }
 function MonitorRows(props) {
   const visible = createMemo(() => props.monitors().slice(0, 4));
@@ -98,41 +103,26 @@ function MonitorRows(props) {
     var _el$8 = _$createElement("box");
     _$setProp(_el$8, "flexDirection", "column");
     _$setProp(_el$8, "width", "100%");
-    _$insert(_el$8, _$createComponent(Show, {
-      get when() {
-        return visible().length > 0;
-      },
-      get fallback() {
-        return (() => {
-          var _el$1 = _$createElement("text");
-          _$insertNode(_el$1, _$createTextNode(`No active monitors`));
-          _$effect((_$p) => _$setProp(_el$1, "fg", props.tone.textMuted, _$p));
-          return _el$1;
-        })();
-      },
-      get children() {
-        return visible().map((monitor) => (() => {
-          var _el$11 = _$createElement("box"), _el$12 = _$createElement("text"), _el$13 = _$createElement("text"), _el$14 = _$createTextNode(` `);
-          _$insertNode(_el$11, _el$12);
-          _$insertNode(_el$11, _el$13);
-          _$setProp(_el$11, "flexDirection", "row");
-          _$setProp(_el$11, "width", "100%");
-          _$insert(_el$12, () => monitor.icon);
-          _$insertNode(_el$13, _el$14);
-          _$insert(_el$13, () => monitor.name, null);
-          _$effect((_p$) => {
-            var _v$3 = monitorTone(monitor, props.tone), _v$4 = props.tone.textMuted;
-            _v$3 !== _p$.e && (_p$.e = _$setProp(_el$12, "fg", _v$3, _p$.e));
-            _v$4 !== _p$.t && (_p$.t = _$setProp(_el$13, "fg", _v$4, _p$.t));
-            return _p$;
-          }, {
-            e: void 0,
-            t: void 0
-          });
-          return _el$11;
-        })());
-      }
-    }), null);
+    _$insert(_el$8, () => visible().map((monitor) => (() => {
+      var _el$1 = _$createElement("box"), _el$10 = _$createElement("text"), _el$11 = _$createElement("text"), _el$12 = _$createTextNode(` `);
+      _$insertNode(_el$1, _el$10);
+      _$insertNode(_el$1, _el$11);
+      _$setProp(_el$1, "flexDirection", "row");
+      _$setProp(_el$1, "width", "100%");
+      _$insert(_el$10, () => monitor.icon);
+      _$insertNode(_el$11, _el$12);
+      _$insert(_el$11, () => monitor.name, null);
+      _$effect((_p$) => {
+        var _v$3 = monitorTone(monitor, props.tone), _v$4 = props.tone.textMuted;
+        _v$3 !== _p$.e && (_p$.e = _$setProp(_el$10, "fg", _v$3, _p$.e));
+        _v$4 !== _p$.t && (_p$.t = _$setProp(_el$11, "fg", _v$4, _p$.t));
+        return _p$;
+      }, {
+        e: void 0,
+        t: void 0
+      });
+      return _el$1;
+    })()), null);
     _$insert(_el$8, _$createComponent(Show, {
       get when() {
         return _$memo(() => !!props.compact)() && visible().length < props.monitors().length;