clay-server 5.3.0-beta.4 → 5.3.0-beta.6

package/lib/public/modules/tool-pane-legacy.js

@@ -0,0 +1,60 @@
+import { ensureArrangeTrigger } from './split-view-presentation-renderer.js';
+import { pairBase } from './view-pair-presentation.js';
+import { activeSavedView } from './view-workspace-state.js';
+// Legacy Driver/Worker pairs use the same display-only window geometry.
+import { store } from './store.js';
+import { rectangles } from './split-view-layout-client.js';
+import { toolPaneLayoutTree, paintToolPaneWindows, bindWorkspaceDivider, dockedToolPanes } from './tool-pane-layout.js';
+
+export function clearToolPaneWindows() {
+  document.querySelectorAll('.tool-pane-window').forEach(function (panel) {
+    panel.classList.remove('tool-pane-window'); delete panel.dataset.toolWindowId;
+    ['left', 'top', 'width', 'height', 'right', 'maxHeight'].forEach(function (field) { panel.style[field] = ''; });
+  });
+  var main = document.getElementById('main-panels');
+  if (main) main.classList.remove('has-tool-pane-windows');
+  store.set({ toolPaneWindowGeometry: null });
+}
+export function paintLegacyToolPanes(host) {
+  var split = store.get('splitPanes');
+  if (!host || !split || !split.panes || split.panes.length < 2) return false;
+  var panes = Array.from(host.querySelectorAll(':scope > .split-pane:not(.split-pane-cached)'));
+  var ids = panes.map(function (pane) {
+    var frame = pane.querySelector('.split-pane-frame');
+    if (frame && !frame.dataset.toolPaneGeometryReadyBound) {
+      frame.dataset.toolPaneGeometryReadyBound = 'true';
+      frame.addEventListener('clay-pane-ready', function () { queueMicrotask(function () { if (frame.isConnected) paintLegacyToolPanes(host); }); });
+    }
+    return frame && frame.dataset.sessionOriginId;
+  });
+  if (ids.length < split.panes.length || ids.some(function (id) { return !id; }) || new Set(ids).size !== ids.length) return false;
+  var base = { id: ids[0] };
+  ids.slice(1).forEach(function (id) { base = { axis: 'horizontal', ratio: .5, left: base, right: { id: id } }; });
+  var view = activeSavedView() || { id: 'legacy-' + (split.groupId || ids.join('-')), activeSessionOriginId: ids[0] };
+  if (view.workspace && view.workspace.linkedPair) base = pairBase(view.workspace.linkedPair, view.tree);
+  host.classList.add('split-view-canvas'); host.dataset.positioned = 'true'; delete host.dataset.singlePane;
+  var style = getComputedStyle(host), left = parseFloat(style.paddingLeft) || 0, top = parseFloat(style.paddingTop) || 0;
+  var width = host.clientWidth - left - (parseFloat(style.paddingRight) || 0), height = host.clientHeight - top - (parseFloat(style.paddingBottom) || 0);
+  var tree = toolPaneLayoutTree(view, base), geometry = rectangles(tree, Math.max(0, width), Math.max(0, height), 7);
+  paintToolPaneWindows(host, view, base, tree, geometry, { left: left, top: top });
+  var focused = store.get('projectSplitViewFocusedOrigin');
+  panes.forEach(function (pane, index) {
+    var rect = geometry.panes[ids[index]];
+    pane.hidden = !!focused && ids[index] !== focused; pane.style.display = pane.hidden ? 'none' : '';
+    if (focused === ids[index]) rect = { x: 0, y: 0, width: width, height: height };
+    if (!rect) return;
+    if (view.sessions && view.sessions.some(function (s) { return s.sessionOriginId === ids[index]; })) ensureArrangeTrigger(pane.querySelector('.split-pane-header'));
+    pane.style.left = left + rect.x + 'px'; pane.style.top = top + rect.y + 'px';
+    pane.style.width = rect.width + 'px'; pane.style.height = rect.height + 'px';
+  });
+  host.querySelectorAll(':scope > .split-view-divider').forEach(function (divider) { divider.remove(); });
+  (focused ? [] : geometry.dividers).forEach(function (entry) {
+    var divider = document.createElement('div'); divider.className = 'split-view-divider'; divider.dataset.axis = entry.axis;
+    divider.setAttribute('role', 'separator'); divider.setAttribute('tabindex', '0'); divider.setAttribute('aria-label', 'Resize pane windows');
+    divider.setAttribute('aria-orientation', entry.axis === 'horizontal' ? 'vertical' : 'horizontal');
+    divider.style.left = left + entry.rect.x + 'px'; divider.style.top = top + entry.rect.y + 'px';
+    divider.style.width = entry.rect.width + 'px'; divider.style.height = entry.rect.height + 'px';
+    bindWorkspaceDivider(divider, entry, tree); host.appendChild(divider);
+  });
+  return true;
+}

package/lib/public/modules/tool-pane-tree.js

