npm - @tea-agent/loop-agent - Versions diffs - 0.33.6 → 0.34.0 - Mend

@tea-agent/loop-agent 0.33.6 → 0.34.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/dist/worker/console/static/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <link rel="stylesheet" href="/inspect/operator-chrome.css" />
     <title>Loop 操作台 · Operator Console</title>
-    <script type="module" crossorigin src="/assets/index-BUOLppPr.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-C1KzazY5.css">
+    <script type="module" crossorigin src="/assets/index-CMHovlqG.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BQkhJpV8.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/worker/console/static-src/operator-chat/landing-density.js ADDED Viewed

@@ -0,0 +1,23 @@
+/** Landing density resolved from measured empty-container height. */
+/** Height thresholds in CSS px against `.oc-messages.is-empty`. */
+export const LANDING_DENSITY_THRESHOLDS = {
+    comfortableMin: 620,
+    compactMin: 480,
+};
+/**
+ * Resolve Landing visual density from empty-container block size.
+ * comfortable >=620, compact 480-619, extra-compact <480.
+ */
+export function resolveLandingDensity(heightPx) {
+    if (!Number.isFinite(heightPx) || heightPx < 0)
+        return "extra-compact";
+    if (heightPx >= LANDING_DENSITY_THRESHOLDS.comfortableMin)
+        return "comfortable";
+    if (heightPx >= LANDING_DENSITY_THRESHOLDS.compactMin)
+        return "compact";
+    return "extra-compact";
+}
+/** CSS class suffix for density attribute binding. */
+export function landingDensityClass(density) {
+    return `is-landing-${density}`;
+}

package/dist/worker/console/static-src/operator-chat/session-title-watcher.js ADDED Viewed

