@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/worker/observe/static/state.js

@@ -0,0 +1,496 @@
+/** Shared mutable UI state singleton (Observe UI R5). */
+import {
+	ACTIVE_DETAIL_POLL_MS,
+	HIDDEN_POLL_MS,
+	DASHBOARD_POLL_MS,
+	TERMINAL_RUN_STATUSES,
+	OUTPUT_FOLLOW_LATEST_PX,
+} from "./constants.js";
+import { clearNode, el } from "./dom.js";
+
+/**
+ * Single mutable ownership bag. Import `{ uiState }` and mutate properties.
+ * Never assign through `import * as ns` live bindings (Chrome TypeError).
+ */
+export const uiState = {
+	dashboardTimer: null,
+	runPollTimer: null,
+	dagPollTimer: null,
+	poolTimer: null,
+	/** Pool page: auto-refresh opt-in (default false). */
+	poolAutoRefresh: false,
+	/** DAG history page request generation (drop late responses). */
+	dagHistoryRequestSeq: 0,
+	/** Last successful formal DAG history page payload. */
+	dagHistoryPage: null,
+	dagHistoryError: null,
+	dagHistoryLoading: false,
+	/** Light busy for cache-miss navigate / manual refresh (keeps old table). */
+	dagHistoryBusy: false,
+	dagHistoryDegraded: false,
+	/** Session-only page cache keyed by `${pageSize}:${page}`. */
+	dagHistoryCache: null,
+	/** In-flight adjacent prefetch map: cacheKey → generation (same-gen dedupe). */
+	dagHistoryPrefetchInFlight: null,
+	/**
+	 * Prefetch generation; manual refresh bumps so older prefetches cannot
+	 * write neighbor cache entries after invalidation.
+	 */
+	dagHistoryPrefetchGeneration: 0,
+	/** AbortController for the active formal history request. */
+	dagHistoryAbortController: null,
+	taskPollTimer: null,
+	runEventOffset: 0,
+	runEvents: [],
+	currentRunId: null,
+	currentBatchRunId: null,
+	currentDagRunId: null,
+	selectedDagNodeId: null,
+	sessionEventOffset: 0,
+	sessionEvents: [],
+	// Identity token ("<dagRunId>:<nodeId>#<seq>") bumped on every node/DAG
+	// switch. In-flight session-event fetches capture this before await and
+	// reject themselves when it no longer matches, so a stale response for a
+	// previous node can never mutate the current node's event cache.
+	sessionEventIdentity: null,
+	sessionEventIdentitySeq: 0,
+	/** Node-input request identity ("<dagRunId>:<nodeId>#<seq>"). */
+	dagNodeInputIdentity: null,
+	dagNodeInputRequestSeq: 0,
+	/** Last successful / in-flight node-input payload for the active identity. */
+	dagNodeInputData: null,
+	dagNodeInputError: null,
+	dagNodeInputLoading: false,
+	/**
+	 * Execution-output request identity ("<dagRunId>:<nodeId>:<key>#<seq>").
+	 * Stale async responses are rejected when this no longer matches.
+	 */
+	dagNodeExecutionOutputIdentity: null,
+	dagNodeExecutionOutputRequestSeq: 0,
+	/**
+	 * Cache of loaded execution bodies keyed by dagRunId\0nodeId\0key.
+	 * Survives poll re-renders; cleared on node switch.
+	 */
+	dagNodeExecutionOutputCache: null,
+	/** Loading/error for the currently requested execution key (not global wipe). */
+	dagNodeExecutionOutputLoading: false,
+	dagNodeExecutionOutputError: null,
+	dagNodeExecutionOutputKey: null,
+	/** When true,「执行过程」展开 message_start/end 原始协议事件。 */
+	sessionTimelineShowProtocol: false,
+	/** Open <details> keys restored across timeline re-renders. */
+	sessionTimelineOpenDetails: null,
+	lastSnapshot: null,
+	dagInspectorOpen: false,
+	dagInspectorTab: "output",
+	/**
+	 * Inspector attempt selection (identity: dagRunId + nodeId + attempt key).
+	 * null = latest attempt; reset on node switch; preserved across poll refreshes.
+	 */
+	dagInspectorAttempt: null,
+	/**
+	 * DAG 图区域当前视图模式镜像（真实持久在 dagGraphViewModes Map）。
+	 * 同会话内重新进入同一 dagRunId 时保持，不切回逻辑拓扑（AC-001）。
+	 */
+	dagGraphViewMode: "topology",
+	dagInspectorWidth: null,
+	dagGraphViewportState: null,
+	dagTrajectoryViewportState: null,
+	dagTimelineViewportState: null,
+	dagNodeOutputViewportState: null,
+	dagNodeInputViewportState: null,
+	/** Spec-evidence inspector content scroll (single active region snapshot). */
+	dagNodeSpecEvidenceViewportState: null,
+	runOutputViewportState: null,
+	/**
+	 * Spec-evidence file preview drill-down. null = list view; otherwise
+	 * { source, path, loading, error, data, triggerId } for the active preview.
+	 */
+	specEvidenceDetail: null,
+	/** Last-rendered spec-evidence list, used to restore the list synchronously. */
+	specEvidenceListEvidence: null,
+	pollingGeneration: 0,
+};
+
+/** Per-dagRunId graph viewport restore map (stable Map instance). */
+export const dagGraphViewportStates = new Map();
+
+/**
+ * Per-dagRunId graph view mode ("topology" | "trajectory"). Session-only
+ * persistence: poll refreshes and re-entering the same dagRunId keep the
+ * current mode; a full page reload falls back to 逻辑拓扑 (AC-001 evidence gap).
+ */
+export const dagGraphViewModes = new Map();
+
+/** Per-dagRunId execution-trajectory viewport restore map. */
+export const dagTrajectoryViewportStates = new Map();
+
+/** Set the graph view mode for a dagRunId (topology | trajectory). */
+export function setDagGraphViewMode(dagRunId, mode) {
+	const normalized = mode === "trajectory" ? "trajectory" : "topology";
+	dagGraphViewModes.set(dagRunId, normalized);
+	uiState.dagGraphViewMode = normalized;
+	return normalized;
+}
+
+/** Resolve the effective graph view mode for a dagRunId (default topology). */
+export function currentDagGraphViewMode(dagRunId) {
+	return dagGraphViewModes.get(dagRunId) ?? "topology";
+}
+
+export function updateDagTrajectoryViewportState(
+	_previous,
+	dagRunId,
+	scrollLeft,
+	scrollTop,
+) {
+	return {
+		dagRunId,
+		scrollLeft: Math.max(0, Number(scrollLeft) || 0),
+		scrollTop: Math.max(0, Number(scrollTop) || 0),
+	};
+}
+
+/**
+ * Per-context inspector content scroll map.
+ * Key format: dag:<dagRunId>:<nodeId>:<tab>
+ */
+export const dagInspectorViewportStates = new Map();
+
+/** Build a stable inspector scroll region key (AC-005 context isolation). */
+export function inspectorViewportRegionKey(dagRunId, nodeId, tab) {
+	return `dag:${dagRunId ?? ""}:${nodeId ?? ""}:${tab ?? "output"}`;
+}
+
+export function updateDagInspectorViewportState(
+	_previous,
+	regionKey,
+	scrollLeft,
+	scrollTop,
+) {
+	return {
+		regionKey,
+		scrollLeft: Math.max(0, Number(scrollLeft) || 0),
+		scrollTop: Math.max(0, Number(scrollTop) || 0),
+	};
+}
+
+/**
+ * Persist inspector scroll for a context. When `preserveIntent` is true and the
+ * incoming position is a zero clamp on short (loading) content while a non-zero
+ * intent already exists, keep the previous intent instead of overwriting to 0.
+ */
+export function saveDagInspectorViewportState(
+	regionKey,
+	scrollLeft,
+	scrollTop,
+	options = {},
+) {
+	if (!regionKey) return null;
+	const left = Math.max(0, Number(scrollLeft) || 0);
+	const top = Math.max(0, Number(scrollTop) || 0);
+	if (options.preserveIntent) {
+		const existing = dagInspectorViewportStates.get(regionKey);
+		if (
+			existing &&
+			left === 0 &&
+			top === 0 &&
+			(existing.scrollLeft > 0 || existing.scrollTop > 0)
+		) {
+			return existing;
+		}
+	}
+	const next = updateDagInspectorViewportState(null, regionKey, left, top);
+	dagInspectorViewportStates.set(regionKey, next);
+	return next;
+}
+
+export function getDagInspectorViewportState(regionKey) {
+	if (!regionKey) return null;
+	return dagInspectorViewportStates.get(regionKey) ?? null;
+}
+
+/** Build a fresh session-event identity token and bump the global sequence. */
+export function makeSessionEventIdentity(dagRunId, nodeId) {
+	uiState.sessionEventIdentitySeq += 1;
+	return `${dagRunId}:${nodeId}#${uiState.sessionEventIdentitySeq}`;
+}
+
+/** Build a fresh node-input identity token and bump its sequence. */
+export function makeDagNodeInputIdentity(dagRunId, nodeId) {
+	uiState.dagNodeInputRequestSeq += 1;
+	return `${dagRunId}:${nodeId}#${uiState.dagNodeInputRequestSeq}`;
+}
+
+/** Build a fresh execution-output identity token (includes key). */
+export function makeDagNodeExecutionOutputIdentity(dagRunId, nodeId, key) {
+	uiState.dagNodeExecutionOutputRequestSeq += 1;
+	return `${dagRunId}:${nodeId}:${key ?? "latest"}#${uiState.dagNodeExecutionOutputRequestSeq}`;
+}
+
+/** Stable cache key for a node execution body. */
+export function dagNodeExecutionOutputCacheKey(dagRunId, nodeId, key) {
+	return `${dagRunId ?? ""}\0${nodeId ?? ""}\0${key ?? "latest"}`;
+}
+
+/** Read a cached execution body entry (or null). */
+export function getDagNodeExecutionOutputCache(dagRunId, nodeId, key) {
+	const map = uiState.dagNodeExecutionOutputCache;
+	if (!(map instanceof Map)) return null;
+	return map.get(dagNodeExecutionOutputCacheKey(dagRunId, nodeId, key)) ?? null;
+}
+
+/** Write a successful body into the cache without clearing other keys. */
+export function setDagNodeExecutionOutputCache(dagRunId, nodeId, key, entry) {
+	if (!(uiState.dagNodeExecutionOutputCache instanceof Map)) {
+		uiState.dagNodeExecutionOutputCache = new Map();
+	}
+	uiState.dagNodeExecutionOutputCache.set(
+		dagNodeExecutionOutputCacheKey(dagRunId, nodeId, key),
+		entry,
+	);
+	return entry;
+}
+
+/** Drop all cached execution bodies (node switch / leave). */
+export function clearDagNodeExecutionOutputCache() {
+	uiState.dagNodeExecutionOutputCache = new Map();
+	uiState.dagNodeExecutionOutputError = null;
+	uiState.dagNodeExecutionOutputLoading = false;
+	uiState.dagNodeExecutionOutputKey = null;
+	uiState.dagNodeExecutionOutputIdentity = null;
+	uiState.dagNodeExecutionOutputRequestSeq += 1;
+}
+
+export function isPageVisible() {
+	return (
+		typeof document === "undefined" || document.visibilityState !== "hidden"
+	);
+}
+
+export function detailPollDelay(status, isVisible) {
+	const normalizedStatus = (status ?? "").toLowerCase().replace(/-/g, "_");
+	if (TERMINAL_RUN_STATUSES.has(normalizedStatus)) return null;
+	return isVisible ? ACTIVE_DETAIL_POLL_MS : HIDDEN_POLL_MS;
+}
+
+export function dashboardPollDelay() {
+	return isPageVisible() ? DASHBOARD_POLL_MS : HIDDEN_POLL_MS;
+}
+
+export function updateDagGraphViewportState(
+	_previous,
+	dagRunId,
+	scrollLeft,
+	scrollTop,
+) {
+	return {
+		dagRunId,
+		scrollLeft: Math.max(0, Number(scrollLeft) || 0),
+		scrollTop: Math.max(0, Number(scrollTop) || 0),
+	};
+}
+
+export function captureDagGraphViewportState(previous, dagRunId, viewport) {
+	if (!viewport || viewport.dataset?.dagRunId !== dagRunId) return previous;
+	return updateDagGraphViewportState(
+		previous,
+		dagRunId,
+		viewport.scrollLeft,
+		viewport.scrollTop,
+	);
+}
+
+export function updateDagTimelineViewportState(
+	_previous,
+	dagRunId,
+	nodeId,
+	scrollLeft,
+	scrollTop,
+	followLatest,
+) {
+	return {
+		dagRunId,
+		nodeId,
+		scrollLeft: Math.max(0, Number(scrollLeft) || 0),
+		scrollTop: Math.max(0, Number(scrollTop) || 0),
+		followLatest: Boolean(followLatest),
+	};
+}
+
+// Unified follow-latest helper for DAG node output and Worker output scroll
+// regions. Returns true only when the user is parked within `threshold` px of
+// the bottom, mirroring the existing process-timeline behaviour.
+export function computeFollowLatest(
+	scrollTop,
+	scrollHeight,
+	clientHeight,
+	threshold = OUTPUT_FOLLOW_LATEST_PX,
+) {
+	const top = Number(scrollTop);
+	const height = Number(scrollHeight);
+	const client = Number(clientHeight);
+	if (
+		!Number.isFinite(top) ||
+		!Number.isFinite(height) ||
+		!Number.isFinite(client)
+	) {
+		return false;
+	}
+	if (height <= 0 || client <= 0) return false;
+	return height - top - client < Math.max(0, Number(threshold) || 0);
+}
+
+// Generalised viewport-state record keyed by `regionKey`, so the same helper
+// serves the DAG node inspector output ("dag:<runId>:<nodeId>:output") and the
+// Worker run output ("run:<runId>:output").
+export function updateDagOutputViewportState(
+	_previous,
+	regionKey,
+	scrollLeft,
+	scrollTop,
+	followLatest,
+) {
+	return {
+		regionKey,
+		scrollLeft: Math.max(0, Number(scrollLeft) || 0),
+		scrollTop: Math.max(0, Number(scrollTop) || 0),
+		followLatest: Boolean(followLatest),
+	};
+}
+
+// Poll-render decision helpers. Initial paints always rebuild the shell; a
+// non-initial refresh reuses the existing viewport/inspector DOM identity so
+// active pointer-capture targets (scrollbar / resize handle) survive.
+export function shouldReuseDagDetailShell(initial, hasExistingViewport) {
+	return !initial && Boolean(hasExistingViewport);
+}
+
+export function shouldPreserveDiagnosticsOpen(initial, existingOpen) {
+	if (initial) return false;
+	return Boolean(existingOpen);
+}
+
+// Detects an in-progress resize/scroll gesture so the poll renderer can defer
+// tearing down the interactive shell until the gesture releases.
+export function isInteractiveGestureActive(bodyClassList) {
+	const list = bodyClassList;
+	if (!list || typeof list.contains !== "function") return false;
+	return (
+		list.contains("is-resizing-dag-inspector") ||
+		list.contains("is-resizing-dag-graph")
+	);
+}
+
+export function stopTimers() {
+	uiState.pollingGeneration += 1;
+	if (uiState.dashboardTimer) {
+		clearTimeout(uiState.dashboardTimer);
+		uiState.dashboardTimer = null;
+	}
+	if (uiState.runPollTimer) {
+		clearTimeout(uiState.runPollTimer);
+		uiState.runPollTimer = null;
+	}
+	if (uiState.dagPollTimer) {
+		clearTimeout(uiState.dagPollTimer);
+		uiState.dagPollTimer = null;
+	}
+	if (uiState.poolTimer) {
+		clearTimeout(uiState.poolTimer);
+		uiState.poolTimer = null;
+	}
+	if (uiState.taskPollTimer) {
+		clearTimeout(uiState.taskPollTimer);
+		uiState.taskPollTimer = null;
+	}
+	uiState.currentRunId = null;
+	uiState.currentBatchRunId = null;
+	uiState.currentDagRunId = null;
+	uiState.selectedDagNodeId = null;
+	uiState.sessionEventOffset = 0;
+	uiState.sessionEvents = [];
+	uiState.sessionEventIdentity = null;
+	uiState.sessionEventIdentitySeq += 1;
+	uiState.runEventOffset = 0;
+	uiState.runEvents = [];
+}
+
+/** Pure descriptor for loading / empty / degraded / error (REQ-R5-05). */
+export function viewStateDescriptor(kind, message, options = {}) {
+	const classByKind = {
+		loading: "view-state view-state-loading",
+		empty: "view-state view-state-empty empty",
+		degraded: "view-state view-state-degraded projection-fault",
+		error: "view-state view-state-error",
+	};
+	const role =
+		kind === "error" || kind === "degraded"
+			? "alert"
+			: kind === "loading"
+				? "status"
+				: null;
+	return {
+		kind,
+		className: classByKind[kind] ?? "view-state",
+		role,
+		ariaLive: kind === "loading" ? "polite" : null,
+		message: message ?? "",
+		detail: options.detail ?? null,
+		messageClass:
+			kind === "empty" ? "empty" : kind === "loading" ? "muted" : null,
+	};
+}
+
+/** Distinguishable loading / empty / degraded / error panel states (REQ-R5-05). */
+export function renderViewState(kind, message, options = {}) {
+	const desc = viewStateDescriptor(kind, message, options);
+	const node = el("div", desc.className);
+	if (desc.role) node.setAttribute("role", desc.role);
+	if (desc.ariaLive) node.setAttribute("aria-live", desc.ariaLive);
+	node.appendChild(el("p", desc.messageClass, desc.message));
+	if (desc.detail) {
+		node.appendChild(el("p", "muted", desc.detail));
+	}
+	return node;
+}
+
+export function mountViewState(container, kind, message, options) {
+	if (!container) return null;
+	clearNode(container);
+	const node = renderViewState(kind, message, options);
+	container.appendChild(node);
+	return node;
+}
+
+export function setLastSnapshot(snapshot) {
+	uiState.lastSnapshot = snapshot;
+}
+
+export function setPollingGeneration(value) {
+	uiState.pollingGeneration = value;
+}
+
+export function bumpPollingGeneration() {
+	uiState.pollingGeneration += 1;
+	return uiState.pollingGeneration;
+}
+
+/** Open an in-inspector spec-evidence file preview (AC-001/002). */
+export function openSpecEvidenceDetail(source, path, triggerEl) {
+	uiState.specEvidenceDetail = {
+		source,
+		path,
+		loading: true,
+		error: null,
+		data: null,
+		triggerId: triggerEl?.id ?? null,
+	};
+}
+
+/** Close the preview; caller restores focus to the trigger element. */
+export function closeSpecEvidenceDetail() {
+	const detail = uiState.specEvidenceDetail;
+	uiState.specEvidenceDetail = null;
+	return detail;
+}