@@ -0,0 +1,51 @@
+import { WORKBENCH_PANELS } from './workbench-panels.js';
+import { listIds, remove, pairTree, swap } from './split-view-layout-client.js';
+
+export var TOOL_PANES = { terminal: { id: 'terminal-container', label: 'Terminal', icon: 'terminal' },
+  browser: { id: 'shared-browser-panel', label: 'Browser', icon: 'globe' }, 'file-viewer': { id: 'file-viewer', label: 'Files', icon: 'file-text' } };
+Object.assign(TOOL_PANES, WORKBENCH_PANELS);
+export function toolWindowId(name) { return 'tool-' + name; }
+export function isToolWindow(id) { return /^tool-file-[A-Za-z0-9_-]+$/.test(id) || Object.keys(TOOL_PANES).some(function (name) { return toolWindowId(name) === id; }); }
+export function insertWindow(tree, source, target, side, ratio) {
+  if (source === target) return tree;
+  if (side === 'center' && isToolWindow(source) && isToolWindow(target)) return swap(tree, source, target).tree;
+  side = side === 'center' ? 'right' : side;
+  var base = remove(tree, source), found = false;
+  function walk(node) {
+    if (!node) return node;
+    if (node.id) {
+      if (node.id !== target) return node;
+      found = true;
+      var result = pairTree(target, source, side);
+      result.ratio = ratio || .5;
+      return result;
+    }
+    return { axis: node.axis, ratio: node.ratio, left: walk(node.left), right: walk(node.right) };
+  }
+  var next = walk(base);
+  return found && listIds(next).length <= 24 ? next : tree;
+}
+function stripUnknown(tree, allowed) {
+  var result = tree;
+  listIds(tree).forEach(function (id) { if (allowed.indexOf(id) < 0) result = remove(result, id); });
+  return result;
+}
+function placements(tree, output) {
+  if (!tree || tree.id) return;
+  var left = listIds(tree.left), right = listIds(tree.right);
+  if (tree.left.id && isToolWindow(tree.left.id)) output.push({ id: tree.left.id, target: right[0], side: tree.axis === 'horizontal' ? 'left' : 'top', ratio: tree.ratio });
+  else if (tree.right.id && isToolWindow(tree.right.id)) output.push({ id: tree.right.id, target: left[0], side: tree.axis === 'horizontal' ? 'right' : 'bottom', ratio: tree.ratio });
+  placements(tree.left, output); placements(tree.right, output);
+}
+export function workspaceWindowTree(base, saved, owners) {
+  var sessions = listIds(base), tools = owners.map(toolWindowId), allowed = sessions.concat(tools), tree = base;
+  if (saved && saved.tree && JSON.stringify(saved.base) === JSON.stringify(base)) tree = stripUnknown(saved.tree, allowed);
+  else if (saved && saved.tree) {
+    var attached = []; placements(saved.tree, attached);
+    attached.reverse().forEach(function (item) { if (tools.indexOf(item.id) >= 0 && listIds(tree).indexOf(item.target) >= 0) tree = insertWindow(tree, item.id, item.target, item.side, item.ratio); });
+  }
+  tools.forEach(function (id) {
+    if (listIds(tree).indexOf(id) < 0) tree = tree ? { axis: 'horizontal', ratio: .66, left: tree, right: { id: id } } : { id: id };
+  });
+  return tree;
+}

package/lib/public/modules/view-legacy-coordinates.js

@@ -0,0 +1,16 @@
+import { copy, mapWorkspaceTree, paneOwner } from './view-workspace-state.js';
+import { listIds } from './split-view-layout-client.js';
+// Coordinates never create resources. Resolve the old singleton Files slot only
+// after a real file instance exists; leave other delayed slots intact.
+export function boundLegacyCoordinates(record, value) {
+  var next = copy(record), mapping = {};
+  listIds(record.tree).forEach(function (id) { mapping[id] = id; });
+  var files = value.panes.filter(function (pane) { return pane.kind === 'file' && pane.open && pane.placement === 'docked'; });
+  if (files.length === 1) mapping['tool-file-viewer'] = 'tool-' + paneOwner(files[0]);
+  next.tree = mapWorkspaceTree(next.tree, mapping);
+  return next;
+}
+export function legacyCoordinatesReady(record, value) {
+  var ids = value.panes.filter(function (p) { return p.open && p.placement === 'docked'; }).map(function (p) { return 'tool-' + paneOwner(p); });
+  return listIds(boundLegacyCoordinates(record, value).tree).filter(function (id) { return id.indexOf('tool-') === 0; }).every(function (id) { return ids.indexOf(id) >= 0; });
+}

package/lib/public/modules/view-mutations.js

@@ -0,0 +1,24 @@
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+import { showToast } from './utils.js';
+import { prepareViewMutation } from './view-workspace-state.js';
+function contextKey(state) { return [state.currentSlug || '', state.currentProjectOwnerId || '', state.myUserId || '', state.projectSplitViewSocketGeneration || 0].join('|'); }
+function projectReady(state) { return getWs() !== state.splitIdentityBlockedSocket && !state.paneMode && !state.dmMode && state.connected && state.authIdentityLoaded && state.currentSlug === state.activeProjectSlug && state.currentSlug === state.sessionListProjectSlug; }
+function sendMessage(message) { var ws = getWs(); if (!ws || ws.readyState !== 1 || !projectReady(store.snap())) return false; try { ws.send(JSON.stringify(message)); return true; } catch (error) { return false; } }
+export function mutation(type, body, meta) {
+  var state = store.snap();
+  if (!projectReady(state) || !state.projectSplitViewHydrated || state.projectSplitViewError || state.projectSplitViewPending) return false;
+  var requestId = "split-view-" + Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 10);
+  var ws = getWs();
+  var message = prepareViewMutation(type, Object.assign({ type: type, requestId: requestId, expectedRevision: state.projectSplitViewRevision }, body || {}));
+  if (!message) return false;
+  var pending = { requestId: requestId, type: type, socket: ws, contextKey: contextKey(state), expectedRevision: state.projectSplitViewRevision, meta: meta || null,
+    awaitingBroadcast: false, resultRevision: null };
+  store.set({ projectSplitViewPending: pending, projectSplitViewError: "" });
+  if (!sendMessage(message)) {
+    store.set({ projectSplitViewPending: null, projectSplitViewError: "Split view change could not be sent. Refresh before trying again." });
+    showToast("Split view change could not be sent. Refresh before trying again.", "error");
+    return false;
+  }
+  return true;
+}

package/lib/public/modules/view-pair-presentation.js

