clay-server 5.2.1-beta.2 → 5.3.0-beta.1

package/lib/project-split-view-names.js

@@ -0,0 +1,67 @@
+var MAX_NAME_LENGTH = 80;
+
+function mode(view) {
+  if (view && (view.nameMode === "automatic" || view.nameMode === "custom")) return view.nameMode;
+  return view && view.name === "Split view" ? "automatic" : "custom";
+}
+
+function truncate(name) {
+  var chars = Array.from(name);
+  return chars.length <= MAX_NAME_LENGTH ? name : chars.slice(0, MAX_NAME_LENGTH - 1).join("") + "…";
+}
+
+function automaticName(sessions) {
+  var titles = (sessions || []).map(function (session) {
+    return session && typeof session.title === "string" && session.title.trim() || "Session";
+  });
+  return truncate(titles.length ? titles.join(" + ") : "Split view");
+}
+
+function project(view, sessions) {
+  var nameMode = mode(view), fullName = (sessions || []).map(function (session) {
+    return session && typeof session.title === "string" && session.title.trim() || "Session";
+  }).join(" + ");
+  return { id: view.id, name: nameMode === "automatic" ? truncate(fullName || "Split view") : view.name,
+    fullName: nameMode === "automatic" ? fullName || "Split view" : view.name, nameMode: nameMode,
+    folderId: view.folderId || null, favorite: view.favorite === true,
+    revision: view.revision, layout: view.layout, activeSessionOriginId: view.activeSessionOriginId,
+    tree: view.tree, sessions: sessions };
+}
+
+function stableOrder(existingRefs, refs, sessions, requiredOrigins) {
+  if (!Array.isArray(existingRefs) || !Array.isArray(refs) || !Array.isArray(sessions) || refs.length !== sessions.length) return null;
+  var priorOrigins = existingRefs.map(function (ref) { return ref && ref.originId; });
+  if (priorOrigins.some(function (origin, index) { return !origin || priorOrigins.indexOf(origin) !== index; })) return null;
+  var requested = refs.map(function (ref, index) {
+    var session = sessions[index];
+    return ref && session && ref.originId === session.sessionOriginId ? ref.originId : null;
+  });
+  if (requested.some(function (origin, index) { return !origin || requested.indexOf(origin) !== index; })) return null;
+  if (requiredOrigins && (requested.length !== requiredOrigins.length || requiredOrigins.some(function (origin) { return requested.indexOf(origin) === -1; }))) return null;
+  var origins = existingRefs.map(function (ref) { return ref && ref.originId; }).filter(function (origin) { return requested.indexOf(origin) !== -1; });
+  requested.forEach(function (origin) { if (origins.indexOf(origin) === -1) origins.push(origin); });
+  if (origins.length !== requested.length) return null;
+  return { refs: origins.map(function (id) { return refs.find(function (ref) { return ref.originId === id; }); }),
+    sessions: origins.map(function (id) { return sessions.find(function (session) { return session.sessionOriginId === id; }); }) };
+}
+
+function append(view, refs, sessions, origin) {
+  if (!view || !Array.isArray(view.sessionRefs) || view.sessionRefs.some(function (ref) { return !ref || ref.originId === origin; })) return null;
+  var required = view.sessionRefs.map(function (ref) { return ref.originId; });
+  required.push(origin);
+  return stableOrder(view.sessionRefs, refs, sessions, required);
+}
+
+function update(view, refs, sessions) { return view ? stableOrder(view.sessionRefs, refs, sessions) : null; }
+
+function targetFirst(refs, sessions, targetOrigin, movedOrigin) {
+  if (!targetOrigin || !movedOrigin || targetOrigin === movedOrigin) return null;
+  var ordered = stableOrder([], refs, sessions, [targetOrigin, movedOrigin]);
+  if (!ordered || ordered.refs.length !== 2) return null;
+  var target = ordered.refs.find(function (ref) { return ref.originId === targetOrigin; });
+  var moved = ordered.refs.find(function (ref) { return ref.originId === movedOrigin; });
+  return target && moved ? { refs: [target, moved], sessions: [ordered.sessions.find(function (session) { return session.sessionOriginId === targetOrigin; }),
+    ordered.sessions.find(function (session) { return session.sessionOriginId === movedOrigin; })] } : null;
+}
+
+module.exports = { mode: mode, truncate: truncate, automaticName: automaticName, project: project, append: append, update: update, targetFirst: targetFirst };

package/lib/project-split-view-organization.js

