clay-server 5.3.0-beta.5 → 5.3.0-beta.7

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')); }

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

@@ -0,0 +1,47 @@
+import { WORKBENCH_PANELS } from './workbench-panels.js';
+import { validLinkedPair } from './view-pair-validation.js';
+import { sessionTree } from './view-workspace-state.js';
+function id(value) { return typeof value === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(value); }
+function runtime(value) { return id(value) || typeof value === 'string' && /^runtime:[A-Za-z0-9_-]{1,128}$/.test(value); }
+function fields(value, names) { return value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).sort().join(',') === names.split(',').sort().join(','); }
+function sameTree(a, b) { return !a || !b ? a === b : a.id || b.id ? a.id === b.id : a.axis === b.axis && a.ratio === b.ratio && sameTree(a.left,b.left) && sameTree(a.right,b.right); }
+export function validWorkspaceView(view) {
+  var value = view && view.workspace;
+  if (!value || !fields(value, 'version,panes,tree,activePaneId' + (value.linkedPair === undefined ? '' : ',linkedPair') + (value.presentation === undefined ? '' : ',presentation')) || value.version !== 1 || !Array.isArray(value.panes) || value.panes.length > 24) return false;
+  var instances = [], origins = [], docked = [], open = [], resources = [], tools = 0, files = 0, overlays = 0;
+  for (var i = 0; i < value.panes.length; i++) {
+    var p = value.panes[i], r = p && p.resource;
+    if (!fields(p, 'instanceId,kind,open,placement,resource') || !id(p.instanceId) || instances.indexOf(p.instanceId) >= 0 || typeof p.open !== 'boolean' || ['docked', 'overlay'].indexOf(p.placement) < 0) return false;
+    instances.push(p.instanceId);
+    if (p.kind === 'session') {
+      if (!fields(r, 'originId') || !id(r.originId) || origins.indexOf(r.originId) >= 0 || !p.open || p.placement !== 'docked') return false;
+      origins.push(r.originId);
+    } else {
+      if (++tools > 16) return false;
+      if (p.kind === 'file') {
+        if (++files > 8) return false;
+        if (!fields(r, 'path,mode,rendered') || typeof r.path !== 'string' || !r.path || r.path.length > 4096 || /[\\\x00-\x1f\x7f:]/.test(r.path) || !r.path.split('/').every(function(part) { return part && part !== '.' && part !== '..'; }) || ['follow', 'pin'].indexOf(r.mode) < 0 || typeof r.rendered !== 'boolean') return false;
+      } else if (p.kind === 'terminal' || p.kind === 'browser') {
+        if (!runtime(r && r.runtimeId)) return false;
+        if (p.kind === 'terminal' ? !fields(r, 'id,identity,runtimeId') || !Number.isSafeInteger(r.id) || r.id < 1 || !id(r.identity) : !fields(r, 'id,runtimeId,sessionOriginId') || !id(r.id) || !id(r.sessionOriginId)) return false;
+        var key = p.kind + ':' + r.runtimeId + ':' + r.id;
+        if (resources.indexOf(key) >= 0) return false;
+        resources.push(key);
+      } else if (p.kind === 'workbench') {
+        if (!fields(r, 'name') || !Object.prototype.hasOwnProperty.call(WORKBENCH_PANELS, r.name) || resources.indexOf('workbench:' + r.name) >= 0) return false;
+        resources.push('workbench:' + r.name);
+      } else return false;
+    }
+    if (p.open) { open.push(p.instanceId); if (p.placement === 'docked') docked.push(p.instanceId); else overlays++; }
+  }
+  if (origins.length !== view.sessions.length || view.sessions.some(function(s) { return origins.indexOf(s.sessionOriginId) < 0; }) || overlays > 1 || (open.length ? open.indexOf(value.activePaneId) < 0 : value.activePaneId !== null)) return false;
+  var seen = [], nodes = 0;
+  function walk(node) {
+    if (++nodes > 47) return false;
+    if (fields(node, 'id')) { if (seen.indexOf(node.id) >= 0 || docked.indexOf(node.id) < 0) return false; seen.push(node.id); return true; }
+    return fields(node, 'axis,ratio,left,right') && ['horizontal', 'vertical'].indexOf(node.axis) >= 0 && Number.isFinite(node.ratio) && node.ratio >= .05 && node.ratio <= .95 && walk(node.left) && walk(node.right);
+  }
+  if (docked.length ? !walk(value.tree) || seen.length !== docked.length : value.tree !== null) return false;
+  if (value.presentation !== undefined && (!fields(value.presentation, 'focusedSessionOriginId,expandedPaneId') || value.presentation.focusedSessionOriginId !== null && origins.indexOf(value.presentation.focusedSessionOriginId) < 0 || value.presentation.expandedPaneId !== null && !value.panes.some(function (p) { return p.kind !== 'session' && p.open && p.instanceId === value.presentation.expandedPaneId; }))) return false;
+  return sameTree(sessionTree(value), view.tree) && (value.linkedPair === undefined || validLinkedPair(value.linkedPair, value, { sessionRefs: view.sessions.map(function (s) { return { originId: s.sessionOriginId }; }) }));
+}