@@ -0,0 +1,74 @@
+// Linked Workers are a read-only presentation of the existing pair registry.
+// They never enter the saved View's ordinary session membership.
+import { showToast } from './utils.js';
+import { store } from './store.js';
+import { getCachedSessions } from './sidebar-sessions.js';
+import { splitGroupRoles } from './split-group-helpers.js';
+import { splitPaneForSession } from './split-pane-reconciler.js';
+import { mutation } from './view-mutations.js';
+import { activeSavedView, copy, displayTree, mapWorkspaceTree } from './view-workspace-state.js';
+
+export function currentViewPair() {
+  var state = store.snap(), split = state.splitPanes;
+  if (!split || !state.projectSplitViewHydrated || state.paneMode || !state.connected || !state.authIdentityLoaded ||
+      state.currentSlug !== state.sessionListProjectSlug || state.currentSlug !== state.activeProjectSlug) return null;
+  var group = (state.splitGroups || []).find(function (item) { return item.id === split.groupId; }), roles = splitGroupRoles(group);
+  if (!roles || roles.orderedIds.length > 8 || split.panes.length !== roles.orderedIds.length || split.panes.some(function (pane) { return pane.slug !== state.currentSlug || roles.orderedIds.indexOf(pane.sessionId) < 0; })) return null;
+  var sessions = getCachedSessions(), driver = sessions.find(function (s) { return s.id === roles.driverId && s.sessionRole !== 'worker' && (s.ownerId || null) === (state.myUserId || null); });
+  var workers = roles.workerIds.map(function (id) { return sessions.find(function (s) { return s.id === id && s.sessionRole === 'worker' && s.parentSessionId === roles.driverId && s.parentAvailable && (s.ownerId || null) === (state.myUserId || null); }); });
+  if (!driver || !driver.sessionOriginId || workers.some(function (s) { return !s || !s.sessionOriginId; })) return null;
+  return { groupId: group.id, driverOriginId: driver.sessionOriginId, workerOrigins: workers.map(function (s) { return s.sessionOriginId; }) };
+}
+export function pairDisplayTree(value) { return value.linkedPair ? value.linkedPair.tree : displayTree(value); }
+export function pairBase(pair, base) {
+  var tree = { id: pair.driverOriginId };
+  pair.workerOrigins.forEach(function (origin) { tree = { axis: 'horizontal', ratio: .5, left: tree, right: { id: origin } }; });
+  function expand(node) { if (!node) return tree; if (node.id) return node.id === pair.driverOriginId ? tree : node; return { axis: node.axis, ratio: node.ratio, left: expand(node.left), right: expand(node.right) }; }
+  return base ? expand(base) : tree;
+}
+export function syncPairView() {
+  var pair = currentViewPair(); if (!pair) return false;
+  var state = store.snap(), view = activeSavedView();
+  if (!view || !view.sessions.some(function (s) { return s.sessionOriginId === pair.driverOriginId; })) {
+    view = (state.projectSplitViews || []).find(function (v) { return v.sessions.some(function (s) { return s.sessionOriginId === pair.driverOriginId; }); });
+    if (view) { store.set({ projectSplitViewActiveId: view.id }); return true; }
+    if (!state.projectSplitViewPending && !state.projectSplitViewError) mutation('project_split_view_create', {
+      name: 'View', sessionOrigins: [pair.driverOriginId], tree: { id: pair.driverOriginId }, layout: 'balanced', activeSessionOriginId: pair.driverOriginId
+    });
+    return true;
+  }
+  if (!view.workspace.linkedPair || view.workspace.linkedPair.groupId !== pair.groupId || JSON.stringify(view.workspace.linkedPair.workerOrigins) !== JSON.stringify(pair.workerOrigins)) {
+    if (state.projectSplitViewPending || state.projectSplitViewError) return true;
+    if (view.sessions.length + pair.workerOrigins.length > 8) return false;
+    var value = copy(view.workspace), mapping = {};
+    value.panes.forEach(function (p) { mapping[p.kind === 'session' ? p.resource.originId : 'tool-' + (p.kind === 'workbench' ? p.resource.name : p.kind === 'file' ? 'file-' + p.instanceId : p.kind)] = p.kind === 'session' ? p.resource.originId : 'tool-' + (p.kind === 'workbench' ? p.resource.name : p.kind === 'file' ? 'file-' + p.instanceId : p.kind); });
+    function expand(node) { if (!node) return null; if (node.id) return node.id === pair.driverOriginId ? pairBase(pair) : node; return { axis: node.axis, ratio: node.ratio, left: expand(node.left), right: expand(node.right) }; }
+    value.linkedPair = Object.assign({}, pair, { tree: expand(mapWorkspaceTree(displayTree(value), mapping)) });
+    mutation('project_split_view_update', { id: view.id, sessionOrigins: view.sessions.map(function (s) { return s.sessionOriginId; }), tree: view.tree, layout: view.layout, activeSessionOriginId: pair.driverOriginId, workspace: value });
+  }
+  return true;
+}
+export function restoreViewPair(view) {
+  var pair = view && view.workspace.linkedPair;
+  if (!pair || store.get('splitPanes')) return false;
+  var group = (store.get('splitGroups') || []).find(function (item) { return item.id === pair.groupId; }), roles = splitGroupRoles(group), sessions = getCachedSessions();
+  if (!roles || roles.orderedIds.length > 8) return false;
+  var members = roles.orderedIds.map(function (id) { return sessions.find(function (s) { return s.id === id; }); });
+  if (members.some(function (s, index) { return !s || (s.ownerId || null) !== (store.get('myUserId') || null) || index > 0 && (s.sessionRole !== 'worker' || !s.parentAvailable || s.parentSessionId !== roles.driverId); }) || members[0].sessionOriginId !== pair.driverOriginId || JSON.stringify(members.slice(1).map(function (s) { return s.sessionOriginId; })) !== JSON.stringify(pair.workerOrigins)) return false;
+  store.set({ splitPanes: { groupId: group.id, panes: roles.orderedIds.map(function (id) { return splitPaneForSession(id, store.get('currentSlug'), sessions); }) } });
+  return true;
+}
+
+export function pairPresentationPanes(panes) {
+  var view = activeSavedView();
+  return !view ? panes : panes.concat(view.sessions.filter(function (s) { return !panes.some(function (p) { return p.sessionId === s.id; }); }).map(function (s) { return splitPaneForSession(s.id, store.get('currentSlug'), getCachedSessions()); }));
+}
+
+export function pairViewCapacity(group) {
+  var roles = splitGroupRoles(group);
+  if (!roles) return true;
+  var view = (store.get('projectSplitViews') || []).find(function (v) { return v.sessions.some(function (s) { return s.id === roles.driverId; }); });
+  if ((view ? view.sessions.length : 1) + roles.workerIds.length <= 8) return true;
+  showToast('This View has no room for the linked Worker panes. Move a session to another View first.', 'warn');
+  return false;
+}