@@ -0,0 +1,128 @@
+/**
+ * Owns title-only SSE lifecycles. It is deliberately independent from the
+ * timeline SSE applier: title frames update the session index only.
+ */
+export class SessionTitleWatcher {
+    options;
+    eligible = new Set();
+    controllers = new Map();
+    fetchFn;
+    backoffMs;
+    deadlineMs;
+    constructor(options) {
+        this.options = options;
+        this.fetchFn = options.fetchFn ?? fetch;
+        this.backoffMs = options.backoffMs ?? 1_000;
+        this.deadlineMs = options.deadlineMs ?? 30_000;
+    }
+    markEligible(sessionId) {
+        this.eligible.add(sessionId);
+    }
+    startIfEligible(sessionId) {
+        if (!this.eligible.delete(sessionId) || this.controllers.has(sessionId))
+            return;
+        const controller = new AbortController();
+        this.controllers.set(sessionId, controller);
+        void this.run(sessionId, controller);
+    }
+    cancel(sessionId) {
+        this.eligible.delete(sessionId);
+        this.controllers.get(sessionId)?.abort();
+        this.controllers.delete(sessionId);
+    }
+    reconcile(sessionIds) {
+        const current = new Set(sessionIds);
+        for (const sessionId of this.controllers.keys()) {
+            if (!current.has(sessionId))
+                this.cancel(sessionId);
+        }
+    }
+    dispose() {
+        for (const controller of this.controllers.values())
+            controller.abort();
+        this.controllers.clear();
+        this.eligible.clear();
+    }
+    async run(sessionId, controller) {
+        let lastEventId;
+        const seen = new Set();
+        let deadlineReached = false;
+        const deadline = window.setTimeout(() => {
+            deadlineReached = true;
+            controller.abort();
+        }, this.deadlineMs);
+        try {
+            while (!controller.signal.aborted) {
+                try {
+                    const headers = { Accept: "text/event-stream" };
+                    if (lastEventId)
+                        headers["Last-Event-ID"] = lastEventId;
+                    const response = await this.fetchFn(`${this.options.origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/events`, { headers, credentials: "include", signal: controller.signal });
+                    if (response.status === 404 || !response.body)
+                        return;
+                    if (!response.ok)
+                        throw new Error(`HTTP ${response.status}`);
+                    const reader = response.body.getReader();
+                    const decoder = new TextDecoder();
+                    let buffer = "";
+                    for (;;) {
+                        const { done, value } = await reader.read();
+                        if (done || controller.signal.aborted)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        const blocks = buffer.split("\n\n");
+                        buffer = blocks.pop() ?? "";
+                        for (const block of blocks) {
+                            const eventId = block.split("\n").find((line) => line.startsWith("id: "))?.slice(4);
+                            if (eventId)
+                                lastEventId = eventId;
+                            if (!eventId || seen.has(eventId) || !block.includes("event: session_title"))
+                                continue;
+                            const data = block.split("\n").find((line) => line.startsWith("data: "))?.slice(6);
+                            if (!data)
+                                continue;
+                            try {
+                                const parsed = JSON.parse(data);
+                                const title = parsed.data?.title?.trim();
+                                if (!title)
+                                    continue;
+                                seen.add(eventId);
+                                if (!this.options.hasSession(sessionId))
+                                    return;
+                                this.options.onTitle(sessionId, { title, automatic: Boolean(parsed.data?.automatic) });
+                                if (parsed.data?.automatic)
+                                    return;
+                            }
+                            catch { /* malformed title frames are ignored */ }
+                        }
+                    }
+                }
+                catch {
+                    if (controller.signal.aborted)
+                        return;
+                }
+                if (!controller.signal.aborted)
+                    await abortableSleep(this.backoffMs, controller.signal);
+            }
+        }
+        finally {
+            window.clearTimeout(deadline);
+            if (this.controllers.get(sessionId) === controller)
+                this.controllers.delete(sessionId);
+            if (deadlineReached || !this.options.hasSession(sessionId))
+                void this.options.refresh();
+        }
+    }
+}
+function abortableSleep(ms, signal) {
+    return new Promise((resolve) => {
+        const timer = window.setTimeout(done, ms);
+        const onAbort = () => done();
+        function done() {
+            window.clearTimeout(timer);
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/worker/console/static-src/operator-chat/sidebar-split.js ADDED Viewed

@@ -0,0 +1,90 @@
+/** Session/repo vertical split percent with versioned localStorage. */
+export const SIDEBAR_SPLIT_STORAGE_KEY = "loop-console.operator-chat.sidebar-split.v1";
+export const SIDEBAR_SPLIT_DEFAULT = 45;
+export const SIDEBAR_SPLIT_MIN = 28;
+export const SIDEBAR_SPLIT_MAX = 70;
+export const SIDEBAR_SPLIT_STEP = 5;
+export const SIDEBAR_SPLIT_STEP_LARGE = 10;
+/** Clamp session share percent into the legal 28–70 band. */
+export function clampSplit(percent) {
+    if (!Number.isFinite(percent))
+        return SIDEBAR_SPLIT_DEFAULT;
+    return Math.min(SIDEBAR_SPLIT_MAX, Math.max(SIDEBAR_SPLIT_MIN, Math.round(percent)));
+}
+/** Parse a stored value; only integers in 28–70 are accepted. */
+export function parseStoredSplit(raw) {
+    if (raw == null || raw === "")
+        return null;
+    const n = Number(raw);
+    if (!Number.isFinite(n))
+        return null;
+    const rounded = Math.round(n);
+    if (rounded < SIDEBAR_SPLIT_MIN || rounded > SIDEBAR_SPLIT_MAX)
+        return null;
+    return rounded;
+}
+/** Load session percent or fall back to 45 on missing/corrupt storage. */
+export function loadSidebarSplit(storage = defaultStorage()) {
+    if (!storage)
+        return SIDEBAR_SPLIT_DEFAULT;
+    try {
+        const parsed = parseStoredSplit(storage.getItem(SIDEBAR_SPLIT_STORAGE_KEY));
+        return parsed ?? SIDEBAR_SPLIT_DEFAULT;
+    }
+    catch {
+        return SIDEBAR_SPLIT_DEFAULT;
+    }
+}
+/** Persist a clamped session percent; ignore storage failures. */
+export function saveSidebarSplit(percent, storage = defaultStorage()) {
+    const value = clampSplit(percent);
+    if (!storage)
+        return value;
+    try {
+        storage.setItem(SIDEBAR_SPLIT_STORAGE_KEY, String(value));
+    }
+    catch {
+        // localStorage may be unavailable; keep in-memory value.
+    }
+    return value;
+}
+/** Map keyboard keys on the separator to a next session percent. */
+export function adjustSplitByKey(current, key, shiftKey = false) {
+    const base = clampSplit(current);
+    switch (key) {
+        case "ArrowUp":
+            return clampSplit(base - (shiftKey ? SIDEBAR_SPLIT_STEP_LARGE : SIDEBAR_SPLIT_STEP));
+        case "ArrowDown":
+            return clampSplit(base + (shiftKey ? SIDEBAR_SPLIT_STEP_LARGE : SIDEBAR_SPLIT_STEP));
+        case "Home":
+            return SIDEBAR_SPLIT_MIN;
+        case "End":
+            return SIDEBAR_SPLIT_MAX;
+        case "Enter":
+            return SIDEBAR_SPLIT_DEFAULT;
+        default:
+            return null;
+    }
+}
+/**
+ * Compute session percent from a pointer Y within a split track rect.
+ * top of track → min session share; bottom → max session share.
+ */
+export function splitPercentFromPointer(clientY, trackTop, trackHeight) {
+    if (!Number.isFinite(trackHeight) || trackHeight <= 0) {
+        return SIDEBAR_SPLIT_DEFAULT;
+    }
+    const ratio = (clientY - trackTop) / trackHeight;
+    return clampSplit(ratio * 100);
+}
+function defaultStorage() {
+    try {
+        if (typeof globalThis === "undefined")
+            return null;
+        const storage = globalThis.localStorage;
+        return storage ?? null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/worker/console/static-src/operator-chat/spatial-overlay.js ADDED Viewed

@@ -0,0 +1,37 @@
+/**
+ * Mutual-exclusion state for large spatial overlays in Operator Chat.
+ * At most one of: sidebar drawer, process, runtime context, tools.
+ * Small composer menus (model/thinking) are out of scope.
+ */
+export function createSpatialOverlayState(active = "none") {
+    return { active };
+}
+/** Open one overlay; closes any other spatial overlay. */
+export function openSpatialOverlay(_state, kind) {
+    return { active: kind };
+}
+/** Close the active overlay (or no-op when already none). */
+export function closeSpatialOverlay(_state = { active: "none" }) {
+    return { active: "none" };
+}
+/** Close only when the named overlay is active. */
+export function closeSpatialOverlayIf(state, kind) {
+    return state.active === kind ? { active: "none" } : state;
+}
+export function isSpatialOverlayOpen(state, kind) {
+    if (kind)
+        return state.active === kind;
+    return state.active !== "none";
+}
+/**
+ * Derive exclusive UI flags for the four large panels from a single source.
+ * Opening one forces the others closed.
+ */
+export function spatialOverlayFlags(state) {
+    return {
+        sidebarDrawerOpen: state.active === "sidebar-drawer",
+        processOpen: state.active === "process",
+        runtimeContextOpen: state.active === "runtime-context",
+        toolsOpen: state.active === "tools",
+    };
+}

package/dist/worker/console/static-src/operator-chat/useChatSessions.js CHANGED Viewed

@@ -4,6 +4,56 @@ import { hydrateSessionThread } from "../../chat/turn-process.js";
 import { ACTIVE_CHAT_SESSION_STORAGE_KEY } from "../../chat/workspace-landing.js";
 import { CHAT_SESSION_LIST_LIMIT } from "../chat-view-types.js";
 import { confirmationToken } from "./format.js";
+import { SessionTitleWatcher } from "./session-title-watcher.js";
+export async function createSessionAndPrimeTitleWatcher(input) {
+    if (input.creatingRef?.current) {
+        throw new Error("CREATE_SESSION_IN_FLIGHT");
+    }
+    if (input.creatingRef)
+        input.creatingRef.current = true;
+    // Synchronous busy feedback: callers set creatingSession in the same render
+    // turn via setCreatingSession before the network await below.
+    input.setCreatingSession?.(true);
+    try {
+        const res = await (input.fetchFn ?? fetch)(`${input.origin}/api/operator/v1/chat/sessions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-loop-console-confirmation": confirmationToken(),
+            },
+            credentials: "include",
+            body: JSON.stringify(input.options ?? {}),
+        });
+        if (!res.ok) {
+            const body = (await res.json().catch(() => ({})));
+            throw new Error(body.error?.message ?? `HTTP ${res.status}`);
+        }
+        const body = (await res.json());
+        if (!body.session)
+            throw new Error("创建会话响应缺少 durable session");
+        const durable = body.session;
+        const created = {
+            sessionId: durable.sessionId,
+            ...runtimeSelectionFromRecord(durable),
+        };
+        const nextList = [
+            durable,
+            ...input.sessionListRef.current.filter((item) => item.sessionId !== durable.sessionId),
+        ].slice(0, CHAT_SESSION_LIST_LIMIT);
+        // Commit ref → state → eligibility → deferred refresh. The ref assignment
+        // makes the durable record observable before React's state commit.
+        input.sessionListRef.current = nextList;
+        input.setSessionList(nextList);
+        input.titleWatcher?.markEligible(durable.sessionId);
+        void input.refreshSessionList();
+        return created;
+    }
+    finally {
+        if (input.creatingRef)
+            input.creatingRef.current = false;
+        input.setCreatingSession?.(false);
+    }
+}
 /** Session lifecycle: list / activate / create / delete / rename-archive /
  *  compact, plus browser-refresh recovery from the durable session store. */
 export function useChatSessions(params) {
@@ -12,6 +62,12 @@ export function useChatSessions(params) {
     const { setInput, setPendingImages } = composer;
     const { setPreviews, setActivePreviewPath } = browser;
     const [sessionList, setSessionList] = useState([]);
+    const sessionListRef = useRef([]);
+    sessionListRef.current = sessionList;
+    const titleWatcherRef = useRef(null);
+    // Shared busy gate for sidebar + Landing create entries (one render feedback).
+    const [creatingSession, setCreatingSession] = useState(false);
+    const creatingSessionRef = useRef(false);
     // Only the latest activate/create/restore intent may commit active-session
     // state. This prevents slow responses from an older selection overwriting a
     // newer user choice.
@@ -102,6 +158,7 @@ export function useChatSessions(params) {
                 setError("删除会话失败");
                 return;
             }
+            titleWatcherRef.current?.cancel(sessionId);
             if (refs.sessionRef.current?.sessionId === sessionId) {
                 sessionSelectionVersionRef.current += 1;
                 refs.sessionRef.current = null;
@@ -179,6 +236,32 @@ export function useChatSessions(params) {
     useEffect(() => {
         void refreshSessionList();
     }, [refreshSessionList]);
+    if (!titleWatcherRef.current) {
+        titleWatcherRef.current = new SessionTitleWatcher({
+            origin,
+            hasSession: (sessionId) => sessionListRef.current.some((item) => item.sessionId === sessionId),
+            onTitle: (sessionId, event) => {
+                setSessionList((current) => current.map((item) => {
+                    if (item.sessionId !== sessionId)
+                        return item;
+                    // A manually assigned title is authoritative over late automatic output.
+                    if (event.automatic && item.title)
+                        return item;
+                    return event.automatic
+                        ? { ...item, title: event.title }
+                        : { ...item, displayTitle: event.title };
+                }));
+            },
+            refresh: refreshSessionList,
+        });
+    }
+    const watchSessionTitle = useCallback((sessionId) => titleWatcherRef.current?.startIfEligible(sessionId), []);
+    useEffect(() => {
+        titleWatcherRef.current?.reconcile(sessionList
+            .filter((item) => item.state !== "archived" && !item.title)
+            .map((item) => item.sessionId));
+    }, [sessionList]);
+    useEffect(() => () => titleWatcherRef.current?.dispose(), []);
     // Browser refresh recovery: retain only the durable session id locally, then
     // re-read messages and operation refs/facts from the server-owned stores.
     useEffect(() => {
@@ -233,29 +316,26 @@ export function useChatSessions(params) {
             cancelled = true;
         };
     }, [origin, refs, setSession, setInput, setMessages]);
+    // The sole production create path delegates to the exported orchestration
+    // helper so its durable commit order is directly traceable and testable.
+    const createSessionAndPrimeTitleWatcherForHook = useCallback((options) => createSessionAndPrimeTitleWatcher({
+        origin,
+        sessionListRef,
+        setSessionList,
+        titleWatcher: titleWatcherRef.current,
+        refreshSessionList,
+        options,
+        setCreatingSession,
+        creatingRef: creatingSessionRef,
+    }), [origin, refreshSessionList]);
     const createSession = useCallback(async (options) => {
+        // Suppress concurrent create from any entry (sidebar / Landing / chip).
+        if (creatingSessionRef.current)
+            return null;
         const selectionVersion = ++sessionSelectionVersionRef.current;
         setError(null);
         try {
-            const res = await fetch(`${origin}/api/operator/v1/chat/sessions`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "x-loop-console-confirmation": confirmationToken(),
-                },
-                credentials: "include",
-                body: JSON.stringify(options ?? {}),
-            });
-            if (!res.ok) {
-                const body = (await res.json().catch(() => ({})));
-                throw new Error(body.error?.message ?? `HTTP ${res.status}`);
-            }
-            const body = (await res.json());
-            const created = {
-                sessionId: body.sessionId,
-                ...(body.model ? { model: body.model } : {}),
-            };
-            void refreshSessionList();
+            const created = await createSessionAndPrimeTitleWatcherForHook(options);
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return null;
             resetActiveProjection();
@@ -270,16 +350,18 @@ export function useChatSessions(params) {
         catch (e) {
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return null;
-            setError(e instanceof Error ? e.message : String(e));
+            const message = e instanceof Error ? e.message : String(e);
+            if (message !== "CREATE_SESSION_IN_FLIGHT") {
+                setError(message);
+            }
             return null;
         }
     }, [
-        origin,
         refs,
         setSession,
         setError,
         resetActiveProjection,
-        refreshSessionList,
+        createSessionAndPrimeTitleWatcherForHook,
     ]);
     // Phase-1: fork / in-session branch / mainline switch UI deferred; API routes remain.
     const compactSession = useCallback(async () => {
@@ -318,6 +400,9 @@ export function useChatSessions(params) {
             return;
         }
         await refreshSessionList();
+        if (patch.state === "archived") {
+            titleWatcherRef.current?.cancel(sessionId);
+        }
         if (patch.state === "archived" &&
             refs.sessionRef.current?.sessionId === sessionId) {
             sessionSelectionVersionRef.current += 1;
@@ -329,11 +414,13 @@ export function useChatSessions(params) {
     };
     return {
         sessionList,
+        creatingSession,
         activateSession,
         refreshSessionList,
         deleteSession,
         createSession,
         updateSession,
+        watchSessionTitle,
         compactSession,
     };
 }

package/dist/worker/console/static-src/operator-chat/useChatStream.js CHANGED Viewed

@@ -14,7 +14,7 @@ function sleepBriefly() {
 /** One GET /events stream owns all Chat events. Sending a prompt creates a
  * detached Turn resource only; it never opens a second inline SSE consumer. */
 export function useChatStream(params) {
-    const { origin, refs, session, thread, composer, setError, setAutoScroll, recoveryVersion = 0, } = params;
+    const { origin, refs, session, thread, composer, setError, setAutoScroll, recoveryVersion = 0, watchSessionTitle, } = params;
     const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, } = thread;
     const { setInput, setPendingImages } = composer;
     /** Follow one session's event stream until it is explicitly aborted. The
@@ -185,6 +185,10 @@ export function useChatStream(params) {
             const body = (await res.json().catch(() => ({})));
             if (!res.ok || !body.turnId)
                 throw new Error(body.error?.message ?? `HTTP ${res.status}`);
+            // A successful accepted turn is the browser-side authorization to
+            // watch this session's late automatic title. The watcher is independent
+            // of the active-session generation, so switching away does not lose it.
+            watchSessionTitle(activeSession.sessionId);
             // Slow POST returns cannot alter a later selection/turn (M5.2).
             if (refs.sessionRef.current?.sessionId !== activeSession.sessionId ||
                 refs.sessionGenerationRef.current !== generation)
@@ -221,6 +225,7 @@ export function useChatStream(params) {
         setStreaming,
         setStreamingAssistantId,
         setPendingImages,
+        watchSessionTitle,
     ]);
     const handleStop = useCallback(() => {
         refs.abortRef.current?.abort();

package/dist/worker/console/static-src/operator-chat/useOverlayFocus.js ADDED Viewed

@@ -0,0 +1,84 @@
+import { useEffect, useRef } from "react";
+const FOCUSABLE = 'a[href],button:not([disabled]),textarea:not([disabled]),input:not([disabled]),select:not([disabled]),[tabindex]:not([tabindex="-1"])';
+/**
+ * Trap focus inside an open overlay root; restore focus to the prior trigger
+ * on close. Escape is handled by the caller (or optional onEscape).
+ *
+ * Restore contract: open true→false and unmount-while-open share a single
+ * restore path (cleanup). A wasOpen flag prevents double restore when the
+ * transition effect re-runs after cleanup.
+ */
+export function useOverlayFocus(options) {
+    const { open, containerRef, triggerRef, onEscape } = options;
+    const previousFocusRef = useRef(null);
+    const wasOpenRef = useRef(false);
+    useEffect(() => {
+        if (open) {
+            if (!wasOpenRef.current) {
+                const active = document.activeElement;
+                previousFocusRef.current =
+                    triggerRef?.current ??
+                        (active instanceof HTMLElement ? active : null);
+                const root = containerRef.current;
+                if (root) {
+                    const first = root.querySelector(FOCUSABLE);
+                    (first ?? root).focus?.();
+                }
+                wasOpenRef.current = true;
+            }
+            // Single restore path for true→false (cleanup before next effect)
+            // and for unmount-while-open (cleanup on unmount).
+            return () => {
+                if (!wasOpenRef.current)
+                    return;
+                const restore = triggerRef?.current ?? previousFocusRef.current;
+                if (restore && document.contains(restore)) {
+                    restore.focus();
+                }
+                previousFocusRef.current = null;
+                wasOpenRef.current = false;
+            };
+        }
+        // open === false: ensure flag is clear; restore already handled by
+        // the previous open-effect cleanup when transitioning true→false.
+        wasOpenRef.current = false;
+        return undefined;
+    }, [open, containerRef, triggerRef]);
+    useEffect(() => {
+        if (!open)
+            return;
+        const root = containerRef.current;
+        if (!root)
+            return;
+        const onKeyDown = (event) => {
+            if (event.key === "Escape") {
+                event.preventDefault();
+                onEscape?.();
+                return;
+            }
+            if (event.key !== "Tab")
+                return;
+            const nodes = Array.from(root.querySelectorAll(FOCUSABLE)).filter((el) => !el.hasAttribute("disabled") && el.tabIndex !== -1);
+            if (nodes.length === 0) {
+                event.preventDefault();
+                root.focus?.();
+                return;
+            }
+            const first = nodes[0];
+            const last = nodes[nodes.length - 1];
+            const active = document.activeElement;
+            if (event.shiftKey) {
+                if (active === first || !root.contains(active)) {
+                    event.preventDefault();
+                    last.focus();
+                }
+            }
+            else if (active === last || !root.contains(active)) {
+                event.preventDefault();
+                first.focus();
+            }
+        };
+        document.addEventListener("keydown", onKeyDown);
+        return () => document.removeEventListener("keydown", onKeyDown);
+    }, [open, containerRef, onEscape]);
+}

package/dist/worker/console/static-src/operator-chat/useWorkspaceLayout.js ADDED Viewed

@@ -0,0 +1,58 @@
+import { useEffect, useState } from "react";
+import { resolveWorkspaceLayoutMode, } from "./workspace-layout-mode.js";
+import { resolveLandingDensity, } from "./landing-density.js";
+const INITIAL = {
+    mode: "comfortable",
+    width: 1600,
+    landingDensity: "comfortable",
+    emptyHeight: 720,
+};
+/**
+ * Single ResizeObserver adapter for `.oc-workspace` width and optional empty
+ * messages height. Mode is never derived from UA or window.innerWidth alone.
+ */
+export function useWorkspaceLayout(workspaceRef, emptyMessagesRef) {
+    const [snapshot, setSnapshot] = useState(INITIAL);
+    useEffect(() => {
+        const workspace = workspaceRef.current;
+        if (!workspace || typeof ResizeObserver === "undefined") {
+            return;
+        }
+        const measure = () => {
+            const width = workspace.getBoundingClientRect().width;
+            const emptyEl = emptyMessagesRef?.current ?? null;
+            const emptyHeight = emptyEl
+                ? emptyEl.getBoundingClientRect().height
+                : 720;
+            setSnapshot({
+                mode: resolveWorkspaceLayoutMode(width),
+                width,
+                landingDensity: resolveLandingDensity(emptyHeight),
+                emptyHeight,
+            });
+        };
+        measure();
+        const ro = new ResizeObserver(() => measure());
+        ro.observe(workspace);
+        // Poll briefly for empty-messages node mount without depending on its
+        // identity as a React effect dependency.
+        let emptyObserved = null;
+        const tryObserveEmpty = () => {
+            const emptyEl = emptyMessagesRef?.current ?? null;
+            if (emptyEl && emptyEl !== emptyObserved) {
+                if (emptyObserved)
+                    ro.unobserve(emptyObserved);
+                ro.observe(emptyEl);
+                emptyObserved = emptyEl;
+                measure();
+            }
+        };
+        tryObserveEmpty();
+        const interval = window.setInterval(tryObserveEmpty, 250);
+        return () => {
+            window.clearInterval(interval);
+            ro.disconnect();
+        };
+    }, [workspaceRef, emptyMessagesRef]);
+    return snapshot;
+}