@@ -0,0 +1,23 @@
+// Saved presentation metadata never changes member-session organization.
+function attachOrganization(deps) {
+  function organize(ownerId, linuxUser, input) {
+    var prepared = deps.prepare(ownerId, linuxUser, input.expectedRevision);
+    if (!prepared.ok) return prepared;
+    var view = prepared.record.views.find(function (item) { return item.id === input.id; });
+    if (!view || view.revision !== input.expectedViewRevision) return { ok: false, code: 'conflict', error: 'Split view changed. Reload and try again.' };
+    if (!(input.folderId === null || typeof input.folderId === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(input.folderId)) || typeof input.favorite !== 'boolean') return { ok: false, code: 'invalid', error: 'Invalid Split view organization.' };
+    view.folderId = input.folderId; view.favorite = input.favorite;
+    return deps.commit(ownerId, prepared.record, view);
+  }
+  function reconcileFolders(ownerId, linuxUser, folderIds) {
+    var current = deps.state(ownerId, linuxUser);
+    if (!current.ok || !current.views.some(function (view) { return view.folderId && folderIds.indexOf(view.folderId) < 0; })) return current;
+    var prepared = deps.prepare(ownerId, linuxUser, current.revision);
+    if (!prepared.ok) return prepared;
+    var changed = [];
+    prepared.record.views.forEach(function (view) { if (view.folderId && folderIds.indexOf(view.folderId) < 0) { view.folderId = null; changed.push(view); } });
+    return deps.commit(ownerId, prepared.record, changed);
+  }
+  return { organize: organize, reconcileFolders: reconcileFolders };
+}
+module.exports = { attachOrganization: attachOrganization };

package/lib/project-split-views.js