package/lib/public/modules/view-pair-validation.js

@@ -0,0 +1,12 @@
+// Pair presentation is UI state, never Worker membership or execution authority.
+export function validLinkedPair(pair, value, view) {
+  if (!pair || Object.keys(pair).sort().join(',') !== 'driverOriginId,groupId,tree,workerOrigins' || typeof pair.groupId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(pair.groupId) ||
+      !view.sessionRefs.some(function (r) { return r.originId === pair.driverOriginId; }) || !Array.isArray(pair.workerOrigins) || !pair.workerOrigins.length || pair.workerOrigins.length + view.sessionRefs.length > 8 || new Set(pair.workerOrigins).size !== pair.workerOrigins.length || pair.workerOrigins.indexOf(pair.driverOriginId) >= 0 || pair.workerOrigins.some(function (id) { return typeof id !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(id); })) return false;
+  var mapping = {}, expected = pair.workerOrigins.slice();
+  value.panes.forEach(function (p) { if (!p.open || p.placement !== 'docked') return; var id = p.kind === 'session' ? p.resource.originId : 'tool-' + (p.kind === 'workbench' ? p.resource.name : p.kind === 'file' ? 'file-' + p.instanceId : p.kind); mapping[id] = p.instanceId; expected.push(id); });
+  var count = 0, seen = [];
+  function walk(n) { if (!n || ++count > 47) return false; if (Object.keys(n).join(',') === 'id') { seen.push(n.id); return expected.indexOf(n.id) >= 0; } return Object.keys(n).sort().join(',') === 'axis,left,ratio,right' && ['horizontal','vertical'].indexOf(n.axis) >= 0 && Number.isFinite(n.ratio) && n.ratio >= .05 && n.ratio <= .95 && walk(n.left) && walk(n.right); }
+  function project(n) { if (!n) return null; if (n.id) return mapping[n.id] ? { id: mapping[n.id] } : null; var l = project(n.left), r = project(n.right); return !l ? r : !r ? l : { axis:n.axis,ratio:n.ratio,left:l,right:r }; }
+  function same(a,b) { return !a || !b ? a === b : a.id || b.id ? a.id === b.id : a.axis === b.axis && a.ratio === b.ratio && same(a.left,b.left) && same(a.right,b.right); }
+  return expected.length <= 24 && walk(pair.tree) && seen.length === expected.length && new Set(seen).size === seen.length && same(project(pair.tree),value.tree);
+}

package/lib/public/modules/view-presentation-state.js

@@ -0,0 +1,37 @@
+import { WORKBENCH_PANELS, setWorkbenchExpanded } from './workbench-panels.js';
+import { store } from './store.js';
+import { activeSavedView, workspaceKey, paneOwner, workspaceChanged } from './view-workspace-state.js';
+
+export function presentation(value) { return value.presentation || { focusedSessionOriginId: null, expandedPaneId: null }; }
+export function capturePresentation(value) {
+  var focus = store.get('projectSplitViewFocusedOrigin') || null;
+  var owner = store.get('savedViewExpandedOwner');
+  var pane = value.panes.find(function (p) { return p.open && p.kind !== 'session' && paneOwner(p) === owner; });
+  value.presentation = { focusedSessionOriginId: value.panes.some(function (p) { return p.kind === 'session' && p.resource.originId === focus; }) ? focus : null, expandedPaneId: pane ? pane.instanceId : null };
+}
+export function recordToolExpansion(owner, enabled) {
+  if (store.get('savedWorkspaceApplying') || !enabled && store.get('savedViewExpandedOwner') !== owner) return;
+  store.set({ savedViewExpandedOwner: enabled ? owner : null });
+  workspaceChanged();
+}
+export async function restoreViewPresentation(view, key) {
+  var apis = await Promise.all([import('./terminal.js'), import('./shared-browser.js'), import('./file-pane-instances.js'), import('./split-view-presentations.js')]);
+  var current = activeSavedView();
+  if (!store.get('connected') || store.get('savedWorkspaceLeaving') || workspaceKey(current) !== key || current.revision !== view.revision) return false;
+  var run = store.get('savedWorkspaceRuntime');
+  if (run && run.key === key) run.presentationApplied = true;
+  var state = presentation(view.workspace), pane = view.workspace.panes.find(function (p) { return p.instanceId === state.expandedPaneId && p.open; });
+  store.set({ savedWorkspaceApplying: true });
+  try {
+    store.set({ projectSplitViewFocusedOrigin: state.focusedSessionOriginId, savedViewExpandedOwner: pane ? paneOwner(pane) : null });
+    apis[0].setTerminalExpanded(!!pane && pane.kind === 'terminal');
+    apis[1].setBrowserExpanded(!!pane && pane.kind === 'browser');
+    Object.keys(apis[2].filePaneStates()).forEach(function (id) {
+      if (!apis[2].filePaneState(id)) return;
+      apis[2].updateFilePaneState(id, { expanded: !!pane && pane.instanceId === id }); apis[2].repaintFilePane(id);
+    });
+    Object.keys(WORKBENCH_PANELS).forEach(function (name) { setWorkbenchExpanded(name, !!pane && pane.kind === 'workbench' && pane.resource.name === name); });
+    apis[3].renderPresentationSplitView();
+  } finally { store.set({ savedWorkspaceApplying: false }); }
+  return true;
+}

package/lib/public/modules/view-workspace-controller.js