package/lib/public/modules/wireframe-workbench.js

@@ -9,7 +9,7 @@ import { mountWireframeViewport } from './wireframe-viewport.js';
 function panel() { return document.getElementById('wireframe-panel'); }
 export function closeWireframe() {
   releaseRightWorkbench('wireframe');
-  if (panel()) panel().remove();
+  if (panel()) { panel().dispatchEvent(new Event('clay-tool-pane-dispose')); panel().remove(); }
   store.set({ wireframeDraft: null });
 }
 
@@ -90,6 +90,7 @@ export function openWireframe(message) {
   var draft = { source: wireframeSource(message.source, message.language), title: String(message.title || 'clay-sketch').slice(0, 100),
     id: /^[a-zA-Z0-9_-]{1,80}$/.test(message.id || '') ? message.id : 'wireframe' };
   store.set({ wireframeDraft: draft });
+  el.querySelector('[data-save]').disabled = false; el.querySelector('[data-download]').disabled = false;
   el.querySelector('header strong').textContent = draft.title;
   el.querySelector('.wireframe-save-status').textContent = '';
   el.querySelector('form').hidden = true;
@@ -115,5 +116,15 @@ function draw(draft, el) {
 }
 registerRightWorkbench('wireframe', closeWireframe);
 store.subscribe(function (state, previous) {
-  if (state.currentSlug !== previous.currentSlug || state.activeSessionId !== previous.activeSessionId || state.myUserId !== previous.myUserId) closeWireframe();
+  if (state.currentSlug !== previous.currentSlug || state.myUserId !== previous.myUserId) closeWireframe();
 });
+
+export function restoreWireframeWorkbench() {
+  var draft = store.get('wireframeDraft');
+  if (draft) { openWireframe(draft); return; }
+  var el = panel() || createPanel();
+  if (!el) return;
+  claimRightWorkbench('wireframe'); el.classList.remove('hidden');
+  el.querySelector('[data-save]').disabled = true; el.querySelector('[data-download]').disabled = true;
+  el.querySelector('.wireframe-workbench-canvas').textContent = 'Open a sketch to view it here.';
+}

package/lib/public/modules/workbench-layout-preference.js

@@ -8,7 +8,7 @@ function state() { return store.get('workbenchLayoutPreference'); }
 function defaults(previous) {
   var same = previous && previous.accountId === account();
   return { mode: same ? previous.mode : 'overlay', accountId: account(), ready: false, loading: false, saving: false,
-    error: '', socket: getWs(), revision: same ? previous.revision : 0, generation: (previous && previous.generation || 0) + 1, checkedAt: 0 };
+    layouts: same ? previous.layouts || {} : {}, error: '', socket: getWs(), revision: same ? previous.revision : 0, generation: (previous && previous.generation || 0) + 1, checkedAt: 0 };
 }
 function initialize() {
   if (!state() || state().accountId !== account() || state().socket !== getWs()) store.set({ workbenchLayoutPreference: defaults(state()) });
@@ -21,7 +21,7 @@ function current(receipt) {
     store.get('connected') === receipt.connected && store.get('authIdentityLoaded') === receipt.identity &&
     store.get('projectSplitViewSocketGeneration') === receipt.socketGeneration;
 }
-function request(mode) {
+function request(mode, layout) {
   var before = initialize(), saving = mode !== undefined;
   var receipt = { generation: before.generation, project: store.get('currentSlug'), socket: getWs(),
     connected: store.get('connected'), identity: store.get('authIdentityLoaded'), socketGeneration: store.get('projectSplitViewSocketGeneration') };
@@ -33,14 +33,15 @@ function request(mode) {
       if (!current(receipt)) return false;
       var response = await fetch(endpoint, { method: saving ? 'PUT' : 'GET', credentials: 'same-origin', cache: 'no-store', signal: controller.signal,
         headers: { 'Content-Type': 'application/json', 'X-Clay-Settings': '1', 'X-Clay-Account-Id': before.accountId },
-        body: saving ? JSON.stringify({ mode: mode, revision: before.revision }) : undefined });
+        body: saving ? JSON.stringify(Object.assign({ mode: mode, revision: before.revision }, layout ? { layout: layout } : {})) : undefined });
       var data = await response.json();
       if (!current(receipt)) return false;
       if (!response.ok) throw new Error(response.status === 409 ? 'Workbench layout changed elsewhere. Reload the preference and try again.' :
         saving ? 'Workbench layout could not be saved. Reload the preference before trying again.' : 'Workbench layout could not be loaded. Try again.');
       if (!data || data.accountId !== before.accountId || !validMode(data.mode) || !Number.isSafeInteger(data.revision) || data.revision < before.revision || data.revision === before.revision && data.mode !== before.mode ||
-          saving && (data.mode !== mode || data.revision !== before.revision + (mode === before.mode ? 0 : 1))) throw new Error('Workbench preference response is stale. Reload and try again.');
-      store.set({ workbenchLayoutPreference: Object.assign({}, state(), { mode: data.mode, revision: data.revision,
+          saving && (data.mode !== mode || data.revision !== before.revision + (mode === before.mode && (!layout || JSON.stringify((before.layouts || {})[layout.key]) === JSON.stringify({ base: layout.base, tree: layout.tree })) ? 0 : 1))) throw new Error('Workbench preference response is stale. Reload and try again.');
+      if (layout && (!data.layouts || JSON.stringify(data.layouts[layout.key]) !== JSON.stringify({ base: layout.base, tree: layout.tree }))) throw new Error('Window layout response is stale. Reload and try again.');
+      store.set({ workbenchLayoutPreference: Object.assign({}, state(), { mode: data.mode, revision: data.revision, layouts: data.layouts || {},
         ready: true, loading: false, saving: false, error: '', checkedAt: Date.now(), receipt: null, promise: null }) });
       return true;
     } catch (error) {
@@ -74,3 +75,9 @@ store.subscribe(function (next, previous) {
     store.set({ workbenchLayoutPreference: defaults(state()) });
   }
 });
+
+export function saveWorkbenchWindowLayout(key, tree, base) {
+  var value = initialize();
+  if (!value.ready || value.loading || value.saving || !store.get('connected') || !store.get('authIdentityLoaded')) return Promise.resolve(false);
+  return request(value.mode, { key: key, tree: tree, base: base });
+}

package/lib/public/modules/workbench-panels.js

@@ -0,0 +1,21 @@
+// One registry for the non-resource workbenches and their existing entrypoints.
+export var WORKBENCH_PANELS = {
+  'project-logs': { id: 'project-logs-panel', label: 'Logs', icon: 'notebook-text', open: 'openProjectLogs', load: function () { return import('./project-logs.js'); } },
+  you: { id: 'you-panel', label: 'Me', icon: 'user', open: 'openYou', load: function () { return import('./you.js'); } },
+  issues: { id: 'issues-panel', label: 'Issues', icon: 'circle-dot', open: 'openIssues', load: function () { return import('./issues.js'); } },
+  linear: { id: 'linear-panel', label: 'Linear', icon: 'list-todo', open: 'openLinear', load: function () { return import('./linear-panel.js'); } },
+  'notes-browser': { id: 'notes-browser', label: 'Sticky Notes', icon: 'sticky-note', open: 'openNotesBrowser', load: function () { return import('./sticky-notes-browser.js'); } },
+  'scheduled-tasks': { id: 'scheduled-tasks-panel', label: 'Scheduled Tasks', icon: 'calendar-clock', open: 'openScheduledTasks', load: function () { return import('./scheduled-tasks.js'); } },
+  debates: { id: 'debates-workbench', label: 'Debates', icon: 'messages-square', open: 'openDebatesWorkbench', load: function () { return import('./debates-workbench.js'); } },
+  'mcp-skills': { id: 'mcp-skills-workbench', label: 'MCP / Skills', icon: 'blocks', open: 'openMcpSkillsWorkbench', load: function () { return import('./mcp-skills-workbench.js'); } },
+  'mate-knowledge': { id: 'mate-knowledge-workbench', label: 'Knowledge', icon: 'book-open', open: 'openKnowledgeWorkbench', load: function () { return import('./mate-knowledge-workbench.js'); } },
+  wireframe: { id: 'wireframe-panel', label: 'Sketch', icon: 'panels-top-left', open: 'restoreWireframeWorkbench', load: function () { return import('./wireframe-workbench.js'); } }
+};
+
+export function setWorkbenchExpanded(name, expanded) {
+  var definition = WORKBENCH_PANELS[name], panel = definition && document.getElementById(definition.id);
+  if (!panel || panel.classList.contains('panel-fullscreen') === expanded) return;
+  var button = panel.querySelector('header button[aria-label*="fullscreen"], header button[title*="fullscreen"]');
+  if (button) button.click();
+  else panel.classList.toggle('panel-fullscreen', expanded);
+}