@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/web-ui/app/controllers/history-pagination.js

@@ -0,0 +1,111 @@
+import { mergeHistoryPage } from "../lib/history-page-messages.js";
+
+export function canRestoreSnapshotQueue(snapshot, waitingRequestId) {
+  if (!snapshot) return false;
+  if (!waitingRequestId) return true;
+  return (snapshot.requests || []).some((request) => request.requestId === waitingRequestId);
+}
+
+export function createHistoryPagination({ state, dom, client, selectedEnvironmentId, normalizeMessage, onRequests, renderMessages, conversationView, applyReadState, loadLatest, onNewerPage = () => {} }) {
+  let revision = 0;
+  let pending = false;
+  let older = null;
+  let newer = null;
+  let error = "";
+  let scrollRequested = false;
+  let windowEnd;
+  const requestIds = new Set();
+  function reset() {
+    revision += 1; pending = false; older = null; newer = null; error = ""; requestIds.clear();
+    scrollRequested = false;
+    windowEnd = undefined;
+  }
+  function adopt(snapshot) {
+    scrollRequested = false;
+    older = snapshot.nextCursor || null; newer = snapshot.newerCursor || null;
+    windowEnd = snapshot.messages?.length ? normalizeMessage(snapshot.messages.at(-1)) : undefined;
+    for (const request of snapshot.requests || []) requestIds.add(request.requestId);
+  }
+  function refresh(snapshot) {
+    if (newer) return;
+    const first = snapshot.messages?.[0];
+    if (!first) { adopt(snapshot); return; }
+    const overlaps = state.messages.some((message) => String(message.persistedMessageId ?? message.id) === String(first.id) && message.createdAt === first.createdAt);
+    if (!overlaps) { reset(); adopt(snapshot); }
+  }
+  function isCurrent(environmentId, sessionId, version, viewVersion) {
+    if (version !== revision || viewVersion !== state.sessionViewVersion) return false;
+    if (environmentId !== selectedEnvironmentId()) return false;
+    return sessionId === state.currentSessionId;
+  }
+  async function load(direction = "older") {
+    const cursor = direction === "older" ? older : newer;
+    if (pending || !cursor) return;
+    scrollRequested = false;
+    const environmentId = selectedEnvironmentId();
+    const sessionId = state.currentSessionId;
+    const version = revision;
+    const viewVersion = state.sessionViewVersion;
+    pending = true; error = "";
+    if (conversationView.preserveScroll) conversationView.preserveScroll(renderMessages);
+    else renderMessages();
+    try {
+      const snapshot = await client.loadSession(sessionId, environmentId, { cursor });
+      if (!isCurrent(environmentId, sessionId, version, viewVersion)) return;
+      const incoming = (snapshot.messages || []).map(normalizeMessage);
+      const requests = (snapshot.requests || []).filter((request) => !requestIds.has(request.requestId));
+      for (const request of requests) requestIds.add(request.requestId);
+      const merge = () => {
+        mergeHistoryPage(state, incoming, direction, windowEnd);
+        if (direction === "newer" && incoming.length) windowEnd = incoming.at(-1);
+        if (direction === "older") older = snapshot.nextCursor || null;
+        else newer = snapshot.newerCursor || null;
+        onRequests(requests);
+        applyReadState(sessionId, snapshot.readState);
+        pending = false;
+        renderMessages();
+      };
+      if (conversationView.preserveScroll) conversationView.preserveScroll(merge);
+      else merge();
+      if (direction === "newer" && incoming.length) onNewerPage(incoming);
+    } catch (failure) {
+      if (!isCurrent(environmentId, sessionId, version, viewVersion)) return;
+      error = failure.code === "history_cursor_stale" ? "History changed. Reopen this conversation." : "Could not load history. Retry.";
+      if (failure.code === "history_cursor_stale") { older = null; newer = null; }
+    } finally {
+      if (isCurrent(environmentId, sessionId, version, viewVersion)) { pending = false; renderMessages(); }
+    }
+  }
+  function renderControls(root) {
+    if (!root?.ownerDocument) return;
+    for (const [direction, cursor, label] of [["older", older, "Load older messages"], ["newer", newer, "Load newer messages"]]) {
+      if (!cursor) continue;
+      const button = root.ownerDocument.createElement("button");
+      button.type = "button"; button.className = "history-page-button";
+      button.disabled = pending;
+      button.textContent = pending ? "Loading…" : error || label;
+      button.addEventListener("click", () => void load(direction));
+      if (direction === "older") root.prepend(button);
+      else root.append(button);
+    }
+    if (error && !older && !newer) {
+      const note = root.ownerDocument.createElement("p"); note.textContent = error; root.prepend(note);
+    }
+  }
+  // Rendering and target positioning also emit scroll events; only user input can request another page.
+  for (const name of ["wheel", "touchmove", "pointerdown"]) {
+    dom.messagesList?.addEventListener?.(name, () => { scrollRequested = true; }, { passive: true });
+  }
+  dom.messagesList?.addEventListener?.("keydown", (event) => {
+    if (["ArrowUp", "ArrowDown", "PageUp", "PageDown", "Home", "End", " "].includes(event.key)) scrollRequested = true;
+  });
+  dom.messagesList?.addEventListener?.("scroll", () => {
+    if (error || pending || !scrollRequested) return;
+    const root = dom.messagesList;
+    if (root.scrollTop < 60 && older) { scrollRequested = false; void load("older"); return; }
+    if (root.scrollHeight - root.scrollTop - root.clientHeight < 60 && newer) { scrollRequested = false; void load("newer"); }
+  }, { passive: true });
+  const controller = { reset, adopt, refresh, load, renderControls, latest: loadLatest, hasNewer: () => Boolean(newer) };
+  conversationView.setHistoryPager?.(controller);
+  return controller;
+}