@@ -0,0 +1,210 @@
+import { WORKBENCH_PANELS } from './workbench-panels.js';
+import { capturePresentation, restoreViewPresentation } from './view-presentation-state.js';
+import { boundLegacyCoordinates, legacyCoordinatesReady } from './view-legacy-coordinates.js';
+import { currentViewPair, pairBase, pairDisplayTree } from './view-pair-presentation.js';
+import { filePaneStates, mountFilePane, resetFilePanes } from './file-pane-instances.js';
+import { listIds } from './split-view-layout-client.js';
+import { store } from './store.js';
+import { mutation } from './view-mutations.js';
+import { activeSavedView, workspaceKey, copy, paneOwner, freshInstance, replacePaneIdentity, displayTree, fromDisplayTree, sessionTree } from './view-workspace-state.js';
+import { workspaceWindowTree } from './tool-pane-tree.js';
+
+function current(key) { return !store.get('savedWorkspaceLeaving') && store.get('connected') && store.get('projectSplitViewHydrated') && workspaceKey(activeSavedView()) === key; }
+function runtime() { return store.get('savedWorkspaceRuntime'); }
+function applying(fn) { store.set({ savedWorkspaceApplying: true }); try { return fn(); } finally { store.set({ savedWorkspaceApplying: false }); } }
+function descriptor(name) {
+  if (name === 'terminal') return store.get('savedViewTerminalResource');
+  if (name === 'browser') {
+    var browser = store.get('sharedBrowser');
+    return browser && store.get('sessionOriginId') && { id: browser.id, runtimeId: store.get('controlRuntimeId'), sessionOriginId: store.get('sessionOriginId') };
+  }
+  var file = store.get('clayControlFileView');
+  return file && file.projectSlug === store.get('currentSlug') && { path: file.path, mode: 'follow', rendered: true };
+}
+function capture() {
+  var view = activeSavedView(), run = runtime();
+  if (!view || !run || run.restoring || !current(run.key) || store.get('paneMode') || store.get('savedWorkspaceApplying')) return;
+  var value = copy(run.desired || run.inflight || view.workspace), docked = store.get('rightWorkbenchDockedOwners') || [], owner = store.get('rightWorkbenchOwner');
+  ['terminal', 'browser'].concat(Object.keys(WORKBENCH_PANELS)).forEach(function (name) {
+    var pane = value.panes.find(function (item) { return paneOwner(item) === name; });
+    var open = owner === name || docked.indexOf(name) >= 0;
+    if (!open && !run.restored[name] && !run.cancelled[name]) return;
+    var resource = WORKBENCH_PANELS[name] ? { name: name } : descriptor(name);
+    if (!pane && open && resource) { pane = { instanceId: freshInstance(), kind: WORKBENCH_PANELS[name] ? 'workbench' : name, open: true, placement: 'overlay', resource: resource }; value.panes.push(pane); }
+    if (!pane) return;
+    if (open) run.restored[name] = true;
+    if (open && run.cancelled[name]) { run.cancelled[name] = false; run.unavailable[name] = false; run.restored[name] = true; }
+    if (!open) run.cancelled[name] = true;
+    pane.open = open; pane.placement = open && docked.indexOf(name) >= 0 ? 'docked' : 'overlay';
+    if (open && resource && !run.unavailable[name]) {
+      if (pane.kind === 'file') resource.mode = pane.resource.mode;
+      if (pane.kind !== 'file' && JSON.stringify(pane.resource) !== JSON.stringify(resource)) replacePaneIdentity(value, pane);
+      pane.resource = resource;
+    }
+  });
+  var files = filePaneStates();
+  Object.keys(files).forEach(function (id) {
+    var file = files[id], name = 'file-' + id;
+    var pane = value.panes.find(function (item) { return item.instanceId === id; });
+    if (!pane && file.open) { pane = { instanceId: id, kind: 'file', resource: file.resource }; value.panes.push(pane); }
+    if (!pane) return;
+    pane.open = file.open; pane.resource = Object.assign({}, file.resource);
+    pane.placement = docked.indexOf(name) >= 0 ? 'docked' : 'overlay';
+    run.restored[name] = true; run.cancelled[name] = !file.open;
+  });
+  // Closed file panes have no running resource and need not consume the limit.
+  value.panes = value.panes.filter(function (pane) { return pane.kind !== 'file' || pane.open; });
+  var tools = value.panes.filter(function (pane) { return pane.kind !== 'session' && pane.open && pane.placement === 'docked'; }).map(paneOwner);
+  var legacy = store.get('savedWorkspaceLegacyLayout');
+  var base = value.linkedPair ? pairBase(value.linkedPair, view.tree) : view.tree;
+  var tree = workspaceWindowTree(base, legacy && legacy.key === run.key ? boundLegacyCoordinates(legacy.record, value) : { base: base, tree: pairDisplayTree(value) }, tools);
+  if (value.linkedPair) value.linkedPair.tree = copy(tree);
+  value.tree = fromDisplayTree(value, tree);
+  var active = value.panes.find(function (pane) { return pane.open && paneOwner(pane) === owner; }) || value.panes.find(function (pane) { return pane.open && pane.instanceId === value.activePaneId; }) || value.panes.find(function (pane) { return pane.open; });
+  value.activePaneId = active ? active.instanceId : null;
+  if (run.presentationApplied) capturePresentation(value);
+  store.set({ savedWorkspaceRuntime: Object.assign({}, run, { desired: value, desiredBase: JSON.stringify(run.inflight || view.workspace) }) });
+  queue();
+}
+export function persistWorkspace(value) {
+  var view = activeSavedView(), run = runtime();
+  if (!view || !run || !current(run.key)) return false;
+  store.set({ savedWorkspaceLegacyLayout: null });
+  run.migrated = true;
+  store.set({ savedWorkspaceRuntime: Object.assign({}, run, { desired: copy(value), desiredBase: JSON.stringify(run.inflight || view.workspace) }) });
+  flush(); return true;
+}
+function flush() {
+  var view = activeSavedView(), run = runtime();
+  if (!view || !run || !current(run.key) || run.restoring || run.presentationApplying || !run.desired || store.get('projectSplitViewPending') || store.get('projectSplitViewError')) return;
+  if (view.workspace.panes.some(function(pane) { var name = paneOwner(pane); return pane.kind !== 'session' && pane.open && !run.restored[name] && !run.cancelled[name]; })) return;
+  if (run.desiredBase !== undefined && run.desiredBase !== JSON.stringify(view.workspace)) {
+    store.set({ savedWorkspaceRuntime: Object.assign({}, run, { desired: null, inflight: null }), projectSplitViewError: 'The saved workspace changed while this edit was pending. Reload before trying again.' }); return;
+  }
+  if (JSON.stringify(run.desired) === JSON.stringify(view.workspace) && store.get('projectSplitViewSavedActiveId') === view.id) { store.set({ savedWorkspaceRuntime: Object.assign({}, run, { desired: null }) }); return; }
+  var tree = sessionTree(run.desired), origins = view.sessions.map(function (session) { return session.sessionOriginId; });
+  var sent = run.desired;
+  store.set({ savedWorkspaceRuntime: Object.assign({}, run, { desired: null, inflight: copy(sent) }) });
+  if (!mutation('project_split_view_update', { id: view.id, sessionOrigins: origins, tree: tree, layout: view.layout,
+    activeSessionOriginId: view.activeSessionOriginId, workspace: sent })) store.set({ savedWorkspaceRuntime: Object.assign({}, runtime(), { desired: sent, inflight: null }) });
+}
+function restoreCurrent(view, run) {
+  if (!current(run.key)) return false;
+  if (activeSavedView().revision === view.revision) return true;
+  store.set({ savedWorkspaceRuntime: Object.assign({}, runtime(), { restoring: false }), projectSplitViewError: 'The View changed during restoration. Reload to restore its latest state.' });
+  return false;
+}
+async function restore(view, run) {
+  var workbench = await import('./right-workbench.js');
+  if (!restoreCurrent(view, run) || runtime() !== run) return;
+  store.set({ savedViewExpandedOwner: null });
+  applying(function () { resetFilePanes(); workbench.resetRightWorkbench(); });
+  for (var i = 0; i < view.workspace.panes.length; i++) {
+    var pane = view.workspace.panes[i], name = paneOwner(pane);
+    if (pane.kind === 'session' || !pane.open) continue;
+    var api = pane.kind === 'workbench' ? await WORKBENCH_PANELS[name].load() : await import(pane.kind === 'terminal' ? './terminal.js' : pane.kind === 'browser' ? './shared-browser.js' : './filebrowser.js');
+    if (!restoreCurrent(view, run) || !runtime() || runtime().key !== run.key) return;
+    if (runtime().cancelled[name]) continue;
+    var result = applying(function () {
+      if (pane.kind === 'workbench') {
+        api[WORKBENCH_PANELS[name].open]();
+        var panel = document.getElementById(WORKBENCH_PANELS[name].id);
+        return panel && !panel.classList.contains('hidden') ? 'restored' : 'unavailable';
+      }
+      if (pane.kind === 'terminal') return api.restoreExistingTerminal(pane.resource);
+      if (pane.kind === 'browser') return api.restoreExistingBrowser(pane.resource);
+      return mountFilePane(pane);
+    });
+    if (result === 'pending') continue;
+    run = runtime(); run.restored[name] = true; run.unavailable[name] = result === 'unavailable';
+    if (pane.placement === 'docked' && (pane.kind !== 'workbench' || result !== 'unavailable')) applying(function () { workbench.restoreWorkbenchDock(name); });
+  }
+  if (!current(run.key)) return;
+  store.set({ savedWorkspaceRuntime: Object.assign({}, runtime(), { restoring: false }) });
+  queue();
+}
+async function retryPending(view, run, name) {
+  var pane = view.workspace.panes.find(function (item) { return item.kind === name && item.open; });
+  var ready = store.get(name === 'terminal' ? 'savedViewTerminalListReady' : 'savedViewBrowserListReady');
+  if (!pane || run.restored[name] || run.cancelled[name] || !ready) return;
+  var api = await import(name === 'terminal' ? './terminal.js' : './shared-browser.js'), workbench = await import('./right-workbench.js');
+  if (!restoreCurrent(view, run) || runtime().cancelled[name] || runtime().restored[name]) return;
+  var result = applying(function () { return name === 'terminal' ? api.restoreExistingTerminal(pane.resource) : api.restoreExistingBrowser(pane.resource); });
+  if (result === 'pending') return;
+  runtime().restored[name] = true; runtime().unavailable[name] = result === 'unavailable';
+  if (pane.placement === 'docked') applying(function () { workbench.restoreWorkbenchDock(name); });
+  queue();
+}
+function migrateCoordinates(view, run) {
+  var preference = store.get('workbenchLayoutPreference');
+  if (run.migrated || !preference || !preference.ready || run.restoring || store.get('projectSplitViewPending')) return;
+  // Legacy coordinate records are read once; subsequent writes target the View.
+  if (!run.legacyEligible) { run.migrated = true; return; }
+  var pair = view.workspace.linkedPair;
+  var scopes = [view.id].concat(pair ? ['legacy-' + pair.groupId] : []).concat(view.sessions.length === 1 ? [view.sessions[0].sessionOriginId] : []), record;
+  scopes.some(function (scope) { record = (preference.layouts || {})[JSON.stringify([store.get('currentSlug'), store.get('currentProjectOwnerId') || null, scope])]; return !!record; });
+  if (!record) { run.migrated = true; return; }
+  // Coordinates alone cannot authorize opening tools or invent their bindings.
+  store.set({ savedWorkspaceLegacyLayout: { key: run.key, record: copy(record) } });
+  var owners = store.get('rightWorkbenchDockedOwners') || [];
+  var waiting = listIds(record.tree).filter(function (id) { return id.indexOf('tool-') === 0; });
+  if (waiting.indexOf('tool-file-viewer') >= 0 && !legacyCoordinatesReady(record, view.workspace)) return;
+  if (!waiting.filter(function (id) { return id !== 'tool-file-viewer'; }).every(function (id) { return owners.indexOf(id.slice(5)) >= 0 && (id === 'tool-terminal' ? descriptor('terminal') : id === 'tool-browser' ? descriptor('browser') : true); })) return;
+  run.migrated = true; capture();
+}
+function tick() {
+  if (store.get('paneMode') || store.get('splitPanes') && !currentViewPair()) return;
+  var view = activeSavedView();
+  if (store.get('splitPanes') && (!view || !view.workspace.linkedPair || store.get('projectSplitViewPending'))) return;
+  if (!view || !store.get('connected') || !store.get('projectSplitViewHydrated')) return;
+  if (view.sessions.length && (store.get('sessionOriginId') !== view.activeSessionOriginId || store.get('sessionActivatedProjectSlug') !== store.get('currentSlug'))) return;
+  var key = workspaceKey(view), run = runtime();
+  if (!run || run.key !== key) {
+    run = { key: key, appliedWorkspace: JSON.stringify(view.workspace), restoring: true, restored: {}, cancelled: {}, unavailable: {}, desired: null, migrated: false, legacyEligible: !view.workspace.panes.some(function (pane) { return pane.kind !== 'session'; }) };
+    store.set({ savedWorkspaceRuntime: run, savedWorkspaceLegacyLayout: null });
+    restore(view, run); return;
+  }
+  var savedWorkspace = JSON.stringify(view.workspace);
+  if (!run.restoring && run.appliedWorkspace && run.appliedWorkspace !== savedWorkspace && !store.get('projectSplitViewPending')) {
+    if (run.inflight && JSON.stringify(run.inflight) === savedWorkspace) run.appliedWorkspace = savedWorkspace;
+    else if (run.desired || run.inflight) {
+      store.set({ projectSplitViewError: 'The saved workspace changed while a local edit was pending. Reload before trying again.' }); return;
+    } else {
+      run = { key: key, appliedWorkspace: savedWorkspace, restoring: true, restored: {}, cancelled: {}, unavailable: {}, desired: null, migrated: true, legacyEligible: false };
+      store.set({ savedWorkspaceRuntime: run, savedWorkspaceLegacyLayout: null }); restore(view, run); return;
+    }
+  }
+  var legacy = store.get('savedWorkspaceLegacyLayout');
+  if (legacy && run.migrated && legacyCoordinatesReady(legacy.record, view.workspace)) store.set({ savedWorkspaceLegacyLayout: null });
+  if (!run.restoring) {
+    if (!run.presentationApplied && !run.presentationApplying && !view.workspace.panes.some(function (p) { return p.kind !== 'session' && p.open && !run.restored[paneOwner(p)] && !run.cancelled[paneOwner(p)]; })) {
+      run.presentationApplying = true;
+      restoreViewPresentation(view, run.key).then(function (applied) { if (runtime() && runtime().key === run.key && runtime().appliedWorkspace === run.appliedWorkspace) { runtime().presentationApplied = applied; runtime().presentationApplying = false; queue(); } });
+    }
+    retryPending(view, run, 'terminal'); retryPending(view, run, 'browser'); migrateCoordinates(view, run);
+    if (!store.get('projectSplitViewPending')) run.inflight = null;
+    if (!run.desired && store.get('projectSplitViewSavedActiveId') !== view.id) { run.desired = copy(view.workspace); run.desiredBase = JSON.stringify(view.workspace); }
+    flush();
+  }
+}
+function queue() {
+  if (store.get('savedWorkspaceTickQueued')) return;
+  store.set({ savedWorkspaceTickQueued: true });
+  queueMicrotask(function () { store.set({ savedWorkspaceTickQueued: false }); tick(); });
+}
+export function initSavedWorkspace() {
+  if (store.get('savedWorkspaceInitialized')) return;
+  store.set({ savedWorkspaceInitialized: true });
+  window.addEventListener('beforeunload', function () { store.set({ savedWorkspaceLeaving: true }); });
+  window.addEventListener('pagehide', function () { store.set({ savedWorkspaceLeaving: true }); });
+  document.addEventListener('clay-workspace-changed', capture);
+  store.subscribe(function (state, previous) {
+    if (previous.savedViewBrowserListReady && !state.savedViewBrowserListReady && runtime()) runtime().restored.browser = false;
+    if ((state.savedViewTerminalResource !== previous.savedViewTerminalResource && state.savedViewTerminalResource || state.clayControlFileView !== previous.clayControlFileView && state.clayControlFileView || state.sharedBrowser !== previous.sharedBrowser && state.sharedBrowser) && !state.savedWorkspaceApplying) capture();
+    if (state.splitPanes !== previous.splitPanes || state.rightWorkbenchDockedOwners !== previous.rightWorkbenchDockedOwners || state.savedViewTerminalResource !== previous.savedViewTerminalResource || state.projectSplitViews !== previous.projectSplitViews || state.projectSplitViewActiveId !== previous.projectSplitViewActiveId ||
+        state.projectSplitViewPending !== previous.projectSplitViewPending || state.connected !== previous.connected ||
+        state.controlRuntimeId !== previous.controlRuntimeId || state.sharedBrowsers !== previous.sharedBrowsers ||
+        state.sessionOriginId !== previous.sessionOriginId || state.sessionActivatedProjectSlug !== previous.sessionActivatedProjectSlug || state.savedViewBrowserListReady !== previous.savedViewBrowserListReady || state.savedViewTerminalListReady !== previous.savedViewTerminalListReady || state.workbenchLayoutPreference !== previous.workbenchLayoutPreference) queue();
+  });
+  queue();
+}

