tmux-ide 2.9.0-beta.21 → 2.9.0-beta.26

package/packages/daemon/src/tui/mirror/runtime/application-home-catalog.ts

@@ -1,6 +1,14 @@
+import WebSocket from "ws";
+import {
+  createWorkspaceEventSupervisor,
+  type WorkspaceEventSocket,
+} from "@tmux-ide/daemon-client/workspace-event-supervisor";
 import { readApplicationDaemonInfo as readCanonicalDaemonInfo } from "./application-daemon-authority.ts";
 import {
-  WorkspaceCatalogResourceV3SchemaZ,
+  TmuxServersResourceSchemaZ,
+  TmuxServerSessionsResourceSchemaZ,
+  type TmuxServerScope,
+  type TmuxServerDescriptor,
   type CanonicalDaemonInfo,
   type WorkspaceCatalogResourceV3,
 } from "@tmux-ide/contracts";
@@ -9,18 +17,16 @@ import {
   type PushResourceSessionAdapter,
   type PushResourceSessionOptions,
 } from "@tmux-ide/daemon-client/push-resource-session";
-import {
-  createWorkspaceEventSupervisor,
-  type WorkspaceEventSocket,
-} from "@tmux-ide/daemon-client/workspace-event-supervisor";
-import WebSocket from "ws";
 
 import { canonicalDaemonUrl } from "../../../lib/canonical-daemon.ts";
 
 export type ApplicationHomeCatalogResourceKey = "live-catalog";
 export type ApplicationHomeCatalogResource = {
   readonly kind: "live-catalog";
-  readonly value: WorkspaceCatalogResourceV3;
+  readonly value?: WorkspaceCatalogResourceV3;
+  readonly daemonInstanceId?: string;
+  readonly servers?: readonly TmuxServerDescriptor[];
+  readonly scopedSessions?: readonly ApplicationHomeCatalogSession[];
 };
 export interface ApplicationHomeCatalogTarget {
   readonly daemon: CanonicalDaemonInfo;
@@ -35,6 +41,8 @@ export interface ApplicationHomeCatalogFailure {
 
 export interface ApplicationHomeCatalogSession {
   readonly id: string;
+  readonly server?: TmuxServerScope;
+  readonly serverLabel?: string;
   readonly liveSessionId?: string;
   readonly workspaceName?: string;
   readonly name: string;
@@ -45,6 +53,7 @@ export interface ApplicationHomeCatalogSnapshot {
   readonly phase: "loading" | "live" | "unavailable";
   readonly daemonInstanceId: string | null;
   readonly sessions: readonly ApplicationHomeCatalogSession[];
+  readonly servers?: readonly TmuxServerDescriptor[];
   readonly note: string | null;
 }
 
@@ -117,7 +126,7 @@ export function closeApplicationHomeCatalogTransport(
   supervisor.dispose();
 }
 
-function createApplicationHomeCatalogAdapter(onTransportRetired: () => void): HomeCatalogAdapter {
+function createApplicationHomeCatalogAdapter(_onTransportRetired: () => void): HomeCatalogAdapter {
   return {
     validateTarget(value) {
       if (
@@ -139,15 +148,9 @@ function createApplicationHomeCatalogAdapter(onTransportRetired: () => void): Ho
       };
     },
     async fetch(target, _key, signal) {
-      const url = canonicalDaemonUrl(
-        "http",
-        target.daemon.bindHostname,
-        target.daemon.port,
-        "/api/resources/workspace-catalog?version=3",
-      );
-      let response: Response;
-      try {
-        response = await fetch(url, {
+      const base = canonicalDaemonUrl("http", target.daemon.bindHostname, target.daemon.port);
+      const read = async (path: string) => {
+        const response = await fetch(base + path, {
           headers: {
             accept: "application/json",
             ...(target.daemon.authToken
@@ -157,88 +160,139 @@ function createApplicationHomeCatalogAdapter(onTransportRetired: () => void): Ho
           credentials: "omit",
           cache: "no-store",
           redirect: "error",
-          signal,
+          signal: AbortSignal.any([signal, AbortSignal.timeout(3_000)]),
         });
-      } catch {
-        return {
-          status: "failed",
-          failure: catalogFailure("network", "Live session discovery failed.", true),
-        };
-      }
-      if (!response.ok)
+        if (!response.ok) throw new Error(`Discovery returned HTTP ${response.status}`);
+        return response.json();
+      };
+      try {
+        const inventory = TmuxServersResourceSchemaZ.parse(await read("/api/v1/tmux-servers"));
+        const sessions = await Promise.allSettled(
+          inventory.servers.map(async (descriptor) => {
+            if (descriptor.state !== "online") return [];
+            const server = { serverId: descriptor.serverId, generation: descriptor.generation };
+            const result = TmuxServerSessionsResourceSchemaZ.parse(
+              await read(`/api/v1/tmux-servers/${server.serverId}/${server.generation}/sessions`),
+            );
+            if (
+              result.server.serverId !== server.serverId ||
+              result.server.generation !== server.generation
+            )
+              throw new Error("Server discovery identity changed");
+            return result.sessions.map((session) => ({
+              id: JSON.stringify([server.serverId, server.generation, session.liveSessionId]),
+              server,
+              serverLabel: descriptor.label,
+              liveSessionId: session.liveSessionId,
+              name: session.sessionName,
+              ...(session.workspaceName ? { workspaceName: session.workspaceName } : {}),
+              paneCount: session.paneCount,
+            }));
+          }),
+        );
         return {
-          status: "failed",
-          failure: catalogFailure(
-            "http",
-            `Live session discovery returned HTTP ${response.status}.`,
-            response.status >= 500,
-          ),
+          status: "ok",
+          resource: {
+            kind: "live-catalog",
+            daemonInstanceId: target.daemon.instanceId,
+            servers: inventory.servers.map((server, index) =>
+              sessions[index]?.status === "rejected"
+                ? {
+                    serverId: server.serverId,
+                    label: server.label,
+                    state: "offline" as const,
+                    generation: null,
+                  }
+                : server,
+            ),
+            scopedSessions: sessions.flatMap((result) =>
+              result.status === "fulfilled" ? result.value : [],
+            ),
+          },
         };
-      let body: unknown;
-      try {
-        body = await response.json();
       } catch {
         return {
           status: "failed",
-          failure: catalogFailure("schema", "Live session discovery returned invalid JSON.", false),
+          failure: catalogFailure("network", "Server session discovery failed.", true),
         };
       }
-      const parsed = WorkspaceCatalogResourceV3SchemaZ.safeParse(body);
-      if (!parsed.success || !sameDaemon(target.daemon, parsed.data.daemon))
-        return {
-          status: "failed",
-          failure: catalogFailure(
-            "schema",
-            "Live session discovery failed daemon identity validation.",
-            false,
-          ),
-        };
-      return { status: "ok", resource: { kind: "live-catalog", value: parsed.data } };
     },
     async connect(target, _interests, handlers, signal) {
-      const socketUrl = canonicalDaemonUrl(
-        "ws",
-        target.daemon.bindHostname,
-        target.daemon.port,
-        "/ws/events?mode=semantic",
-      );
-      const socket = new WebSocket(socketUrl, {
-        headers: target.daemon.authToken
-          ? { Authorization: `Bearer ${target.daemon.authToken}` }
-          : undefined,
-      }) as unknown as WorkspaceEventSocket;
-      const supervisor = createWorkspaceEventSupervisor({
-        socket,
-        daemon: target.daemon,
-        workspaceName: target.workspaceName,
-        sessionName: target.workspaceName,
-        fetchTerminalRuntimeInventory: () =>
-          Promise.reject(new Error("Home catalog owns no terminal inventory.")),
-        onRetired: onTransportRetired,
-      });
-      const subscription = supervisor.connectWorkspaceCatalog(
-        () => handlers.invalidate(["live-catalog"]),
-        { terminalFirst: false },
-      );
+      // Root push is an advisory invalidation only: every refresh still resolves
+      // the full scoped inventory. The timer discovers changes on other owners.
       let closed = false;
-      const close = (): void => {
-        if (closed) return;
+      let pending = false;
+      let closePush: (() => void) | null = null;
+      const invalidate = () => {
+        if (!closed) handlers.invalidate(["live-catalog"]);
+      };
+      const startPush = async () => {
+        if (closed || pending || closePush) return;
+        pending = true;
+        const socket = new WebSocket(
+          canonicalDaemonUrl(
+            "ws",
+            target.daemon.bindHostname,
+            target.daemon.port,
+            "/ws/events?mode=semantic",
+          ),
+          {
+            headers: target.daemon.authToken
+              ? { Authorization: `Bearer ${target.daemon.authToken}` }
+              : undefined,
+          },
+        ) as unknown as WorkspaceEventSocket;
+        const supervisor = createWorkspaceEventSupervisor({
+          socket,
+          daemon: target.daemon,
+          workspaceName: target.workspaceName,
+          sessionName: target.workspaceName,
+          fetchTerminalRuntimeInventory: () =>
+            Promise.reject(new Error("Home catalog owns no terminal inventory.")),
+          onRetired: () => {
+            const cleanup = closePush;
+            closePush = null;
+            cleanup?.();
+          },
+        });
+        const subscription = supervisor.connectWorkspaceCatalog(invalidate, {
+          terminalFirst: false,
+        });
+        const cleanup = () => closeApplicationHomeCatalogTransport(subscription, supervisor);
+        closePush = cleanup;
+        try {
+          await subscription.ready;
+        } catch {
+          if (closePush === cleanup) closePush = null;
+          cleanup();
+        } finally {
+          pending = false;
+          if (closed) {
+            cleanup();
+            closePush = null;
+          }
+        }
+      };
+      const timer = setInterval(() => {
+        invalidate();
+        void startPush().catch(() => {
+          pending = false;
+        });
+      }, 5_000);
+      const close = () => {
         closed = true;
+        clearInterval(timer);
         signal.removeEventListener("abort", close);
-        // Release the logical observer before retiring its physical transport.
-        closeApplicationHomeCatalogTransport(subscription, supervisor);
+        const cleanup = closePush;
+        closePush = null;
+        cleanup?.();
       };
       signal.addEventListener("abort", close, { once: true });
-      try {
-        await subscription.ready;
-      } catch (error) {
-        close();
-        throw error;
-      }
-      if (signal.aborted) {
-        close();
-        throw signal.reason;
-      }
+      if (signal.aborted) close();
+      else
+        void startPush().catch(() => {
+          pending = false;
+        });
       return { status: "connected", close };
     },
     rejectionFailure: () =>
@@ -264,31 +318,37 @@ const initialSnapshot = (): ApplicationHomeCatalogSnapshot => ({
   note: "Discovering live tmux sessions…",
 });
 
-function projectCatalog(resource: WorkspaceCatalogResourceV3): ApplicationHomeCatalogSnapshot {
+function projectCatalog(
+  resource: WorkspaceCatalogResourceV3,
+  scopedSessions?: readonly ApplicationHomeCatalogSession[],
+): ApplicationHomeCatalogSnapshot {
   return {
     phase: "live",
     daemonInstanceId: resource.daemon.instanceId,
-    sessions: resource.liveSessions
-      .map(({ liveSessionId, sessionName, paneCount }) => ({
-        id: `${resource.daemon.instanceId}:${liveSessionId}`,
-        liveSessionId,
-        workspaceName: resource.intents.find((intent) => intent.sessionName === sessionName)
-          ?.workspaceName,
-        name: sessionName,
-        paneCount,
-      }))
-      .sort((left, right) => left.name.localeCompare(right.name)),
+    sessions:
+      scopedSessions ??
+      resource.liveSessions
+        .map(({ liveSessionId, sessionName, paneCount }) => ({
+          id: `${resource.daemon.instanceId}:${liveSessionId}`,
+          liveSessionId,
+          workspaceName: resource.intents.find((intent) => intent.sessionName === sessionName)
+            ?.workspaceName,
+          name: sessionName,
+          paneCount,
+        }))
+        .sort((left, right) => left.name.localeCompare(right.name)),
     note:
-      resource.liveSessions.length === 0
+      (scopedSessions?.length ?? resource.liveSessions.length) === 0
         ? "No live tmux sessions yet. This list updates automatically."
         : null,
   };
 }
 
 /**
- * Daemon-authoritative Home catalog. Reads are push-invalidated while the
- * daemon generation is healthy; the only timer is a bounded failure-recovery
- * probe used when no canonical daemon or event transport is available.
+ * Daemon-authoritative fleet metadata. Root push preserves immediate updates,
+ * while a five-second refresh discovers independent
+ * server owners without opening pane streams. Failed reads use bounded backoff;
+ * each failed server is excluded without suppressing healthy siblings.
  */
 export function createApplicationHomeCatalog(
   overrides: Partial<ApplicationHomeCatalogDependencies> = {},
@@ -373,7 +433,19 @@ export function createApplicationHomeCatalog(
     if (slot?.status === "loaded" && !slot.refreshing && slot.resource.kind === "live-catalog") {
       clearRetry();
       retryAttempt = 0;
-      publish(projectCatalog(slot.resource.value));
+      publish(
+        slot.resource.value
+          ? projectCatalog(slot.resource.value)
+          : {
+              phase: "live",
+              daemonInstanceId: slot.resource.daemonInstanceId ?? null,
+              sessions: slot.resource.scopedSessions ?? [],
+              servers: slot.resource.servers,
+              note: slot.resource.scopedSessions?.length
+                ? null
+                : "No live tmux sessions yet. This list updates automatically.",
+            },
+      );
       return;
     }
     if (slot?.status === "error") {

package/packages/daemon/src/tui/mirror/runtime/application-home-experience.ts

@@ -0,0 +1,59 @@
+import type { Accessor } from "solid-js";
+import { createApplicationHomeFleetOwner } from "./application-home-fleet.ts";
+import { createApplicationHomeNavigationOwner } from "./application-home-agents-owner.ts";
+import { createApplicationGuidedTourIntegration } from "./application-guided-tour-integration.tsx";
+
+type NavigationOptions = Parameters<typeof createApplicationHomeNavigationOwner>[0];
+type TourOptions = Parameters<typeof createApplicationGuidedTourIntegration>[0];
+/** Compose Home's fleet, navigation and learning experience without additional transports. */
+export function createApplicationHomeExperience(
+  options: Omit<NavigationOptions, "fleetHome" | "fleetCommands" | "openFleet"> &
+    Pick<
+      TourOptions,
+      | "machines"
+      | "lifecycle"
+      | "generation"
+      | "generationMachineId"
+      | "layoutSnapshot"
+      | "appearance"
+      | "dimensions"
+    > & { paletteModalOpen: Accessor<boolean> },
+) {
+  const { machines, appearance } = options;
+  const paletteOpen = () =>
+    options.shell().semantic?.focus.palette.open ?? options.shell().localPaletteOpen;
+  const fleetHome = createApplicationHomeFleetOwner({
+    catalog: machines.catalog,
+    agents: machines.agents,
+    inputActive: () =>
+      options.activeSurface() === "home" &&
+      options.rendererFocused() &&
+      !options.paletteModalOpen() &&
+      !machines.switching() &&
+      !machines.adding() &&
+      !machines.focused() &&
+      !paletteOpen() &&
+      !appearance.pickerOpen(),
+    open: (_machineId, agent, source) => machines.openHomeAgent(agent, source),
+  });
+  const navigation = createApplicationHomeNavigationOwner({
+    ...options,
+    fleetHome: fleetHome.presentation,
+    fleetCommands: machines.paletteCommands,
+    openFleet: machines.openPalette,
+  });
+  const tour = createApplicationGuidedTourIntegration({
+    ...options,
+    sessionName: () => options.sessionOwner()?.sessionName() ?? null,
+    paletteOpen,
+    paletteCommands: navigation.paletteCommands,
+    blocked: () =>
+      options.paletteModalOpen() ||
+      !!navigation.paneRename.draft() ||
+      paletteOpen() ||
+      appearance.pickerOpen() ||
+      machines.switching() ||
+      machines.adding(),
+  });
+  return { ...navigation, tour };
+}

package/packages/daemon/src/tui/mirror/runtime/application-home-fleet.ts

@@ -0,0 +1,175 @@
+import { createEffect, createMemo, createSignal, onCleanup } from "solid-js";
+import type {
+  ApplicationMachineAgent,
+  ApplicationMachineAgentGroup,
+} from "./application-machine-agents.ts";
+import type { ApplicationMachineCatalogSnapshot } from "./application-machine-catalog.ts";
+import type { HomeAgentRow, HomeAgentSnapshot } from "./application-home-agents.ts";
+import { createHomeAgentSelectionOwner } from "./application-home-agent-selection.ts";
+import type { ApplicationHomeAgentPresentation } from "./application-home-agents-owner.ts";
+
+export interface HomeFleetFilter {
+  readonly machineId: string | null;
+  readonly attentionOnly: boolean;
+}
+export function projectHomeFleet(
+  catalog: ApplicationMachineCatalogSnapshot,
+  groups: readonly ApplicationMachineAgentGroup[],
+  filter: HomeFleetFilter,
+): HomeAgentSnapshot {
+  const machines = catalog.groups.filter(
+    (group) => filter.machineId === null || group.id === filter.machineId,
+  );
+  const rows: HomeAgentRow[] = [];
+  const unavailable = new Set<string>();
+  let observedSessions = 0,
+    totalSessions = 0,
+    loadingSessions = 0,
+    unavailableSessions = 0,
+    truncatedSessions = 0;
+  const panes = new Set<string>();
+  for (const machine of machines) {
+    const group = groups.find((group) => group.machineId === machine.id);
+    totalSessions += machine.sessions.length;
+    const observation = machine.state === "ready" ? group?.observation : undefined;
+    observedSessions +=
+      observation?.observedSessions ?? (group?.available ? machine.sessions.length : 0);
+    loadingSessions +=
+      observation?.loadingSessions ??
+      (machine.state === "connecting" ? machine.sessions.length : 0);
+    unavailableSessions +=
+      observation?.unavailableSessions ??
+      (machine.state === "disconnected" ? machine.sessions.length : 0);
+    truncatedSessions += observation?.truncatedSessions ?? 0;
+    for (const key of observation?.unavailableSessionKeys ?? [])
+      unavailable.add(JSON.stringify([machine.id, key]));
+    for (const agent of [...(group?.agents ?? [])].sort(
+      (a, b) => Number(a.disabled) - Number(b.disabled) || a.id.localeCompare(b.id),
+    )) {
+      const sessionKey = JSON.stringify([machine.id, agent.sessionKey]);
+      if (agent.disabled) unavailable.add(sessionKey);
+      if (
+        filter.attentionOnly &&
+        !(agent.attention || agent.activity === "waiting" || agent.activity === "failed")
+      )
+        continue;
+      const paneKey = agent.paneId
+        ? JSON.stringify([machine.id, agent.server?.serverId, agent.daemonInstanceId, agent.paneId])
+        : agent.id;
+      if (panes.has(paneKey)) continue;
+      panes.add(paneKey);
+      rows.push({ ...agent, key: agent.id, sessionKey, machineLabel: machine.label });
+    }
+  }
+  // Identity order never jumps when an activity signal changes.
+  rows.sort((a, b) => a.key.localeCompare(b.key));
+  const missing = machines.filter(
+    (machine) =>
+      machine.state !== "ready" ||
+      !groups.find((group) => group.machineId === machine.id)?.available,
+  );
+  return {
+    phase: missing.length
+      ? rows.length || observedSessions
+        ? "partial"
+        : machines.some((machine) => machine.state === "connecting")
+          ? "loading"
+          : "unavailable"
+      : "live",
+    rows,
+    observedSessions,
+    totalSessions,
+    loadingSessions,
+    unavailableSessions,
+    truncatedSessions,
+    refreshingSessionKeys: [],
+    unavailableSessionKeys: [...unavailable],
+    note: missing.length
+      ? `${missing.map((machine) => `${machine.label}: ${machine.state === "ready" ? "partial observations" : machine.state}`).join(" · ")} · unavailable rows show last observed activity`
+      : rows.length === 0 && filter.attentionOnly
+        ? "No agents need attention in this view."
+        : null,
+  };
+}
+
+/** Reuses resident fleet observations, adding no daemon connections or pane streams. */
+export function createApplicationHomeFleetOwner(options: {
+  readonly catalog: {
+    getSnapshot(): ApplicationMachineCatalogSnapshot;
+    subscribe(listener: (value: ApplicationMachineCatalogSnapshot) => void): () => void;
+  };
+  readonly agents: {
+    retry?(): void;
+    loadMore?(): void;
+    getSnapshot(): readonly ApplicationMachineAgentGroup[];
+    subscribe(listener: (value: readonly ApplicationMachineAgentGroup[]) => void): () => void;
+  };
+  readonly inputActive: () => boolean;
+  readonly open: (
+    machineId: string,
+    agent: ApplicationMachineAgent,
+    source: "keyboard" | "mouse",
+  ) => Promise<unknown> | void;
+}) {
+  const [catalog, setCatalog] = createSignal(options.catalog.getSnapshot());
+  const [groups, setGroups] = createSignal(options.agents.getSnapshot());
+  const [filter, setFilter] = createSignal<HomeFleetFilter>({
+    machineId: null,
+    attentionOnly: false,
+  });
+  const selection = createHomeAgentSelectionOwner();
+  const [selected, setSelected] = createSignal(selection.snapshot());
+  const snapshot = createMemo(() => projectHomeFleet(catalog(), groups(), filter()));
+  const stops = [
+    options.catalog.subscribe(setCatalog),
+    options.agents.subscribe(setGroups),
+    selection.subscribe(setSelected),
+  ];
+  createEffect(() => selection.setRows(snapshot().rows));
+  createEffect(() => {
+    const id = filter().machineId;
+    if (id && !catalog().groups.some((group) => group.id === id))
+      setFilter((value) => ({ ...value, machineId: null }));
+  });
+  onCleanup(() => {
+    for (const stop of stops) stop();
+    selection.dispose();
+  });
+  const presentation: ApplicationHomeAgentPresentation = {
+    get agentRoster() {
+      return snapshot();
+    },
+    get agentSelection() {
+      return selected();
+    },
+    get agentInputActive() {
+      return options.inputActive();
+    },
+    get agentFilterLabel() {
+      return `${catalog().groups.find((group) => group.id === filter().machineId)?.label ?? "All machines"} · ${filter().attentionOnly ? "Needs attention" : "All agents"}`;
+    },
+    onCycleAgentMachine() {
+      const ids = [null, ...catalog().groups.map((group) => group.id)];
+      setFilter((value) => ({
+        ...value,
+        machineId: ids[(ids.indexOf(value.machineId) + 1) % ids.length]!,
+      }));
+    },
+    onToggleAgentAttention() {
+      setFilter((value) => ({ ...value, attentionOnly: !value.attentionOnly }));
+    },
+    onRetryAgents: () => options.agents.retry?.(),
+    onLoadMoreAgents: () => options.agents.loadMore?.(),
+    onSelectAgent: selection.select,
+    onMoveAgent: selection.move,
+    onAgentViewport: selection.setViewport,
+    onOpenAgent(row, source) {
+      if (!options.inputActive()) return;
+      const group = groups().find((group) => group.machineId === row.machineId);
+      const agent = group?.agents.find((agent) => agent.id === row.key);
+      if (agent && !agent.disabled && agent.paneId)
+        void options.open(agent.machineId, agent, source);
+    },
+  };
+  return { presentation };
+}

package/packages/daemon/src/tui/mirror/runtime/application-machine-agents.ts

@@ -10,7 +10,7 @@ import {
   type ApplicationHomeAgentObserver,
 } from "./application-home-agent-observer.ts";
 import { createApplicationHomeAgentTransport } from "./application-home-agent-transport.ts";
-import type { HomeAgentRow } from "./application-home-agents.ts";
+import type { HomeAgentRow, HomeAgentSnapshot } from "./application-home-agents.ts";
 
 export interface ApplicationMachineAgent extends HomeAgentRow {
   readonly id: string;
@@ -19,6 +19,7 @@ export interface ApplicationMachineAgent extends HomeAgentRow {
 }
 export interface ApplicationMachineAgentGroup {
   readonly available?: boolean;
+  readonly observation?: HomeAgentSnapshot;
   readonly machineId: string;
   readonly agents: readonly ApplicationMachineAgent[];
 }
@@ -74,6 +75,7 @@ export function createApplicationMachineAgents(options: {
         const current = !!entry && entry.binding === bindingFor(entry.handle);
         return Object.freeze({
           machineId: group.id,
+          observation: entry?.observer?.getSnapshot(),
           available:
             group.state === "ready" && current && entry?.observer?.getSnapshot().phase === "live",
           agents: Object.freeze(
@@ -185,6 +187,12 @@ export function createApplicationMachineAgents(options: {
         !!entry.observer?.isCurrentTarget(row)
       );
     },
+    retry() {
+      for (const entry of entries.values()) entry.observer?.retry();
+    },
+    loadMore() {
+      for (const entry of entries.values()) entry.observer?.loadMore();
+    },
     start() {
       if (started || disposed) return;
       started = true;