package/dist/src/web-ui/app/controllers/notifications-controller.js

@@ -11,7 +11,7 @@ export function createNotificationsController({
 }) {
   const state = {
     items: [], unreadCount: 0, nextCursor: null, preferences: null,
-    desktop: null, loading: false, busy: false, error: "", filter: "all",
+    desktop: null, loading: false, busy: false, error: "", filter: "unread",
   };
   let ready = false;
   let environmentRevision = 0;

package/dist/src/web-ui/app/controllers/operations-controller.d.ts

@@ -3,8 +3,19 @@ export declare function latestHealthEvent(
   details: readonly Record<string, unknown>[],
 ): Record<string, unknown> | undefined;
 
+export interface OperationsSummary {
+  readonly label: string;
+  readonly items: readonly {
+    readonly label: string;
+    readonly value: string;
+    readonly dirty?: boolean;
+    readonly status?: boolean;
+  }[];
+}
+
 export interface OperationsControllerDependencies {
   readonly getEnvironmentId?: () => string | undefined;
+  readonly onSummaryChange?: () => void;
   readonly dom: Readonly<{
     runtimeStatus: Pick<HTMLElement, "innerHTML" | "textContent">;
     runtimeLogs: Pick<HTMLElement, "textContent">;
@@ -20,6 +31,7 @@ export interface OperationsControllerDependencies {
 export declare function createOperationsController(
   options: OperationsControllerDependencies,
 ): {
+  summary(tab: string): OperationsSummary;
   environmentChanged(): void;
   loadRuntimeStatus(): Promise<void>;
   loadRuntimeLogs(): Promise<void>;

package/dist/src/web-ui/app/controllers/operations-controller.js

@@ -1,5 +1,7 @@
 import { escapeHtml, formatTime, shortId, textOf } from "../lib/text-format.js";
-import { getNumber } from "../lib/event-presentation.js";
+import { formatDurationMs, latestHealthEvent, projectOperationsSummary } from "../components/operations-summary.js";
+
+export { formatDurationMs, latestHealthEvent } from "../components/operations-summary.js";
 
 function renderRuntimeRows(rows) {
   return `
@@ -18,34 +20,27 @@ function renderRuntimeRows(rows) {
   `;
 }
 
-export function formatDurationMs(value) {
-  const ms = typeof value === "number" ? value : Number(value);
-  if (!Number.isFinite(ms) || ms < 0) return "-";
-  const seconds = Math.round(ms / 1000);
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.round(seconds / 60);
-  if (minutes < 90) return `${minutes}m`;
-  const hours = Math.round(minutes / 60);
-  if (hours < 48) return `${hours}h`;
-  return `${Math.round(hours / 24)}d`;
-}
-
-export function latestHealthEvent(details) {
-  return [...details].sort(
-    (left, right) =>
-      getNumber(right.lastEventAt, 0) - getNumber(left.lastEventAt, 0),
-  )[0];
-}
-
-export function createOperationsController({ dom, client, getEnvironmentId = () => undefined }) {
+export function createOperationsController({ dom, client, getEnvironmentId = () => undefined, onSummaryChange = () => {} }) {
   let statusRevision = 0;
   let logsRevision = 0;
+  let healthRevision = 0;
   let displayedEnvironment = getEnvironmentId();
+  const reads = { runtime: { phase: "idle" }, logs: { phase: "idle" }, health: { phase: "idle" } };
+  function updateSummaryRead(tab, read) {
+    reads[tab] = read;
+    onSummaryChange();
+  }
   function isCurrentOperationsRead(environmentId, revision, currentRevision) {
     if (environmentId !== getEnvironmentId()) return false;
     return revision === currentRevision;
   }
+  function isCurrentHealthRead(revision) {
+    return revision === healthRevision;
+  }
   const controller = {
+    summary(tab) {
+      return projectOperationsSummary(tab, reads, getEnvironmentId());
+    },
     environmentChanged() {
       const environmentId = getEnvironmentId();
       if (displayedEnvironment === environmentId) return;
@@ -57,6 +52,7 @@ export function createOperationsController({ dom, client, getEnvironmentId = ()
       const environmentId = getEnvironmentId();
       const revision = ++statusRevision;
       dom.runtimeStatus.textContent = "Loading...";
+      updateSummaryRead("runtime", { phase: "loading", environmentId });
       try {
         const payload = await client.getRuntimeStatus(environmentId);
         if (!isCurrentOperationsRead(environmentId, revision, statusRevision)) return;
@@ -70,11 +66,13 @@ export function createOperationsController({ dom, client, getEnvironmentId = ()
             <div class="runtime-row"><span>Trace</span><strong>${escapeHtml(status.config?.traceFile || "-")}</strong></div>
           </div>
         `;
+        updateSummaryRead("runtime", { phase: "ready", environmentId, payload });
       } catch (error) {
         if (!isCurrentOperationsRead(environmentId, revision, statusRevision)) return;
         dom.runtimeStatus.innerHTML = `<span class="error-text">${escapeHtml(
           error instanceof Error ? error.message : String(error),
         )}</span>`;
+        updateSummaryRead("runtime", { phase: "error", environmentId });
       }
     },
 
@@ -82,6 +80,7 @@ export function createOperationsController({ dom, client, getEnvironmentId = ()
       const environmentId = getEnvironmentId();
       const revision = ++logsRevision;
       dom.runtimeLogs.textContent = "Loading...";
+      updateSummaryRead("logs", { phase: "loading", environmentId });
       try {
         const payload = await client.getRuntimeLogs(100, environmentId);
         if (!isCurrentOperationsRead(environmentId, revision, logsRevision)) return;
@@ -91,17 +90,22 @@ export function createOperationsController({ dom, client, getEnvironmentId = ()
         dom.runtimeLogs.textContent = lines.length
           ? lines.join("\n")
           : "No runtime log lines returned.";
+        updateSummaryRead("logs", { phase: "ready", environmentId, payload, refreshedAt: Date.now() });
       } catch (error) {
         if (!isCurrentOperationsRead(environmentId, revision, logsRevision)) return;
         dom.runtimeLogs.textContent =
           error instanceof Error ? error.message : String(error);
+        updateSummaryRead("logs", { phase: "error", environmentId });
       }
     },
 
     async loadSystemHealth() {
+      const revision = ++healthRevision;
       dom.healthStatus.textContent = "Loading...";
+      updateSummaryRead("health", { phase: "loading" });
       try {
         const payload = await client.getSystemHealth();
+        if (!isCurrentHealthRead(revision)) return;
         const details = Array.isArray(payload.activeStreamingRequestDetails)
           ? payload.activeStreamingRequestDetails
           : [];
@@ -149,10 +153,13 @@ export function createOperationsController({ dom, client, getEnvironmentId = ()
               : '<div class="empty-state compact">No active streaming requests</div>'
           }
         `;
+        updateSummaryRead("health", { phase: "ready", payload });
       } catch (error) {
+        if (!isCurrentHealthRead(revision)) return;
         dom.healthStatus.innerHTML = `<span class="error-text">${escapeHtml(
           error instanceof Error ? error.message : String(error),
         )}</span>`;
+        updateSummaryRead("health", { phase: "error" });
       }
     },
   };

package/dist/src/web-ui/app/controllers/passive-learning-controller.js

@@ -22,8 +22,8 @@ export function createPassiveLearningController({
   client,
   getEnvironmentId,
   render,
-  openSession = () => {},
   isVisible = () => document.visibilityState === "visible",
+  isRuntimeReady = () => true,
   setTimer = setTimeout,
   clearTimer = clearTimeout,
 }) {
@@ -35,8 +35,6 @@ export function createPassiveLearningController({
     candidates: [],
     candidateError: "",
     loadingCandidates: false,
-    proposalError: "",
-    dismissingProposalId: "",
     selectedBatch: null,
     selectedBatchId: "",
     models: [],
@@ -57,10 +55,15 @@ export function createPassiveLearningController({
   let stale = true;
   let modelsStale = true;
   let environmentEpoch = 0;
+  let runtimeReady = isRuntimeReady();
 
   const learningActive = () => workspace === "learning";
   const homeActive = () => workspace === "home";
-  const canRefresh = () => (learningActive() || homeActive()) && isVisible();
+  function canRefresh() {
+    if (!isRuntimeReady()) return false;
+    if (!learningActive() && !homeActive()) return false;
+    return isVisible();
+  }
   const snapshot = () => ({
     ...state,
     environmentId,
@@ -68,8 +71,11 @@ export function createPassiveLearningController({
     homeActive: homeActive(),
   });
   const publish = () => render(snapshot());
-  const currentRead = (readEnvironmentId, readRevision) =>
-    readRevision === revision && readEnvironmentId === getEnvironmentId();
+  function currentRead(readEnvironmentId, readRevision) {
+    if (!isRuntimeReady()) return false;
+    if (readRevision !== revision) return false;
+    return readEnvironmentId === getEnvironmentId();
+  }
 
   async function readCurrentState() {
     stale = false;
@@ -214,6 +220,7 @@ export function createPassiveLearningController({
 
   function resetEnvironment() {
     eventRefresh.cancel();
+    runtimeReady = isRuntimeReady();
     revision += 1;
     detailRevision += 1;
     environmentEpoch += 1;
@@ -226,8 +233,6 @@ export function createPassiveLearningController({
       candidates: [],
       candidateError: "",
       loadingCandidates: false,
-      proposalError: "",
-      dismissingProposalId: "",
       selectedBatch: null,
       selectedBatchId: "",
       models: [],
@@ -248,8 +253,14 @@ export function createPassiveLearningController({
   }
 
   async function selectBatch(id) {
+    if (!isRuntimeReady()) return;
     const readEnvironmentId = getEnvironmentId();
     const readRevision = ++detailRevision;
+    function hasCurrentBatchRead() {
+      if (!isRuntimeReady()) return false;
+      if (readRevision !== detailRevision) return false;
+      return readEnvironmentId === getEnvironmentId();
+    }
     state.selectedBatchId = id;
     state.selectedBatch = null;
     state.detailError = "";
@@ -261,26 +272,15 @@ export function createPassiveLearningController({
         id,
         readEnvironmentId,
       );
-      if (
-        readRevision !== detailRevision ||
-        readEnvironmentId !== getEnvironmentId()
-      )
-        return;
+      if (!hasCurrentBatchRead()) return;
       if (!result?.batch || result.batch.id !== id)
         throw new Error("Batch details are unavailable.");
       state.selectedBatch = result.batch;
     } catch (error) {
-      if (
-        readRevision !== detailRevision ||
-        readEnvironmentId !== getEnvironmentId()
-      )
-        return;
+      if (!hasCurrentBatchRead()) return;
       state.detailError = errorMessage(error);
     } finally {
-      if (
-        readRevision === detailRevision &&
-        readEnvironmentId === getEnvironmentId()
-      ) {
+      if (hasCurrentBatchRead()) {
         state.loadingDetail = false;
         publish();
       }
@@ -288,12 +288,15 @@ export function createPassiveLearningController({
   }
 
   async function mutateLearningState(mutate, failureMessage) {
+    if (!isRuntimeReady()) return;
     if (state.saving) return;
     const mutationEnvironmentId = getEnvironmentId();
     const epoch = environmentEpoch;
-    const mutationCurrent = () =>
-      epoch === environmentEpoch &&
-      mutationEnvironmentId === getEnvironmentId();
+    function mutationCurrent() {
+      if (!isRuntimeReady()) return false;
+      if (epoch !== environmentEpoch) return false;
+      return mutationEnvironmentId === getEnvironmentId();
+    }
     state.saving = true;
     state.statusError = "";
     publish();
@@ -315,6 +318,7 @@ export function createPassiveLearningController({
   }
 
   function canRestartCollection() {
+    if (!isRuntimeReady()) return false;
     if (state.saving || state.loadingStatus) return false;
     if (state.restartingCollection) return false;
     if (environmentId !== getEnvironmentId()) return false;
@@ -340,68 +344,14 @@ export function createPassiveLearningController({
     }
   }
 
-  function findDeliveredProposal(id) {
-    return state.status?.proactive?.proposals?.find(
-      (proposal) =>
-        proposal.id === id &&
-        ["delivered", "dismissed"].includes(proposal.status),
-    );
-  }
-
-  async function openProposal(id) {
-    const proposal = findDeliveredProposal(id);
-    if (!proposal || environmentId !== getEnvironmentId()) return;
-    const epoch = environmentEpoch;
-    state.proposalError = "";
-    try {
-      await openSession(proposal.sessionId, environmentId);
-    } catch (error) {
-      if (epoch !== environmentEpoch) return;
-      state.proposalError = errorMessage(error);
-      publish();
-    }
-  }
-
-  async function dismissProposal(id) {
-    if (state.dismissingProposalId || !findDeliveredProposal(id)) return;
-    const targetEnvironment = getEnvironmentId();
-    if (environmentId !== targetEnvironment) return;
-    const epoch = environmentEpoch;
-    state.dismissingProposalId = id;
-    state.proposalError = "";
-    publish();
-    try {
-      const result = await client.dismissPassiveLearningProposal(
-        id,
-        targetEnvironment,
-      );
-      if (
-        epoch !== environmentEpoch ||
-        targetEnvironment !== getEnvironmentId()
-      )
-        return;
-      if (result?.ok !== true)
-        throw new Error("Suggestion dismissal was not confirmed.");
-      markStale();
-    } catch (error) {
-      if (
-        epoch === environmentEpoch &&
-        targetEnvironment === getEnvironmentId()
-      )
-        state.proposalError = errorMessage(error);
-    } finally {
-      if (
-        epoch === environmentEpoch &&
-        targetEnvironment === getEnvironmentId()
-      ) {
-        state.dismissingProposalId = "";
-        publish();
-      }
-    }
+  function runtimeAvailabilityChanged() {
+    if (isRuntimeReady() === runtimeReady) return;
+    resetEnvironment();
   }
 
   return Object.freeze({
     snapshot,
+    runtimeAvailabilityChanged,
     publish,
     restartCollection,
     configure: (preferences) =>
@@ -415,8 +365,6 @@ export function createPassiveLearningController({
         "Pending activity deletion was not confirmed.",
       ),
     selectBatch,
-    openProposal,
-    dismissProposal,
     refresh: () => {
       stale = true;
       modelsStale = true;

package/dist/src/web-ui/app/controllers/projects-controller.d.ts

@@ -22,6 +22,7 @@ export type ProjectsControllerState = {
 export declare function createProjectsController(options: {
   client: ProjectRequests;
   getEnvironmentId: () => string;
+  isRuntimeReady?: () => boolean;
   getConversationRevision: () => string | number;
   prepareConversation: () => boolean;
   openSession: (sessionId: string) => Promise<unknown>;
@@ -33,6 +34,7 @@ export declare function createProjectsController(options: {
   snapshot(): ProjectsControllerState;
   load(): Promise<void>;
   environmentChanged(): Promise<void>;
+  runtimeAvailabilityChanged(): Promise<void>;
   openCreate(): void;
   closeCreate(): boolean;
   updateDraft(field: string, value: string): void;

package/dist/src/web-ui/app/controllers/projects-controller.js

@@ -5,6 +5,7 @@ function errorMessage(error) {
 export function createProjectsController({
   client,
   getEnvironmentId,
+  isRuntimeReady = () => true,
   getConversationRevision,
   prepareConversation,
   openSession,
@@ -15,6 +16,7 @@ export function createProjectsController({
 }) {
   let revision = 0;
   let currentEnvironment = getEnvironmentId();
+  let runtimeReady = isRuntimeReady();
   let browseRevision = 0;
   let listRevision = 0;
   let activationRevision = 0;
@@ -27,8 +29,16 @@ export function createProjectsController({
   };
   const snapshot = () => state;
   const publish = () => onChange(snapshot());
-  const isCurrentEnvironment = (environmentId, token) =>
-    environmentId === getEnvironmentId() && token === revision;
+  function canUseProjects() {
+    if (!isRuntimeReady()) return false;
+    return client.supportsProjects();
+  }
+
+  function isCurrentEnvironment(environmentId, token) {
+    if (!canUseProjects()) return false;
+    if (environmentId !== getEnvironmentId()) return false;
+    return token === revision;
+  }
   const hasCurrentDraft = (environmentId, token, draft) =>
     isCurrentEnvironment(environmentId, token) && state.draft === draft;
 
@@ -38,6 +48,7 @@ export function createProjectsController({
   }
 
   function canApplyFolderListing(environmentId, token, draft) {
+    if (!canUseProjects()) return false;
     if (state.draft !== draft) return false;
     if (token !== browseRevision) return false;
     if (!draft.pickerOpen) return false;
@@ -50,12 +61,14 @@ export function createProjectsController({
   }
 
   function canCreateProject(draft) {
+    if (!canUseProjects()) return false;
     if (!canEditProjectDraft(draft)) return false;
     if (draft.pickerOpen) return false;
     return !draft.loading;
   }
 
   function canBrowseProjectFolders(draft) {
+    if (!canUseProjects()) return false;
     if (!canEditProjectDraft(draft)) return false;
     return draft.pickerOpen;
   }
@@ -72,17 +85,17 @@ export function createProjectsController({
   }
 
   async function load() {
+    synchronizeProjectRuntime();
     const environmentId = getEnvironmentId();
-    currentEnvironment = environmentId;
     const token = revision;
     const listToken = ++listRevision;
-    state = { ...state, loading: true, error: "" };
-    publish();
-    if (!client.supportsProjects()) {
-      state = { ...state, projects: [], loading: false };
+    if (!canUseProjects()) {
+      state = { ...state, projects: [], loading: false, error: "" };
       publish();
       return;
     }
+    state = { ...state, loading: true, error: "" };
+    publish();
     try {
       const result = await client.listProjects(environmentId);
       if (!canApplyProjectList(environmentId, token, listToken)) return;
@@ -131,6 +144,7 @@ export function createProjectsController({
   }
 
   function openFolderPicker() {
+    if (!canUseProjects()) return Promise.resolve();
     const draft = state.draft;
     if (!canEditProjectDraft(draft)) return Promise.resolve();
     draft.pickerOpen = true;
@@ -156,6 +170,7 @@ export function createProjectsController({
   }
 
   function openCreate() {
+    if (!canUseProjects()) return;
     activationRevision += 1;
     state = {
       ...state,
@@ -213,6 +228,7 @@ export function createProjectsController({
   }
 
   async function newConversation(projectId) {
+    if (!canUseProjects()) return;
     if (state.busyProjectId) return;
     if (!prepareConversation()) return;
     const environmentId = getEnvironmentId();
@@ -244,27 +260,46 @@ export function createProjectsController({
     }
   }
 
-  function environmentChanged() {
-    if (currentEnvironment === getEnvironmentId()) return Promise.resolve();
-    currentEnvironment = getEnvironmentId();
+  function retainedProjectDraft(environmentChanged) {
+    if (environmentChanged) return null;
+    if (!state.draft) return null;
+    return { ...state.draft, loading: false, saving: false, error: "",
+      pickerOpen: false, listing: null };
+  }
+
+  function hasProjectRuntimeChanged(environmentId, ready) {
+    if (currentEnvironment !== environmentId) return true;
+    return runtimeReady !== ready;
+  }
+
+  function synchronizeProjectRuntime() {
+    const environmentId = getEnvironmentId();
+    const ready = isRuntimeReady();
+    const environmentChanged = currentEnvironment !== environmentId;
+    if (!hasProjectRuntimeChanged(environmentId, ready)) return false;
+    const draft = retainedProjectDraft(environmentChanged);
+    currentEnvironment = environmentId;
+    runtimeReady = ready;
     revision += 1;
     listRevision += 1;
     browseRevision += 1;
-    state = {
-      projects: [],
-      loading: false,
-      error: "",
-      draft: null,
-      busyProjectId: "",
-    };
+    activationRevision += 1;
+    state = { projects: [], loading: false, error: "", draft, busyProjectId: "" };
     publish();
+    return true;
+  }
+
+  function runtimeAvailabilityChanged() {
+    if (!synchronizeProjectRuntime()) return Promise.resolve();
+    if (!canUseProjects()) return Promise.resolve();
     return load();
   }
 
   return {
     snapshot,
     load,
-    environmentChanged,
+    environmentChanged: runtimeAvailabilityChanged,
+    runtimeAvailabilityChanged,
     openCreate,
     closeCreate,
     updateDraft,