zidane-ui 9.1.1 → 9.1.4

package/src/workspace/headless/layout-memory.ts

@@ -1,649 +0,0 @@
-/**
- * Layout memory: everything about "how did I leave this window" that is not
- * user data or agent configuration.
- *
- * Three tiers, one API. The sidebar is not here: it lists every project's
- * sessions, so its width and collapsed state are global to the window
- * (the appearance store). The panel / terminal / Files-tree layout is per
- * SESSION: a scope copies its PROJECT's (cwd) last-used layout, the
- * template, once (when it is created, or first shown: `adoptScopeLayout`)
- * and owns it from then on, so another session's change never moves it.
- * Every change is written to the scope's own record and, as the template
- * for scopes still to come, to the project. The new-chat draft owns none:
- * it shows the template live, and its session copies it when created. The Files tab's filters are per
- * project. What is open in the Files tab and the terminal tab order are
- * content, so they are the session's alone.
- *
- *   template   panelOpen panelTree panelWidth panelShare terminalOpen
- *              terminalHeight filesTreeOpen filesTreeWidth
- *   project    filesShowIgnored filesChangedOnly terminalHideAgent badgeOrder
- *   session    filesOpen filesActive terminalOrder
- *
- * Layouts are addressed by SCOPE ({@link LayoutScope}): a session, the
- * new-chat draft, or a project with no session. The project key is the
- * scope's root, qualified by the server for a server session; the per-view
- * fields are keyed by the scope key (a session's key, `draft:…`,
- * `project:…`). Session-keyed callers go through the session → scope
- * mapping the app feeds (`setSessionScopes`); a session without
- * a known scope falls back to a per-session project.
- *
- * Storage: one key of the injected `Storage` holding `{ projects, sessions }` (`sessions`
- * holds every scope's own fields; the name predates scopes). A project key
- * stored as the raw cwd is read as a fallback. Reads are validated field by field so a
- * stale blob never leaks an impossible state into React; older shapes
- * migrate on read (`parseLayout`). A scope's record lives until its session
- * is deleted (`forgetScopeLayout`, or the launch sweep for sessions gone
- * while this window was not looking: `sweepScopeLayouts`); a draft's moves
- * to the session it becomes, or goes when the draft is replaced. Writes are
- * read-modify-write: a window applies its op to what is stored now, so it
- * never writes back a stale copy it already saw replaced. The v1
- * per-session blob is read as a fallback so existing layouts carry over.
- *
- * `createLayoutMemory({ storage })` makes one memory (an app makes one per
- * window); `useScopeLayout` (`zidane-ui/workspace`) reads a scope's layout in a
- * component. Other windows' writes arrive as `storage` events.
- */
-import { LOCAL_HOST_KEY, parseSessionKey, TERMINAL_PANEL_ID } from 'zidane/chat/pure';
-
-import { parsePanelTree, panelTreeOf, type PanelTree } from './panel-tree';
-import { parseTree, treeTabs } from './tree';
-
-/**
- * What a layout is attached to: a folder, optionally bound to a session (or
- * to the new-chat draft that will become one). The desktop app's `Scope` has
- * this shape, so it passes its own.
- */
-export interface LayoutScope {
-  /** The project root (worktrees fold into their main checkout). */
-  root: string;
-  /** Where things open. */
-  cwd: string;
-  /** Bound to this session (its key). */
-  session?: string;
-  /** The new-chat draft's id (never together with `session`). */
-  draft?: string;
-  /** Where a bound session's files live when not on this machine. */
-  workspace?: string;
-}
-
-const DRAFT_PREFIX = 'draft:';
-const PROJECT_PREFIX = 'project:';
-
-/**
- * A scope's identity: the session key when bound, else `draft:<id>` or `project:<root>`.
- *
- * @param scope - The scope.
- */
-export function layoutScopeKey(scope: LayoutScope): string {
-  if (scope.session) return scope.session;
-  if (scope.draft) return `${DRAFT_PREFIX}${scope.draft}`;
-  return `${PROJECT_PREFIX}${scope.root}`;
-}
-
-const hasSession = (scope: LayoutScope): boolean => typeof scope.session === 'string';
-const sessionOfScopeKey = (key: string): string | null =>
-  key.startsWith(DRAFT_PREFIX) || key.startsWith(PROJECT_PREFIX) ? null : key;
-const draftOfScopeKey = (key: string): string | null =>
-  key.startsWith(DRAFT_PREFIX) ? key.slice(DRAFT_PREFIX.length) : null;
-
-/** The server a session key names; `null` for This computer. */
-function serverIdOf(session: string): string | null {
-  const { hostKey } = parseSessionKey(session);
-  return hostKey === LOCAL_HOST_KEY ? null : hostKey;
-}
-
-/**
- * The project a scope's shared layout lives under: the root, qualified by the server for a server
- * session (the same path on two hosts is two projects).
- *
- * @param scope - The scope.
- */
-export function layoutProjectKey(scope: LayoutScope): string {
-  // A folderless session has no project: its layout is its own.
-  if (!scope.root) return scope.session ? `session:${scope.session}` : `scope:${layoutScopeKey(scope)}`;
-  const server = scope.session ? serverIdOf(scope.session) : null;
-  return server ? `${server}\u001f${scope.root}` : scope.root;
-}
-
-const LEGACY_STORAGE_KEY = 'zg:layout:v1';
-
-/** The storage key the layouts live under. */
-export const LAYOUT_STORAGE_KEY = 'zg:layout:v2';
-
-/** How a scope's window was left: the side panel, the Files tab, the terminal drawer, the composer badges. */
-export interface SessionLayout {
-  /** The side panel is shown. */
-  panelOpen: boolean;
-  /** The side panel's tab groups, the focused one, and its active tab (`PanelTree`, `zidane-ui/workspace/headless`). */
-  panelTree: PanelTree;
-  /** The side panel's width (px); null = default. */
-  panelWidth: number | null;
-  /** Dragged past the chat's usual floor: the panel's share of the room beside the sidebar (`resolveLayout`, `zidane-ui/workspace/headless`). */
-  panelShare: number | null;
-  /** The files open in the Files tab. */
-  filesOpen: readonly string[];
-  /** The Files tab's active file. */
-  filesActive: string | null;
-  /** The Files tree shows ignored files. */
-  filesShowIgnored: boolean;
-  /** Files tab tree column width (px); null = default. */
-  filesTreeWidth: number | null;
-  /** The Files tab's tree column is shown. */
-  filesTreeOpen: boolean;
-  /** The Files tree shows changed files only. */
-  filesChangedOnly: boolean;
-  /** Terminal drawer under the chat column: shown. */
-  terminalOpen: boolean;
-  /** The terminal drawer's height (px; null = default). */
-  terminalHeight: number | null;
-  /** Terminal tabs in the user's dragged order (`zidane-ui/terminal/headless` order); per session, like its terminals. */
-  terminalOrder: readonly string[];
-  /** The terminal strip leaves the agent's terminals out (its robot toggle); per project, like the Files filters. */
-  terminalHideAgent: boolean;
-  /**
-   * The composer badges in the user's dragged order (`orderComposerBadges`);
-   * per project, so every conversation of the folder shows them alike.
-   */
-  badgeOrder: readonly string[];
-}
-
-/** A layout with every default (the side panel on Artifacts, closed). */
-export const EMPTY_LAYOUT: SessionLayout = {
-  panelOpen: false,
-  panelTree: panelTreeOf(['artifacts']),
-  panelWidth: null,
-  panelShare: null,
-  filesOpen: [],
-  filesActive: null,
-  filesShowIgnored: false,
-  filesTreeWidth: null,
-  filesTreeOpen: true,
-  filesChangedOnly: false,
-  terminalOpen: false,
-  terminalHeight: null,
-  terminalOrder: [],
-  terminalHideAgent: false,
-  badgeOrder: [],
-};
-
-const SESSION_FIELDS = ['filesOpen', 'filesActive', 'terminalOrder'] as const;
-type SessionField = (typeof SESSION_FIELDS)[number];
-const TEMPLATE_FIELDS = [
-  'panelOpen',
-  'panelTree',
-  'panelWidth',
-  'panelShare',
-  'terminalOpen',
-  'terminalHeight',
-  'filesTreeOpen',
-  'filesTreeWidth',
-] as const;
-type TemplateField = (typeof TEMPLATE_FIELDS)[number];
-type ProjectField = Exclude<keyof SessionLayout, SessionField | TemplateField>;
-const PROJECT_FIELDS = (Object.keys(EMPTY_LAYOUT) as (keyof SessionLayout)[]).filter(
-  (k): k is ProjectField =>
-    !(SESSION_FIELDS as readonly string[]).includes(k) && !(TEMPLATE_FIELDS as readonly string[]).includes(k),
-);
-
-const pick = <K extends keyof SessionLayout>(from: SessionLayout, keys: readonly K[]): Pick<SessionLayout, K> =>
-  Object.fromEntries(keys.map((k) => [k, from[k]])) as Pick<SessionLayout, K>;
-
-const strList = (v: unknown): string[] => (Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string') : []);
-const strOrNull = (v: unknown): string | null => (typeof v === 'string' ? v : null);
-const numOrNull = (v: unknown): number | null => (typeof v === 'number' && Number.isFinite(v) ? v : null);
-const shareOrNull = (v: unknown): number | null => {
-  const n = numOrNull(v);
-  return n !== null && n > 0 && n < 1 ? n : null;
-};
-
-/**
- * A stored layout, validated field by field; older shapes migrate (the flat tab strip, the bottom group).
- *
- * @param raw - What was stored (parsed JSON).
- */
-export function parseLayout(raw: unknown): SessionLayout {
-  if (!raw || typeof raw !== 'object') return EMPTY_LAYOUT;
-  const o = raw as Record<string, unknown>;
-  // Before the tree: the flat strip and its active tab.
-  const tabs = strList(o.panelTabs);
-  return {
-    panelOpen: o.panelOpen === true,
-    panelTree: parsePanelTree(o.panelTree, {
-      tabs: tabs.length > 0 ? tabs : treeTabs(EMPTY_LAYOUT.panelTree.root),
-      active: strOrNull(o.panelActiveId),
-    }),
-    panelWidth: numOrNull(o.panelWidth),
-    panelShare: shareOrNull(o.panelShare),
-    filesOpen: strList(o.filesOpen),
-    filesActive: strOrNull(o.filesActive),
-    filesShowIgnored: o.filesShowIgnored === true,
-    filesTreeWidth: numOrNull(o.filesTreeWidth),
-    filesTreeOpen: o.filesTreeOpen !== false,
-    filesChangedOnly: o.filesChangedOnly === true,
-    // A group under the chat column (`bottomTree`) briefly held the drawer: open while it held the Terminal.
-    terminalOpen:
-      o.terminalOpen === true || treeTabs(parseTree(o.bottomTree) ?? EMPTY_GROUP).includes(TERMINAL_PANEL_ID),
-    terminalHeight: numOrNull(o.terminalHeight ?? o.bottomHeight),
-    terminalOrder: strList(o.terminalOrder),
-    terminalHideAgent: o.terminalHideAgent === true,
-    badgeOrder: strList(o.badgeOrder),
-  };
-}
-
-const EMPTY_GROUP = panelTreeOf([]).root;
-
-/**
- * A stored record. Both scopes store full records; only their own fields are
- * read. `ownsLayout` marks a scope record holding its own template fields;
- * records written before per-session layouts lack it and read the
- * project's until the scope is adopted (`adoptScopeLayout`).
- */
-interface StoredLayout extends SessionLayout {
-  ownsLayout?: true;
-}
-
-interface Store {
-  projects: Record<string, StoredLayout>;
-  sessions: Record<string, StoredLayout>;
-}
-
-/** A changed layout, or a function of the layout stored right now. */
-export type LayoutPatch = Partial<SessionLayout>;
-
-/** Options of {@link createLayoutMemory}. */
-export interface LayoutMemoryOptions {
-  /** Where the layouts are kept, read on each access (`() => localStorage`). Reads and writes that throw are survived. */
-  storage: () => Pick<Storage, 'getItem' | 'setItem'>;
-  /** A write that failed (quota, disabled storage): the layout is kept for this window only. Default: a console warning. */
-  onSaveError?: (error: unknown) => void;
-}
-
-/** One window's layout memory; see the top of this file. */
-export interface LayoutMemory {
-  /** The session → scope mapping (every listed session's scope); layouts re-resolve when it changes. */
-  setSessionScopes(scopes: Iterable<LayoutScope>): void;
-  /** Session → project (cwd) pairs: the pre-scope form of `setSessionScopes` (root = cwd). */
-  setSessionProjects(pairs: Iterable<readonly [sessionId: string, cwd: string | null | undefined]>): void;
-  /** A session just created, before the list catches up: it resolves to its project and takes its own copy. */
-  registerSessionScope(scope: LayoutScope): void;
-  /** A session's layout (`EMPTY_LAYOUT` without one), through the mapping. */
-  getSessionLayout(sessionId: string | null): SessionLayout;
-  /** A scope's layout (`EMPTY_LAYOUT` without one); the same object until it changes. */
-  getScopeLayout(scope: LayoutScope | null): SessionLayout;
-  /** Give `scope` its own copy of the layout it shows now; no-op once it owns one. */
-  adoptScopeLayout(scope: LayoutScope): void;
-  /** Change a session's layout, through the mapping. */
-  updateSessionLayout(sessionId: string, change: LayoutPatch | ((current: SessionLayout) => LayoutPatch)): void;
-  /** Change a scope's layout; a function `change` reads the layout stored right now (read-modify-write). */
-  updateScopeLayout(scope: LayoutScope, change: LayoutPatch | ((current: SessionLayout) => LayoutPatch)): void;
-  /** Drop a session's (or scope's) own layout, e.g. when the session is deleted. */
-  forgetScopeLayout(target: string | LayoutScope): void;
-  /** A draft became a session: the draft's own fields move onto the session's record. */
-  moveScopeLayout(from: LayoutScope, to: LayoutScope): void;
-  /** Once per launch: drop the draft records and the records of local sessions `localSessions` no longer lists. */
-  sweepScopeLayouts(localSessions: () => Promise<readonly string[]>): Promise<void>;
-  /** Calls `listener` after any layout changed, in this window or another. Returns the unsubscribe. */
-  subscribeLayouts(listener: () => void): () => void;
-  /** The identity a scope's composed layout is cached under (what a reader keys its memo on). */
-  scopeLayoutId(scope: LayoutScope): string;
-  /** Forget the cache, the mapping and the snapshots (tests). */
-  reset(): void;
-}
-
-/**
- * A new layout memory over `options.storage`.
- *
- * @param options - The storage, and what to do when a write fails.
- */
-export function createLayoutMemory(options: LayoutMemoryOptions): LayoutMemory {
-  const onSaveError =
-    options.onSaveError ?? ((err: unknown) => console.warn('[zidane-ui] layout not saved (kept for this window)', err));
-  const readRaw = (key: string): string | null => {
-    try {
-      return options.storage().getItem(key);
-    } catch {
-      return null;
-    }
-  };
-
-  let cache: Store | undefined;
-  /** The stored text `cache` was read from (or written as): another window's write changes it. */
-  let cacheRaw: string | null = null;
-  let legacy: Record<string, SessionLayout> | undefined;
-  const listeners = new Set<() => void>();
-  /** Session key → its scope (fed by `SessionsProvider`, plus sessions registered at creation). */
-  let sessionScopes = new Map<string, LayoutScope>();
-  const registered = new Map<string, LayoutScope>();
-
-  function parseMap(raw: unknown): Record<string, StoredLayout> {
-    const out: Record<string, StoredLayout> = {};
-    if (raw && typeof raw === 'object') {
-      for (const [id, layout] of Object.entries(raw as Record<string, unknown>)) {
-        const owns = !!layout && typeof layout === 'object' && (layout as StoredLayout).ownsLayout === true;
-        out[id] = owns ? { ...parseLayout(layout), ownsLayout: true } : parseLayout(layout);
-      }
-    }
-    return out;
-  }
-
-  function parseJson(raw: string): unknown {
-    try {
-      return JSON.parse(raw) as unknown;
-    } catch {
-      return undefined;
-    }
-  }
-
-  function storedRaw(): string | null {
-    return readRaw(LAYOUT_STORAGE_KEY);
-  }
-
-  function load(): Store {
-    if (!cache) {
-      cacheRaw = storedRaw();
-      const v = (cacheRaw === null ? undefined : parseJson(cacheRaw)) as
-        Partial<Record<keyof Store, unknown>> | undefined;
-      cache = { projects: parseMap(v?.projects), sessions: parseMap(v?.sessions) };
-    }
-    return cache;
-  }
-
-  /** Before a write: what another window stored since our last read wins over our copy. */
-  function loadFresh(): Store {
-    if (cache && storedRaw() !== cacheRaw) {
-      cache = undefined;
-      notify();
-    }
-    return load();
-  }
-
-  function loadLegacy(): Record<string, SessionLayout> {
-    if (!legacy) {
-      const raw = readRaw(LEGACY_STORAGE_KEY);
-      legacy = parseMap(raw === null ? undefined : parseJson(raw));
-    }
-    return legacy;
-  }
-
-  function save(next: Store): void {
-    cache = next;
-    const raw = JSON.stringify(next);
-    try {
-      options.storage().setItem(LAYOUT_STORAGE_KEY, raw);
-      // Only once stored: `loadFresh` would otherwise take the unchanged storage for another window's write.
-      cacheRaw = raw;
-    } catch (err) {
-      onSaveError(err);
-    }
-    notify();
-  }
-
-  // Composed snapshots per scope; `useSyncExternalStore` needs a stable
-  // reference between writes. Dropped whenever the store or mapping changes,
-  // but a scope whose composed layout came out the same keeps its old object
-  // (`previous`): one scope's write, or the sessions list re-feeding the
-  // mapping, must not re-render every other scope's readers (PanelsProvider,
-  // SidePanel, the terminal drawer).
-  const snapshots = new Map<string, SessionLayout>();
-  const previous = new Map<string, SessionLayout>();
-  const PREVIOUS_KEPT = 64;
-
-  /** A scope's first-time defaults: without a session the strip starts on Files (artifacts are session-only). */
-  const UNBOUND_DEFAULT: SessionLayout = { ...EMPTY_LAYOUT, panelTree: panelTreeOf(['files']) };
-
-  function notify(): void {
-    for (const [key, layout] of snapshots) {
-      previous.delete(key);
-      previous.set(key, layout);
-    }
-    for (const key of previous.keys()) {
-      if (previous.size <= PREVIOUS_KEPT) break;
-      previous.delete(key);
-    }
-    snapshots.clear();
-    for (const l of listeners) l();
-  }
-
-  function sameScope(a: LayoutScope | undefined, b: LayoutScope): boolean {
-    return !!a && a.root === b.root && a.cwd === b.cwd && a.session === b.session && a.workspace === b.workspace;
-  }
-
-  /**
-   * Session → scope mapping. `SessionsProvider` keeps it current; layouts
-   * re-resolve on change so a session that just learned its folder adopts
-   * the project's layout.
-   */
-  function setSessionScopes(scopes: Iterable<LayoutScope>): void {
-    const next = new Map<string, LayoutScope>();
-    for (const scope of scopes) if (scope.session) next.set(scope.session, scope);
-    let same = next.size === sessionScopes.size;
-    if (same) for (const [id, scope] of next) if (!sameScope(sessionScopes.get(id), scope)) same = false;
-    if (same) return;
-    sessionScopes = next;
-    // Registered at creation and now listed: the list is authoritative.
-    for (const id of next.keys()) registered.delete(id);
-    notify();
-  }
-
-  /** Session → project (cwd) pairs: the pre-scope form of {@link setSessionScopes} (root = cwd). */
-  function setSessionProjects(pairs: Iterable<readonly [sessionId: string, cwd: string | null | undefined]>): void {
-    setSessionScopes([...pairs].flatMap(([session, cwd]) => (cwd ? [{ root: cwd, cwd, session }] : [])));
-  }
-
-  /**
-   * A session that just got created, before the sessions list catches up:
-   * its layout resolves to its project from the first render (no empty
-   * layout flash, no write to a per-session fallback key), and it takes its
-   * own copy of the project's template.
-   */
-  function registerSessionScope(scope: LayoutScope): void {
-    if (!scope.session || sameScope(sessionScopes.get(scope.session) ?? registered.get(scope.session), scope)) return;
-    registered.set(scope.session, scope);
-    notify();
-    adoptScopeLayout(scope);
-  }
-
-  function scopeOfKey(sessionId: string): LayoutScope {
-    return sessionScopes.get(sessionId) ?? registered.get(sessionId) ?? { root: '', cwd: '', session: sessionId };
-  }
-
-  function snapshotKey(scope: LayoutScope): string {
-    return `${layoutScopeKey(scope)}\u0000${layoutProjectKey(scope)}\u0000${scope.cwd}`;
-  }
-
-  function getSessionLayout(sessionId: string | null): SessionLayout {
-    if (!sessionId) return EMPTY_LAYOUT;
-    return getScopeLayout(scopeOfKey(sessionId));
-  }
-
-  /** The layout of a scope (EMPTY_LAYOUT without one). */
-  function getScopeLayout(scope: LayoutScope | null): SessionLayout {
-    if (!scope) return EMPTY_LAYOUT;
-    const key = snapshotKey(scope);
-    const hit = snapshots.get(key);
-    if (hit) return hit;
-    const composed = composeLayout(scope);
-    const old = previous.get(key);
-    const layout = old && JSON.stringify(old) === JSON.stringify(composed) ? old : composed;
-    snapshots.set(key, layout);
-    return layout;
-  }
-
-  /** The project record a scope reads, with the pre-scope keys (raw cwd, per-session) as fallbacks. */
-  function projectRecord(store: Store, scope: LayoutScope): SessionLayout | undefined {
-    const old = scope.session ? loadLegacy()[scope.session] : undefined;
-    // Raw-cwd keys are local paths now: a server session must not read this computer's project.
-    const local = !scope.session || !serverIdOf(scope.session);
-    return (
-      store.projects[layoutProjectKey(scope)] ??
-      (scope.cwd && local ? store.projects[scope.cwd] : undefined) ??
-      (scope.session ? store.projects[`session:${scope.session}`] : undefined) ??
-      old
-    );
-  }
-
-  /**
-   * Session fields from the scope's own record; template fields from it when
-   * it owns them, else from the project (its last-used layout), else defaults;
-   * project fields from the project.
-   */
-  function composeLayout(scope: LayoutScope): SessionLayout {
-    const store = load();
-    const fallback = hasSession(scope) ? EMPTY_LAYOUT : UNBOUND_DEFAULT;
-    const project = projectRecord(store, scope) ?? fallback;
-    const own: StoredLayout =
-      store.sessions[layoutScopeKey(scope)] ?? (scope.session ? loadLegacy()[scope.session] : undefined) ?? fallback;
-    if (project === fallback && own === fallback) return fallback;
-    return {
-      ...pick(project, PROJECT_FIELDS),
-      ...pick(own.ownsLayout ? own : project, TEMPLATE_FIELDS),
-      ...pick(own, SESSION_FIELDS),
-    };
-  }
-
-  /** A scope whose session is not known yet (no folder): nothing to copy from. */
-  const unresolved = (scope: LayoutScope): boolean => !scope.root && !scope.cwd;
-
-  /**
-   * Give `scope` its own copy of the layout it shows now (the project's
-   * template, for a scope that never had one), so later changes elsewhere in
-   * the project leave it alone. No-op once it owns one.
-   */
-  function adoptScopeLayout(scope: LayoutScope): void {
-    if (unresolved(scope) || scope.draft) return;
-    const store = loadFresh();
-    const key = layoutScopeKey(scope);
-    if (store.sessions[key]?.ownsLayout) return;
-    const sessions = { ...store.sessions, [key]: { ...composeLayout(scope), ownsLayout: true as const } };
-    save({ projects: store.projects, sessions });
-  }
-
-  function updateSessionLayout(
-    sessionId: string,
-    change: LayoutPatch | ((current: SessionLayout) => LayoutPatch),
-  ): void {
-    updateScopeLayout(scopeOfKey(sessionId), change);
-  }
-
-  /**
-   * Change a scope's layout. `change` may be a function of the layout stored
-   * right now (read-modify-write): what the panel's operations use, so a
-   * window acting on a stale copy never overwrites another's change.
-   */
-  function updateScopeLayout(
-    scope: LayoutScope,
-    change: LayoutPatch | ((current: SessionLayout) => LayoutPatch),
-  ): void {
-    const store = loadFresh();
-    const current = getScopeLayout(scope);
-    const merged = { ...current, ...(typeof change === 'function' ? change(current) : change) };
-    const changed = (keys: readonly (keyof SessionLayout)[]) =>
-      keys.some((k) => JSON.stringify(current[k]) !== JSON.stringify(merged[k]));
-    const projectChanged = changed(PROJECT_FIELDS);
-    const templateChanged = changed(TEMPLATE_FIELDS);
-    if (!projectChanged && !templateChanged && !changed(SESSION_FIELDS)) return;
-    const next: Store = { projects: { ...store.projects }, sessions: { ...store.sessions } };
-    const pk = layoutProjectKey(scope);
-    // Template fields land in both: the scope's own, and the project's last-used
-    // template for scopes still to come.
-    if (projectChanged || templateChanged || !next.projects[pk]) next.projects[pk] = merged;
-    // The draft keeps only its own fields: it reads the template live.
-    if (!scope.draft) next.sessions[layoutScopeKey(scope)] = { ...merged, ownsLayout: true };
-    else if (changed(SESSION_FIELDS)) next.sessions[layoutScopeKey(scope)] = merged;
-    save(next);
-  }
-
-  /** Drop a session's (or scope's) own layout, e.g. when the session is deleted. */
-  function forgetScopeLayout(target: string | LayoutScope): void {
-    const store = loadFresh();
-    const key = typeof target === 'string' ? target : layoutScopeKey(target);
-    if (!store.sessions[key]) return;
-    const sessions = { ...store.sessions };
-    delete sessions[key];
-    save({ projects: store.projects, sessions });
-  }
-
-  /**
-   * A draft became a session: the draft's own fields (open files, terminal
-   * order) move onto the session's record. Either order with
-   * `registerSessionScope` works: adopting keeps a record's own fields.
-   */
-  function moveScopeLayout(from: LayoutScope, to: LayoutScope): void {
-    const store = loadFresh();
-    const fromKey = layoutScopeKey(from);
-    const toKey = layoutScopeKey(to);
-    const record = store.sessions[fromKey];
-    if (!record || fromKey === toKey) return;
-    const base = store.sessions[toKey] ?? composeLayout(to);
-    const sessions = { ...store.sessions, [toKey]: { ...base, ...pick(record, SESSION_FIELDS) } };
-    delete sessions[fromKey];
-    save({ projects: store.projects, sessions });
-  }
-
-  /**
-   * Once per launch, in the main window: drop the records nothing can show
-   * again. Draft ids live for one window load, so every draft record found
-   * is abandoned; a session's goes once This computer no longer lists it
-   * (deleted from the TUI, or while the app was closed). `localSessions` is
-   * every session This computer has, archived and side ones included.
-   * Server sessions are left alone (their list is the server's), and so is
-   * whatever is written while the list loads.
-   */
-  async function sweepScopeLayouts(localSessions: () => Promise<readonly string[]>): Promise<void> {
-    const candidates = Object.keys(loadFresh().sessions).filter((key) => {
-      const session = sessionOfScopeKey(key);
-      return session ? !serverIdOf(session) : draftOfScopeKey(key) !== null;
-    });
-    if (candidates.length === 0) return;
-    const listed = new Set<string>(await localSessions());
-    const stale = candidates.filter((key) => !listed.has(key));
-    const store = loadFresh();
-    if (!stale.some((key) => store.sessions[key])) return;
-    const sessions = { ...store.sessions };
-    for (const key of stale) delete sessions[key];
-    save({ projects: store.projects, sessions });
-  }
-
-  /** Calls `listener` after any layout changed, in this window or another. Returns the unsubscribe. */
-  function subscribeLayouts(listener: () => void): () => void {
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-    };
-  }
-
-  // Other windows (standalone session windows) write the same store: their
-  // writes arrive as `storage` events; dropping the cache shows them to every reader.
-  if (typeof window !== 'undefined') {
-    window.addEventListener('storage', (e) => {
-      if (e.key !== LAYOUT_STORAGE_KEY || e.newValue === cacheRaw) return;
-      cache = undefined;
-      notify();
-    });
-  }
-
-  return {
-    setSessionScopes,
-    setSessionProjects,
-    registerSessionScope,
-    getSessionLayout,
-    getScopeLayout,
-    adoptScopeLayout,
-    updateSessionLayout,
-    updateScopeLayout,
-    forgetScopeLayout,
-    moveScopeLayout,
-    sweepScopeLayouts,
-    subscribeLayouts,
-    scopeLayoutId: snapshotKey,
-    reset() {
-      cache = undefined;
-      cacheRaw = null;
-      legacy = undefined;
-      sessionScopes = new Map();
-      registered.clear();
-      snapshots.clear();
-      previous.clear();
-    },
-  };
-}