package/lib/public/modules/view-workspace-state.js

@@ -0,0 +1,103 @@
+import { store } from './store.js';
+import { listIds } from './split-view-layout-client.js';
+
+export function activeSavedView() { return (store.get('projectSplitViews') || []).find(function (view) { return view.id === store.get('projectSplitViewActiveId'); }) || null; }
+export function workspaceKey(view) {
+  return view && JSON.stringify([store.get('myUserId') || null, store.get('currentSlug'), store.get('currentProjectOwnerId'), store.get('projectSplitViewSocketGeneration'), view.id]);
+}
+export function copy(value) { return JSON.parse(JSON.stringify(value)); }
+export function mapWorkspaceTree(tree, mapping) {
+  if (!tree) return null;
+  if (tree.id) return mapping[tree.id] ? { id: mapping[tree.id] } : null;
+  var left = mapWorkspaceTree(tree.left, mapping), right = mapWorkspaceTree(tree.right, mapping);
+  return !left ? right : !right ? left : { axis: tree.axis, ratio: tree.ratio, left: left, right: right };
+}
+export function paneOwner(pane) { return pane.kind === 'workbench' ? pane.resource.name : pane.kind === 'file' ? 'file-' + pane.instanceId : pane.kind; }
+export function displayTree(value) {
+  var mapping = Object.create(null);
+  value.panes.forEach(function (pane) { mapping[pane.instanceId] = pane.kind === 'session' ? pane.resource.originId : 'tool-' + paneOwner(pane); });
+  return mapWorkspaceTree(value.tree, mapping);
+}
+export function sessionTree(value) {
+  var mapping = Object.create(null);
+  value.panes.forEach(function (pane) { if (pane.kind === 'session') mapping[pane.instanceId] = pane.resource.originId; });
+  return mapWorkspaceTree(value.tree, mapping);
+}
+export function fromDisplayTree(value, tree) {
+  var mapping = Object.create(null);
+  value.panes.forEach(function (pane) { mapping[pane.kind === 'session' ? pane.resource.originId : 'tool-' + paneOwner(pane)] = pane.instanceId; });
+  return mapWorkspaceTree(tree, mapping);
+}
+export function replacePaneIdentity(value, pane) {
+  var previous = pane.instanceId, next = freshInstance(), mapping = Object.create(null);
+  value.panes.forEach(function(item) { mapping[item.instanceId] = item.instanceId === previous ? next : item.instanceId; });
+  value.tree = mapWorkspaceTree(value.tree, mapping);
+  if (value.activePaneId === previous) value.activePaneId = next;
+  pane.instanceId = next;
+}
+export function freshInstance() { return 'pane-' + crypto.randomUUID(); }
+// Keep tool branches and their ratios while replacing the session layout.
+export function recomposeWorkspace(previous, tree, activeOrigin) {
+  var next = copy(previous || { version: 1, panes: [], tree: null, activePaneId: null }), origins = listIds(tree), oldTree = displayTree(next);
+  next.panes = next.panes.filter(function (pane) { return pane.kind !== 'session' || origins.indexOf(pane.resource.originId) >= 0; });
+  origins.forEach(function (origin) {
+    if (!next.panes.some(function (pane) { return pane.kind === 'session' && pane.resource.originId === origin; })) next.panes.push({ instanceId: freshInstance(), kind: 'session', open: true, placement: 'docked', resource: { originId: origin } });
+  });
+  if (next.linkedPair && (origins.indexOf(next.linkedPair.driverOriginId) < 0 || origins.length + next.linkedPair.workerOrigins.length > 8)) delete next.linkedPair;
+  var placements = [];
+  function collect(node) {
+    if (!node || node.id) return;
+    if (node.left.id && node.left.id.indexOf('tool-') === 0) placements.push({ id: node.left.id, target: listIds(node.right)[0], axis: node.axis, ratio: node.ratio, before: true });
+    else if (node.right.id && node.right.id.indexOf('tool-') === 0) placements.push({ id: node.right.id, target: listIds(node.left)[0], axis: node.axis, ratio: node.ratio, before: false });
+    collect(node.left); collect(node.right);
+  }
+  collect(oldTree);
+  var result = tree;
+  function insert(node, placement) {
+    if (!node) return node;
+    if (node.id) return node.id === placement.target ? { axis: placement.axis, ratio: placement.ratio,
+      left: placement.before ? { id: placement.id } : node, right: placement.before ? node : { id: placement.id } } : node;
+    return { axis: node.axis, ratio: node.ratio, left: insert(node.left, placement), right: insert(node.right, placement) };
+  }
+  placements.reverse().forEach(function (placement) { result = insert(result, placement); });
+  next.panes.filter(function (pane) { return pane.kind !== 'session' && pane.open && pane.placement === 'docked'; }).forEach(function (pane) {
+    var id = 'tool-' + paneOwner(pane);
+    if (listIds(result).indexOf(id) < 0) result = result ? { axis: 'horizontal', ratio: .66, left: result, right: { id: id } } : { id: id };
+  });
+  next.tree = fromDisplayTree(next, result);
+  var selected = next.panes.find(function (pane) { return pane.kind === 'session' && pane.resource.originId === activeOrigin; }) || next.panes.find(function (pane) { return pane.open; });
+  next.activePaneId = selected ? selected.instanceId : null;
+  if (next.presentation) {
+    if (origins.indexOf(next.presentation.focusedSessionOriginId) < 0) next.presentation.focusedSessionOriginId = null;
+    if (!next.panes.some(function (p) { return p.open && p.instanceId === next.presentation.expandedPaneId; })) next.presentation.expandedPaneId = null;
+  }
+  return next;
+}
+export function prepareViewMutation(type, message) {
+  var state = store.snap(), views = state.projectSplitViews || [];
+  var view = views.find(function (item) { return item.id === (message.id || message.sourceViewId); });
+  message.accountId = state.myUserId || null; message.projectSlug = state.currentSlug;
+  if (view) message.expectedViewRevision = view.revision;
+  if (type === 'project_split_view_create' || type === 'project_split_view_update') {
+    if (!message.workspace) message.workspace = recomposeWorkspace(view && view.workspace, message.tree, message.activeSessionOriginId);
+    message.tree = sessionTree(message.workspace);
+    message.active = true;
+  }
+  if (type === 'project_split_view_move') {
+    var target = views.find(function (item) { return item.id === message.targetViewId; });
+    message.expectedTargetViewRevision = target && target.revision;
+    message.targetWorkspace = recomposeWorkspace(target && target.workspace, message.tree, message.activeSessionOriginId);
+    var moved = view && view.workspace.panes.find(function (pane) { return pane.kind === 'session' && pane.resource.originId === message.sourceSessionOriginId; });
+    var destination = message.targetWorkspace.panes.find(function (pane) { return pane.kind === 'session' && pane.resource.originId === message.sourceSessionOriginId; });
+    if (moved && destination) {
+      var mapping = Object.create(null); message.targetWorkspace.panes.forEach(function (pane) { mapping[pane.instanceId] = pane === destination ? moved.instanceId : pane.instanceId; });
+      message.targetWorkspace.tree = mapWorkspaceTree(message.targetWorkspace.tree, mapping);
+      if (message.targetWorkspace.activePaneId === destination.instanceId) message.targetWorkspace.activePaneId = moved.instanceId;
+      destination.instanceId = moved.instanceId;
+    }
+    message.tree = sessionTree(message.targetWorkspace);
+    message.active = true;
+  }
+  return message;
+}
+export function workspaceChanged() { document.dispatchEvent(new CustomEvent('clay-workspace-changed')); }