@@ -0,0 +1,479 @@
+var fs = require("fs");
+var path = require("path");
+var crypto = require("crypto");
+var layout = require("./split-view-layout");
+var names = require("./project-split-view-names");
+var sessionProvenance = require("./session-provenance");
+var validDocument = require("./project-split-view-document").validDocument;
+function clone(value) { return JSON.parse(JSON.stringify(value)); }
+function ownerKey(ownerId) { return ownerId == null ? "default" : "user:" + String(ownerId); }
+function emptyDocument() { return { version: 1, projects: {} }; }
+function emptyOwner(ownerId, linuxUser) { return { ownerId: ownerId == null ? null : String(ownerId), linuxUser: linuxUser || null, revision: 0, views: [] }; }
+function createSplitViewsStore(opts) {
+  var slug = opts.slug;
+  var sessionsDir = opts.sessionsDir;
+  var filePath = opts.filePath || path.join(sessionsDir, "presentation-split-views.json");
+  var fsImpl = opts.fs || fs;
+  var persist = opts.persist || null;
+  var document = emptyDocument();
+  var loadError = null;
+  try {
+    var loaded = JSON.parse(fsImpl.readFileSync(filePath, "utf8"));
+    if (!validDocument(loaded)) throw new Error("Stored Split view data is invalid");
+    document = loaded;
+  } catch (error) {
+    if (!error || error.code !== "ENOENT") loadError = error;
+  }
+  function projectRecord(source, create) {
+    if (!source.projects[slug] && create) source.projects[slug] = { owners: {} };
+    return source.projects[slug] || null;
+  }
+  function ownerRecord(source, ownerId, linuxUser, create) {
+    var project = projectRecord(source, create);
+    if (!project) return null;
+    var key = ownerKey(ownerId), record = project.owners[key];
+    if (!record && create) { record = emptyOwner(ownerId, linuxUser); project.owners[key] = record; }
+    if (record && (record.ownerId !== (ownerId == null ? null : String(ownerId)) || record.linuxUser !== (linuxUser || null))) return { identityMismatch: true };
+    return record || null;
+  }
+  function save(next) {
+    if (!validDocument(next)) throw new Error("Split view state failed validation");
+    var serialized = JSON.stringify(next, null, 2) + "\n";
+    if (persist) {
+      if (persist(filePath, serialized) === false) throw new Error("Split view persistence returned false");
+      return;
+    }
+    fsImpl.mkdirSync(sessionsDir, { recursive: true });
+    var tempPath = filePath + ".tmp." + process.pid + "." + crypto.randomBytes(4).toString("hex");
+    try {
+      fsImpl.writeFileSync(tempPath, serialized, { encoding: "utf8", flag: "wx", mode: 0o600 });
+      if (process.platform !== "win32") try { fsImpl.chmodSync(tempPath, 0o600); } catch (e) {}
+      fsImpl.renameSync(tempPath, filePath);
+    } catch (error) {
+      try { fsImpl.unlinkSync(tempPath); } catch (e) {}
+      throw error;
+    }
+  }
+  function state(ownerId, linuxUser) {
+    if (loadError) return { ok: false, error: "Stored Split view data could not be read; no changes were made", code: "storage", revision: 0, views: [] };
+    var record = ownerRecord(document, ownerId, linuxUser, false);
+    if (record && record.identityMismatch) return { ok: false, error: "Split view owner or OS identity changed", code: "identity", revision: 0, views: [] };
+    return record ? { ok: true, revision: record.revision, views: clone(record.views) } : { ok: true, revision: 0, views: [] };
+  }
+  function conflict(actual) { return { ok: false, error: "Split view state changed. Reload and try again.", code: "conflict", revision: actual }; }
+  function validateRevision(value) { return Number.isInteger(value) && value >= 0; }
+  function prepareRecord(ownerId, linuxUser, expectedRevision) {
+    var current = state(ownerId, linuxUser);
+    if (!current.ok) return current;
+    if (!validateRevision(expectedRevision) || expectedRevision !== current.revision) return conflict(current.revision);
+    var next = clone(document), record = ownerRecord(next, ownerId, linuxUser, true);
+    return { ok: true, next: next, record: record };
+  }
+  function commit(ownerId, record, changedView) {
+    record.revision++;
+    if (Array.isArray(changedView)) changedView.forEach(function (view) { if (view) view.revision = record.revision; });
+    else if (changedView) changedView.revision = record.revision;
+    try { save(documentForOwner(record, ownerId)); }
+    catch (error) { return { ok: false, error: error.message || String(error), code: "storage", revision: state(ownerId, record.linuxUser).revision }; }
+    document = documentForOwner(record, ownerId);
+    var resultView = Array.isArray(changedView) ? changedView[changedView.length - 1] : changedView;
+    return { ok: true, revision: record.revision, view: resultView ? clone(resultView) : null, views: clone(record.views) };
+  }
+  function documentForOwner(record, ownerId) {
+    var next = clone(document), project = projectRecord(next, true);
+    project.owners[ownerKey(ownerId)] = clone(record);
+    return next;
+  }
+  function validExpectedView(record, id) {
+    if (typeof id !== "string" || !id) return { error: "Split view not found" };
+    var index = record.views.findIndex(function (view) { return view.id === id; });
+    if (index === -1) return { error: "Split view not found" };
+    return { index: index, view: record.views[index] };
+  }
+  function refsFor(origins, resolvedRefs) {
+    if (!Array.isArray(origins) || origins.length < 2 || origins.length > layout.MAX_SESSIONS ||
+        origins.some(function (origin) { return !layout.validOrigin(origin); }) || new Set(origins).size !== origins.length) return { error: "A Split view requires two to eight unique session origins" };
+    if (!Array.isArray(resolvedRefs) || resolvedRefs.length !== origins.length) return { error: "One or more exact sessions could not be resolved" };
+    var refs = [];
+    for (var i = 0; i < origins.length; i++) {
+      var ref = resolvedRefs.find(function (item) { return item && item.originId === origins[i]; });
+      if (!ref) return { error: "One or more exact sessions could not be resolved" };
+      refs.push({ originId: ref.originId, ownerId: ref.ownerId == null ? null : String(ref.ownerId), linuxUser: ref.linuxUser || null });
+    }
+    return { refs: refs };
+  }
+  function validateComposition(input, refs) {
+    var origins = refs.map(function (ref) { return ref.originId; }), tree = layout.validateTree(input.tree, origins), preset = input.layout;
+    if (!tree.ok) return { error: tree.error };
+    if (!layout.validatePreset(preset)) return { error: "Unknown Split view layout" };
+    if (typeof input.activeSessionOriginId !== "string" || origins.indexOf(input.activeSessionOriginId) === -1) return { error: "Active session must belong to the Split view" };
+    return { origins: origins };
+  }
+  function uniqueMembership(views, refs, exceptId, secondExceptId) {
+    var used = [];
+    views.forEach(function (view) {
+      if (view.id === exceptId || view.id === secondExceptId) return;
+      view.sessionRefs.forEach(function (ref) { used.push(ref.originId); });
+    });
+    return refs.every(function (ref) { return used.indexOf(ref.originId) === -1; });
+  }
+  function create(ownerId, linuxUser, input, resolvedRefs) {
+    input = input || {};
+    var prepared = prepareRecord(ownerId, linuxUser, input.expectedRevision);
+    if (!prepared.ok) return prepared;
+    var name = layout.validateName(input.name), refs = refsFor(input.sessionOrigins, resolvedRefs);
+    if (!name.ok) return name;
+    if (refs.error) return { ok: false, error: refs.error };
+    var composition = validateComposition(input, refs.refs);
+    if (composition.error) return { ok: false, error: composition.error };
+    if (!uniqueMembership(prepared.record.views, refs.refs)) return { ok: false, error: "A session can belong to only one Split view" };
+    var nameMode = input.nameMode === "custom" ? "custom" : "automatic";
+    var view = { id: crypto.randomUUID(), name: nameMode === "automatic" ? names.automaticName(input.liveSessions) : name.name, nameMode: nameMode,
+      folderId: null, favorite: false, revision: prepared.record.revision + 1, layout: input.layout,
+      activeSessionOriginId: input.activeSessionOriginId, tree: clone(input.tree), sessionRefs: refs.refs };
+    prepared.record.views.push(view);
+    return commit(ownerId, prepared.record, view);
+  }
+  function update(ownerId, linuxUser, input, resolvedRefs) {
+    input = input || {};
+    var prepared = prepareRecord(ownerId, linuxUser, input.expectedRevision);
+    if (!prepared.ok) return prepared;
+    var found = validExpectedView(prepared.record, input.id, input.expectedRevision);
+    if (found.error) return { ok: false, error: found.error };
+    if (found.conflict) return conflict(found.revision);
+    var refs = refsFor(input.sessionOrigins, resolvedRefs);
+    if (refs.error) return { ok: false, error: refs.error };
+    var ordered = names.update(found.view, refs.refs, input.liveSessions);
+    if (!ordered) return { ok: false, error: "One or more exact sessions could not be resolved" };
+    refs.refs = ordered.refs; input.liveSessions = ordered.sessions;
+    var composition = validateComposition(input, refs.refs);
+    if (composition.error) return { ok: false, error: composition.error };
+    if (!uniqueMembership(prepared.record.views, refs.refs, input.id)) return { ok: false, error: "A session can belong to only one Split view" };
+    if (names.mode(found.view) === "automatic") found.view.name = names.automaticName(input.liveSessions);
+    found.view.layout = input.layout; found.view.activeSessionOriginId = input.activeSessionOriginId;
+    found.view.tree = clone(input.tree); found.view.sessionRefs = refs.refs;
+    return commit(ownerId, prepared.record, found.view);
+  }
+  function rename(ownerId, linuxUser, input) {
+    input = input || {};
+    var prepared = prepareRecord(ownerId, linuxUser, input.expectedRevision);
+    if (!prepared.ok) return prepared;
+    var found = validExpectedView(prepared.record, input.id, input.expectedRevision);
+    if (found.error) return { ok: false, error: found.error };
+    if (found.conflict) return conflict(found.revision);
+    var name = layout.validateName(input.name);
+    if (!name.ok) return name;
+    found.view.name = name.name;
+    found.view.nameMode = "custom";
+    return commit(ownerId, prepared.record, found.view);
+  }
+  function separate(ownerId, linuxUser, input) {
+    input = input || {};
+    var prepared = prepareRecord(ownerId, linuxUser, input.expectedRevision);
+    if (!prepared.ok) return prepared;
+    var found = validExpectedView(prepared.record, input.id, input.expectedRevision);
+    if (found.error) return { ok: false, error: found.error };
+    if (found.conflict) return conflict(found.revision);
+    var removed = prepared.record.views.splice(found.index, 1)[0];
+    return commit(ownerId, prepared.record, null);
+  }
+  function move(ownerId, linuxUser, input, resolvedSourceRefs, resolvedTargetRefs) {
+    input = input || {};
+    var prepared = prepareRecord(ownerId, linuxUser, input.expectedRevision);
+    if (!prepared.ok) return prepared;
+    if (typeof input.sourceSessionOriginId !== "string" || !layout.validOrigin(input.sourceSessionOriginId)) return { ok: false, error: "A valid source session is required", code: "invalid" };
+    var source = validExpectedView(prepared.record, input.sourceViewId);
+    if (source.error) return { ok: false, error: "Source Split view not found", code: "not_found", revision: prepared.record.revision };
+    var sourceOrigins = source.view.sessionRefs.map(function (ref) { return ref.originId; });
+    if (sourceOrigins.indexOf(input.sourceSessionOriginId) === -1) return { ok: false, error: "Source session does not belong to the source Split view", code: "session", revision: prepared.record.revision };
+    if (!Array.isArray(resolvedSourceRefs) || resolvedSourceRefs.length !== source.view.sessionRefs.length) return { ok: false, error: "Source sessions could not be resolved", code: "session", revision: prepared.record.revision };
+    for (var i = 0; i < source.view.sessionRefs.length; i++) {
+      var storedSource = source.view.sessionRefs[i], liveSource = resolvedSourceRefs.find(function (ref) { return ref && ref.originId === storedSource.originId; });
+      if (!liveSource || (liveSource.ownerId || null) !== (storedSource.ownerId || null) || (liveSource.linuxUser || null) !== (storedSource.linuxUser || null)) {
+        return { ok: false, error: "A source session was replaced or changed identity", code: "session", revision: prepared.record.revision };
+      }
+    }
+    var target = null, targetSessionOriginId = input.targetSessionOriginId;
+    var hasTargetView = typeof input.targetViewId === "string" && input.targetViewId.length > 0;
+    var hasStandaloneTarget = typeof targetSessionOriginId === "string" && layout.validOrigin(targetSessionOriginId);
+    if (hasTargetView === hasStandaloneTarget || (input.targetViewId != null && !hasTargetView)) {
+      return { ok: false, error: "Choose exactly one target Split view or standalone session", code: "invalid", revision: prepared.record.revision };
+    }
+    if (hasTargetView) {
+      target = validExpectedView(prepared.record, input.targetViewId);
+      if (target.error || target.view.id === source.view.id) return { ok: false, error: "Target Split view is unavailable", code: "not_found", revision: prepared.record.revision };
+    }
+    if (Array.isArray(input.targetSessionOrigins) && input.targetSessionOrigins.length > layout.MAX_SESSIONS) {
+      return { ok: false, error: "A Split view can contain at most eight sessions", code: "limit", revision: prepared.record.revision };
+    }
+    var targetRefs = refsFor(input.targetSessionOrigins, resolvedTargetRefs);
+    if (targetRefs.error) return { ok: false, error: targetRefs.error, code: "session", revision: prepared.record.revision };
+    var requestedTargetOrigins = targetRefs.refs.map(function (ref) { return ref.originId; });
+    if (requestedTargetOrigins.indexOf(input.sourceSessionOriginId) === -1) return { ok: false, error: "Target layout must include the moved source session", code: "invalid", revision: prepared.record.revision };
+    if (target) {
+      var requestedPriorOrigins = target.view.sessionRefs.map(function (ref) { return ref.originId; });
+      if (requestedTargetOrigins.length !== requestedPriorOrigins.length + 1 || requestedPriorOrigins.some(function (origin) { return requestedTargetOrigins.indexOf(origin) === -1; })) {
+        return { ok: false, error: "Target layout must preserve every existing target session", code: "invalid", revision: prepared.record.revision };
+      }
+      if (!uniqueMembership(prepared.record.views, targetRefs.refs, target.view.id, source.view.id)) return { ok: false, error: "A target session belongs to another Split view", code: "membership", revision: prepared.record.revision };
+    } else if (targetSessionOriginId === input.sourceSessionOriginId || requestedTargetOrigins.length !== 2 || requestedTargetOrigins.indexOf(targetSessionOriginId) === -1) {
+      return { ok: false, error: "A standalone target transfer requires exactly the target and moved sessions", code: "invalid", revision: prepared.record.revision };
+    } else if (!uniqueMembership(prepared.record.views, targetRefs.refs, source.view.id)) {
+      return { ok: false, error: "A standalone target session already belongs to a Split view", code: "membership", revision: prepared.record.revision };
+    }
+    if (target) { var orderedTarget = names.append(target.view, targetRefs.refs, input.liveSessions, input.sourceSessionOriginId);
+      if (!orderedTarget) return { ok: false, error: "Target layout must preserve existing sessions and include the moved source exactly once", code: "invalid", revision: prepared.record.revision };
+      targetRefs.refs = orderedTarget.refs; input.liveSessions = orderedTarget.sessions; }
+    else { var orderedStandalone = names.targetFirst(targetRefs.refs, input.liveSessions, targetSessionOriginId, input.sourceSessionOriginId);
+      if (!orderedStandalone) return { ok: false, error: "A standalone target transfer requires exactly the target and moved sessions", code: "invalid", revision: prepared.record.revision };
+      targetRefs.refs = orderedStandalone.refs; input.liveSessions = orderedStandalone.sessions; }
+    var targetOrigins = targetRefs.refs.map(function (ref) { return ref.originId; });
+    if (!layout.validatePreset(input.layout) || !layout.validateTree(input.tree, targetOrigins).ok || targetOrigins.length > layout.MAX_SESSIONS) {
+      return { ok: false, error: "Target layout is invalid or exceeds the eight-session limit", code: targetOrigins.length > layout.MAX_SESSIONS ? "limit" : "invalid", revision: prepared.record.revision };
+    }
+    if (typeof input.activeSessionOriginId !== "string" || targetOrigins.indexOf(input.activeSessionOriginId) === -1) {
+      return { ok: false, error: "Active session must belong to the target Split view", code: "invalid", revision: prepared.record.revision };
+    }
+    if (!target) {
+      var name = layout.validateName(input.name);
+      if (!name.ok) return { ok: false, error: name.error, code: "invalid", revision: prepared.record.revision };
+    }
+    var nextSourceOrigins = sourceOrigins.filter(function (origin) { return origin !== input.sourceSessionOriginId; });
+    source.view.tree = layout.removeLeaf(source.view.tree, input.sourceSessionOriginId);
+    source.view.sessionRefs = source.view.sessionRefs.filter(function (ref) { return ref.originId !== input.sourceSessionOriginId; });
+    if (source.view.activeSessionOriginId === input.sourceSessionOriginId && nextSourceOrigins.length) source.view.activeSessionOriginId = nextSourceOrigins[0];
+    if (nextSourceOrigins.length < 2) prepared.record.views.splice(source.index, 1);
+    if (nextSourceOrigins.length >= 2 && names.mode(source.view) === "automatic") source.view.name = names.automaticName(input.sourceLiveSessions.filter(function (session) { return session.sessionOriginId !== input.sourceSessionOriginId; }));
+    if (target) {
+      target.view.tree = clone(input.tree); target.view.layout = input.layout;
+      target.view.activeSessionOriginId = input.activeSessionOriginId; target.view.sessionRefs = targetRefs.refs;
+      if (names.mode(target.view) === "automatic") target.view.name = names.automaticName(input.liveSessions);
+    } else {
+      target = { index: -1, view: { id: crypto.randomUUID(), folderId: null, favorite: false, name: names.automaticName(input.liveSessions), nameMode: "automatic", revision: prepared.record.revision + 1,
+        layout: input.layout, activeSessionOriginId: input.activeSessionOriginId, tree: clone(input.tree), sessionRefs: targetRefs.refs } };
+      prepared.record.views.push(target.view);
+    }
+    var changed = [target.view];
+    if (nextSourceOrigins.length >= 2) changed.unshift(source.view);
+    return commit(ownerId, prepared.record, changed);
+  }
+  function removeOrigin(originId) {
+    var project = projectRecord(document, false), changedOwners = [], failures = [];
+    if (!project) return { owners: changedOwners, failures: failures };
+    var keys = Object.keys(project.owners);
+    for (var i = 0; i < keys.length; i++) {
+      var source = project.owners[keys[i]], next = clone(source), changed = false, retained = [];
+      for (var j = 0; j < next.views.length; j++) {
+        var view = next.views[j], member = view.sessionRefs.some(function (ref) { return ref.originId === originId; });
+        if (!member) { retained.push(view); continue; }
+        changed = true;
+        var tree = layout.removeLeaf(view.tree, originId), origins = view.sessionRefs.filter(function (ref) { return ref.originId !== originId; });
+        if (origins.length < 2) continue;
+        view.tree = tree;
+        view.sessionRefs = origins;
+        if (view.activeSessionOriginId === originId) view.activeSessionOriginId = origins[0].originId;
+        retained.push(view);
+      }
+      if (!changed) continue;
+      next.views = retained;
+      next.revision++;
+      next.views.forEach(function (view) { view.revision = next.revision; });
+      try {
+        var replacement = documentForOwner(next, source.ownerId);
+        save(replacement);
+        document = replacement;
+        changedOwners.push(source.ownerId);
+      } catch (error) { failures.push({ ownerId: source.ownerId, error: error.message || String(error) }); }
+    }
+    return { owners: changedOwners, failures: failures };
+  }
+  var organization = require('./project-split-view-organization').attachOrganization({ prepare: prepareRecord, commit: commit, state: state });
+  return { organize: organization.organize, reconcileFolders: organization.reconcileFolders, state: state, create: create, update: update, rename: rename, separate: separate, move: move, removeOrigin: removeOrigin,
+    get filePath() { return filePath; }, get loadError() { return loadError; } };
+}
+function attachProjectSplitViews(ctx) {
+  var store = createSplitViewsStore({ sessionsDir: ctx.sm.sessionsDir, slug: ctx.slug, persist: ctx.persist });
+  var users = ctx.usersModule;
+  function actor(ws) {
+    if (ctx.isMate || !ws || !ctx.clients.has(ws) || ws._clayPaneActivation || !ctx.canAccessProject(ws)) return null;
+    if (users.isMultiUser()) {
+      var user = ws._clayUser && users.findUserById(ws._clayUser.id);
+      if (!user || !ctx.canAccessProject(ws)) return null;
+      if (ctx.osUsers && (!user.linuxUser || !ctx.getOsUserInfoForWs({ _clayUser: user }))) return null;
+      return { id: user.id, linuxUser: ctx.osUsers ? user.linuxUser : null };
+    }
+    var current = ws._clayUser && users.findUserById(ws._clayUser.id);
+    if (ctx.osUsers && (!current || !current.linuxUser || !ctx.getOsUserInfoForWs({ _clayUser: current }))) return null;
+    return { id: current && current.id || null, linuxUser: ctx.osUsers && current ? current.linuxUser : null };
+  }
+  function resolveOrigin(ws, originId) {
+    if (!layout.validOrigin(originId)) return null;
+    var found = null, ambiguous = false;
+    ctx.sm.sessions.forEach(function (session) {
+      if (session.sessionOriginId !== originId) return;
+      if (found && found !== session) { ambiguous = true; return; }
+      found = session;
+    });
+    if (!found || ambiguous || ctx.sm.sessions.get(found.localId) !== found || sessionProvenance.isWorker(found) || !ctx.canAccessSession(ws, found)) return null;
+    var linuxUser = ctx.osUsers ? ctx.getLinuxUserForSession(found) : null;
+    if (ctx.osUsers && !linuxUser) return null;
+    return { session: found, ref: { originId: found.sessionOriginId, ownerId: found.ownerId || null, linuxUser: linuxUser || null } };
+  }
+  function resolvedRefs(ws, origins) {
+    if (!Array.isArray(origins) || origins.length < 2) return { error: "A Split view requires two to eight sessions", code: "invalid" };
+    if (origins.length > layout.MAX_SESSIONS) return { error: "A Split view can contain at most eight sessions", code: "limit" };
+    if (new Set(origins).size !== origins.length || origins.some(function (origin) { return !layout.validOrigin(origin); })) return { error: "Split view session origins must be unique valid values", code: "invalid" };
+    var refs = [], sessions = [];
+    for (var i = 0; i < origins.length; i++) {
+      var resolved = resolveOrigin(ws, origins[i]);
+      if (!resolved) return { error: "One or more exact project sessions are unavailable", code: "session" };
+      refs.push(resolved.ref); sessions.push(resolved.session);
+    }
+    return { refs: refs, sessions: sessions };
+  }
+  function verifyStoredView(ws, owner, id) {
+    var state = store.state(owner.id, owner.linuxUser);
+    if (!state.ok) return { error: state.error, code: state.code };
+    var view = state.views.find(function (item) { return item.id === id; });
+    if (!view) return { error: "Split view not found", code: "not_found" };
+    for (var i = 0; i < view.sessionRefs.length; i++) {
+      var stored = view.sessionRefs[i], current = resolveOrigin(ws, stored.originId);
+      if (!current || (current.ref.ownerId || null) !== (stored.ownerId || null) ||
+          (current.ref.linuxUser || null) !== (stored.linuxUser || null)) {
+        return { error: "A referenced session was deleted, replaced, or is no longer accessible", code: "session" };
+      }
+    }
+    return { ok: true };
+  }
+  function visibleView(ws, view) {
+    var refs = [];
+    for (var i = 0; i < view.sessionRefs.length; i++) {
+      var stored = view.sessionRefs[i], resolved = resolveOrigin(ws, stored.originId);
+      if (!resolved || (resolved.ref.ownerId || null) !== (stored.ownerId || null) ||
+          (resolved.ref.linuxUser || null) !== (stored.linuxUser || null)) return null;
+      refs.push({ id: resolved.session.localId, sessionOriginId: resolved.session.sessionOriginId, title: resolved.session.title || "" });
+    }
+    var projected = names.project(view, refs); projected.tree = clone(view.tree); return projected;
+  }
+  function folderIds(ownerId) {
+    var accountId = users.isMultiUser() ? ownerId : 'default';
+    return typeof users.getSessionFolders === 'function' ? users.getSessionFolders(accountId, ctx.slug).folders.map(function (folder) { return folder.id; }) : [];
+  }
+  function stateFor(ws) {
+    var current = actor(ws);
+    if (!current) return null;
+    var state = store.reconcileFolders(current.id, current.linuxUser, folderIds(current.id));
+    if (!state.ok) return { owner: current, revision: state.revision, views: [], error: state.error };
+    var views = state.views.map(function (view) { return visibleView(ws, view); }).filter(Boolean);
+    return { owner: current, revision: state.revision, views: views };
+  }
+  function sendState(ws) {
+    var state = stateFor(ws);
+    if (!state) return false;
+    ctx.sendTo(ws, { type: "project_split_views", projectSlug: ctx.slug, revision: state.revision, views: state.views, error: state.error || null });
+    return true;
+  }
+  function broadcastOwner(ownerId) {
+    ctx.clients.forEach(function (ws) {
+      if (ws.readyState !== 1) return;
+      var current = actor(ws);
+      if (current && current.id === ownerId) sendState(ws);
+    });
+  }
+  function sendOwnerError(ownerId, error) {
+    ctx.clients.forEach(function (ws) {
+      if (ws.readyState !== 1) return;
+      var current = actor(ws);
+      if (!current || current.id !== ownerId) return;
+      var state = stateFor(ws);
+      if (state) ctx.sendTo(ws, { type: "project_split_views", projectSlug: ctx.slug, revision: state.revision,
+        views: state.views, error: error });
+    });
+  }
+  function serviceForConnection(ws) {
+    var original = actor(ws);
+    if (!original) return null;
+    function currentActor() {
+      var latest = actor(ws);
+      if (!latest || latest.id !== original.id || latest.linuxUser !== original.linuxUser) return null;
+      return latest;
+    }
+    function state() {
+      if (!currentActor()) return { ok: false, error: "Split view access is no longer permitted", code: "forbidden", views: [] };
+      return stateFor(ws);
+    }
+    function execute(action, input) {
+      var current = currentActor(), result;
+      if (!current) return { ok: false, error: "Split view access is no longer permitted", code: "forbidden" };
+      input = input || {};
+      var currentState = store.state(current.id, current.linuxUser);
+      if (!currentState.ok) return currentState;
+      if (!Number.isInteger(input.expectedRevision) || input.expectedRevision !== currentState.revision) {
+        return { ok: false, error: "Split view state changed. Reload and try again.", code: "conflict", revision: currentState.revision };
+      }
+      if (action === "create" || action === "update") {
+        var refs = resolvedRefs(ws, input.sessionOrigins);
+        if (!refs.refs) return refs;
+        input.liveSessions = refs.sessions;
+        if (action === "update") {
+          var exact = verifyStoredView(ws, current, input.id);
+          return exact.ok ? store.update(current.id, current.linuxUser, input, refs.refs) : exact;
+        }
+        input.nameMode = "automatic";
+        return store.create(current.id, current.linuxUser, input, refs.refs);
+      }
+      if (action === "move") {
+        var sourceState = store.state(current.id, current.linuxUser);
+        if (!sourceState.ok) return sourceState;
+        var sourceView = sourceState.views.find(function (view) { return view.id === input.sourceViewId; });
+        var sourceCheck = verifyStoredView(ws, current, input.sourceViewId);
+        if (!sourceCheck.ok || !sourceView) return sourceCheck.ok ? { error: "Source Split view not found", code: "not_found" } : sourceCheck;
+        var sourceResolved = resolvedRefs(ws, sourceView.sessionRefs.map(function (ref) { return ref.originId; }));
+        if (!sourceResolved.refs) return sourceResolved;
+        input.sourceLiveSessions = sourceResolved.sessions;
+        if (input.targetViewId) {
+          var targetCheck = verifyStoredView(ws, current, input.targetViewId);
+          if (!targetCheck.ok) return targetCheck;
+        }
+        var targetResolved = resolvedRefs(ws, input.targetSessionOrigins);
+        if (!targetResolved.refs) return targetResolved;
+        input.liveSessions = targetResolved.sessions;
+        return store.move(current.id, current.linuxUser, input, sourceResolved.refs, targetResolved.refs);
+      }
+      if (action === 'organize' && (input.projectSlug !== ctx.slug || input.folderId !== null && folderIds(current.id).indexOf(input.folderId) < 0)) return { ok: false, code: 'folder', error: 'That project folder is no longer available.' };
+      var exactView = verifyStoredView(ws, current, input.id);
+      return exactView.ok ? store[action](current.id, current.linuxUser, input) : exactView;
+    }
+    return { publish: function () { var current = currentActor(); if (!current) throw new Error("Split view access changed"); broadcastOwner(current.id); }, state: state, folders: function () { var current = currentActor(); if (!current) throw new Error("Split view access changed"); return users.getSessionFolders ? users.getSessionFolders(users.isMultiUser() ? current.id : "default", ctx.slug).folders : []; }, create: function (input) { return execute("create", input); },
+      update: function (input) { return execute("update", input); },
+      organize: function (input) { return execute('organize', input); },
+      rename: function (input) { return execute("rename", input); },
+      separate: function (input) { return execute("separate", input); },
+      move: function (input) { return execute("move", input); } };
+  }
+  function onSessionDeleted(localId, session) {
+    if (!session || !layout.validOrigin(session.sessionOriginId)) return;
+    var result = store.removeOrigin(session.sessionOriginId);
+    result.owners.forEach(broadcastOwner);
+    result.failures.forEach(function (failure) {
+      sendOwnerError(failure.ownerId, "A deleted session's Split view cleanup could not be persisted; affected layouts are unavailable until repaired.");
+    });
+  }
+  function handleMessage(ws, msg) {
+    var action = msg.type === "project_split_view_create" ? "create" : msg.type === "project_split_view_update" ? "update" :
+      msg.type === "project_split_view_rename" ? "rename" : msg.type === "project_split_view_separate" ? "separate" :
+      msg.type === "project_split_view_move" ? "move" : msg.type === "project_split_view_organize" ? "organize" : null;
+    if (msg.type === "project_split_views_request") { sendState(ws); return true; }
+    if (!action) return false;
+    var service = serviceForConnection(ws), result = service ? service[action](msg) : { ok: false, error: "Split view access is not permitted", code: "forbidden" };
+    ctx.sendTo(ws, { type: "project_split_view_result", action: action, requestId: typeof msg.requestId === "string" ? msg.requestId : null,
+      ok: !!result.ok, error: result.error || null, code: result.code || null, revision: result.revision,
+      view: result.ok && result.view ? visibleView(ws, result.view) : null });
+    var current = actor(ws);
+    if (result.ok && current) broadcastOwner(current.id);
+    return true;
+  }
+  if (ctx.sm && typeof ctx.sm.addOnSessionDeleted === "function") ctx.sm.addOnSessionDeleted(onSessionDeleted);
+  return { onFoldersChanged: function (accountId) { if (users.isMultiUser()) broadcastOwner(accountId); else ctx.clients.forEach(function (ws) { if (ws.readyState === 1) sendState(ws); }); }, handleMessage: handleMessage, sendConnectionState: sendState, forConnection: serviceForConnection, store: store };
+}
+module.exports = { createSplitViewsStore: createSplitViewsStore, attachProjectSplitViews: attachProjectSplitViews, validDocument: validDocument };