@kabmo-labs/kabmo 0.0.0-stage → 0.0.1

package/src/shared/lib/workspace/panel-ids.test.ts

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Panel id guards: what a stored `layout.activeRightPanel` and a width-map key
+ * are allowed to be.
+ *
+ * These predicates are the only thing standing between a persisted blob and a
+ * layout that renders a view nobody asked for, so the interesting cases are the
+ * near-misses: a bare prefix, a stray segment, a non-string.
+ */
+
+import { test, expect, describe } from 'bun:test';
+import { isPanelId, pluginIdOf, pluginKeyOf, pluginPanelKey } from '@/shared/lib/workspace/panel-ids';
+
+describe('pluginPanelKey', () => {
+  test('builds the id from the plugin id', () => {
+    expect(pluginPanelKey('hello')).toBe('plugin:hello');
+  });
+});
+
+describe('pluginKeyOf', () => {
+  test('accepts a well-formed plugin key', () => {
+    expect(pluginKeyOf('plugin:hello')).toBe('plugin:hello');
+  });
+
+  test('rejects a bare prefix and an extra segment', () => {
+    expect(pluginKeyOf('plugin:')).toBeNull();
+    // The id used to carry a panel segment; a blob written then must not be
+    // adopted as a plugin id that no registry can report.
+    expect(pluginKeyOf('plugin:hello/greeter')).toBeNull();
+  });
+
+  test('rejects a built-in view id and a non-string', () => {
+    expect(pluginKeyOf('files')).toBeNull();
+    expect(pluginKeyOf(7)).toBeNull();
+    expect(pluginKeyOf(null)).toBeNull();
+  });
+});
+
+describe('pluginIdOf', () => {
+  test('unwraps the plugin id', () => {
+    expect(pluginIdOf('plugin:hello')).toBe('hello');
+    expect(pluginIdOf('files')).toBeNull();
+  });
+});
+
+describe('isPanelId', () => {
+  test('accepts every built-in view', () => {
+    expect(isPanelId('files')).toBe(true);
+    expect(isPanelId('wiki')).toBe(true);
+    expect(isPanelId('plan')).toBe(true);
+  });
+
+  test('accepts a plugin key', () => {
+    expect(isPanelId('plugin:hello')).toBe(true);
+  });
+
+  test('rejects an unknown view and a malformed plugin key', () => {
+    expect(isPanelId('nope')).toBe(false);
+    expect(isPanelId('plugin:')).toBe(false);
+    expect(isPanelId(undefined)).toBe(false);
+  });
+});

package/src/shared/lib/workspace/panel-ids.ts

@@ -0,0 +1,59 @@
+/**
+ * Panel ids: the built-in right-panel views plus the panels plugin code
+ * contributes.
+ *
+ * A plugin panel's id is `plugin:<pluginId>` — one string the layout stores,
+ * keys widths by, and resolves a component from. Keeping it a plain string
+ * rather than a second union member is what lets the activity bar, the mobile
+ * tab bar and the width map handle a plugin without each learning about it.
+ *
+ * There is no panel-id segment because a plugin contributes AT MOST ONE panel
+ * per slot: the layout gives it one activity-bar button and one editor tab, so
+ * a second id could never be reached.
+ */
+
+import { RIGHT_PANEL_TYPES, type RightPanelType } from '@/shared/lib/workspace/right-panels';
+
+/** Prefix every plugin-contributed panel id carries. */
+export const PLUGIN_PANEL_PREFIX = 'plugin:';
+
+/** `plugin:<pluginId>` for a plugin's contributed panel. */
+export function pluginPanelKey(pluginId: string): string {
+  return `${PLUGIN_PANEL_PREFIX}${pluginId}`;
+}
+
+/**
+ * The plugin id a panel id names, or null when `value` is not one.
+ *
+ * The segment must be non-empty: `plugin:` is the shape a truncated write or a
+ * half-typed value produces, and accepting it would key a width map and a
+ * component lookup on an id no registry can ever report.
+ */
+export function pluginKeyOf(value: unknown): string | null {
+  if (typeof value !== 'string' || !value.startsWith(PLUGIN_PANEL_PREFIX)) return null;
+  const rest = value.slice(PLUGIN_PANEL_PREFIX.length);
+  if (!rest || rest.includes('/')) return null;
+  return value;
+}
+
+/** The plugin id inside a panel id, or null. */
+export function pluginIdOf(value: unknown): string | null {
+  const key = pluginKeyOf(value);
+  return key ? key.slice(PLUGIN_PANEL_PREFIX.length) : null;
+}
+
+/**
+ * Whether a stored `layout.activeRightPanel` may be adopted on load.
+ *
+ * A plugin panel is accepted on the shape of its id alone: the registry is a
+ * network read and the slots exist only after a bundle has been imported, so
+ * requiring the panel to be present would drop a perfectly valid selection
+ * every time the server is slower than the first paint. A panel whose plugin
+ * has since been uninstalled renders its own "not installed" notice rather than
+ * falling back silently to Files.
+ */
+export function isPanelId(value: unknown): value is string {
+  return (RIGHT_PANEL_TYPES as readonly string[]).includes(value as string) || pluginKeyOf(value) !== null;
+}
+
+export type { RightPanelType };

package/src/shared/lib/workspace/panel-order.test.ts

@@ -0,0 +1,133 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The stored panel order: how it is read, laid over the catalog, and rewritten
+ * after a drag.
+ *
+ * Two properties are pinned because both fail SILENTLY. A read that accepts a
+ * malformed row (a duplicate, a non-string, an empty id) keys a rank map on an
+ * id no panel has, and the bar draws in an order nobody chose. And a commit that
+ * takes the drawn sequence verbatim DROPS every panel that was not on screen —
+ * the bar cannot drag what it does not draw — so a panel switched off for a
+ * moment comes back at the end of the list instead of where the user put it.
+ *
+ * Split from `workspace-modules.test.ts`, which is at the file-size ceiling.
+ */
+
+import { afterAll, afterEach, describe, expect, test } from 'bun:test';
+
+import { primeKabmoSettings, readKabmoSetting, writeSetting } from '@/shared/lib/settings/client';
+import {
+  PANEL_ORDER_SETTING_KEY,
+  mergeVisibleOrder,
+  movePanel,
+  readPanelOrder,
+  savePanelOrder,
+  sortPanels,
+} from '@/shared/lib/workspace/panel-order';
+
+const ORDER_KEY = PANEL_ORDER_SETTING_KEY;
+
+/** Every case starts from "nothing stored", which is what a fresh install sees. */
+function resetSettings(): void {
+  primeKabmoSettings({});
+}
+
+afterEach(() => {
+  resetSettings();
+});
+
+afterAll(() => {
+  // The settings snapshot is module state shared by every suite in one
+  // `bun test` process; leave it as close to how it was found as possible.
+  primeKabmoSettings({});
+});
+
+describe('readPanelOrder', () => {
+  test('nothing stored reads as the empty order', () => {
+    resetSettings();
+    expect(readPanelOrder()).toEqual([]);
+    writeSetting(ORDER_KEY, 'not-a-list');
+    expect(readPanelOrder()).toEqual([]);
+  });
+
+  test('a malformed row is filtered rather than keyed', () => {
+    resetSettings();
+    writeSetting(ORDER_KEY, ['git', 3, '', null, 'git', 'files']);
+    // The duplicate is dropped, not kept: a second rank for one id would make
+    // the comparison depend on which entry the sort happened to read.
+    expect(readPanelOrder()).toEqual(['git', 'files']);
+  });
+});
+
+describe('sortPanels', () => {
+  const panels = [{ id: 'a' }, { id: 'b' }, { id: 'c' }];
+
+  test('an empty order leaves the catalog as it was', () => {
+    expect(sortPanels(panels, []).map((p) => p.id)).toEqual(['a', 'b', 'c']);
+  });
+
+  test('named panels are ordered and unnamed ones are appended in place', () => {
+    // `c` is not named — a plugin installed after the order was written — so it
+    // keeps its catalog position at the END rather than being dropped.
+    expect(sortPanels(panels, ['b']).map((p) => p.id)).toEqual(['b', 'a', 'c']);
+  });
+
+  test('an id the catalog does not hold is ignored, not invented', () => {
+    expect(sortPanels(panels, ['gone', 'c', 'a']).map((p) => p.id)).toEqual(['c', 'a', 'b']);
+  });
+
+  test('a full order is honoured exactly', () => {
+    expect(sortPanels(panels, ['c', 'a', 'b']).map((p) => p.id)).toEqual(['c', 'a', 'b']);
+  });
+});
+
+describe('movePanel', () => {
+  const ids = ['a', 'b', 'c', 'd'];
+
+  test('dragging down lands the row where it was dropped', () => {
+    expect(movePanel(ids, 'a', 'c')).toEqual(['b', 'c', 'a', 'd']);
+  });
+
+  test('dragging up lands it above the row it was dropped on', () => {
+    expect(movePanel(ids, 'd', 'b')).toEqual(['a', 'd', 'b', 'c']);
+  });
+
+  test('an absent id or a no-op move returns a copy, not a mutation', () => {
+    const next = movePanel(ids, 'a', 'a');
+    expect(next).toEqual(ids);
+    expect(next).not.toBe(ids);
+    expect(movePanel(ids, 'nope', 'a')).toEqual(ids);
+  });
+});
+
+describe('mergeVisibleOrder', () => {
+  test('a reorder of the visible rows keeps the hidden ids in their slots', () => {
+    // `hidden` is switched off, so the bar drew [a, b, c] and the user moved c
+    // to the front. The hidden id keeps its position BETWEEN them.
+    const stored = ['a', 'hidden', 'b', 'c'];
+    expect(mergeVisibleOrder(stored, ['a', 'b', 'c'], ['c', 'a', 'b'])).toEqual(['c', 'hidden', 'a', 'b']);
+  });
+
+  test('a visible id the stored order never named is appended', () => {
+    // A plugin installed after the order was written: it has no slot to fill,
+    // so the reorder appends it rather than losing it.
+    expect(mergeVisibleOrder(['a', 'b'], ['a', 'b', 'new'], ['new', 'b', 'a'])).toEqual(['new', 'b', 'a']);
+  });
+
+  test('an empty stored order is exactly the drawn order', () => {
+    expect(mergeVisibleOrder([], ['a', 'b'], ['b', 'a'])).toEqual(['b', 'a']);
+  });
+});
+
+describe('savePanelOrder', () => {
+  test('a save round-trips through the settings snapshot', () => {
+    resetSettings();
+    savePanelOrder(['plan', 'git']);
+    expect(readKabmoSetting<string[]>(ORDER_KEY)).toEqual(['plan', 'git']);
+    expect(readPanelOrder()).toEqual(['plan', 'git']);
+  });
+});

package/src/shared/lib/workspace/panel-order.ts

@@ -0,0 +1,127 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The user's own order for the right-panel buttons.
+ *
+ * GLOBAL, in `app_settings`, for the same reason the sidebar's width is: the
+ * activity bar lists the same panels in every session — only the active
+ * highlight moves — so an order stored per session would reshuffle the bar the
+ * moment the user picked a different chat.
+ *
+ * The stored list is a PREFERENCE over ids, not a copy of the catalog. Two
+ * consequences follow, and both are the point:
+ *
+ * - A panel the list does not name is APPENDED, in the order the catalog
+ *   already had. A freshly installed plugin therefore appears immediately
+ *   instead of being hidden by an order written before it existed.
+ * - An id the list names but the catalog does not hold is simply not drawn —
+ *   and it is deliberately KEPT, so switching a panel off and on again (or
+ *   reinstalling a plugin) returns it to the place the user put it.
+ */
+
+import { readKabmoSetting, writeSetting } from '@/shared/lib/settings/client';
+
+/** `app_settings` key holding the panel ids in the user's order. */
+export const PANEL_ORDER_SETTING_KEY = 'omp_right_panel_order';
+
+/** The stored order, validated: strings only, no blanks, no duplicates. */
+export function readPanelOrder(): string[] {
+  const stored = readKabmoSetting<unknown>(PANEL_ORDER_SETTING_KEY);
+  if (!Array.isArray(stored)) return [];
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const value of stored) {
+    if (typeof value !== 'string' || !value || seen.has(value)) continue;
+    seen.add(value);
+    out.push(value);
+  }
+  return out;
+}
+
+/** Persist a dragged order. */
+export function savePanelOrder(ids: readonly string[]): void {
+  writeSetting(PANEL_ORDER_SETTING_KEY, [...ids]);
+}
+
+/**
+ * `panels` in the stored order, with everything the order does not name left in
+ * the relative order it arrived in.
+ *
+ * A stable partition, not a rank sort: a panel absent from the order has no
+ * rank, and giving it one (`Infinity`) is only the same thing if the comparison
+ * also keeps the ties in place — which is what the `index` tiebreaker below is
+ * for.
+ */
+export function sortPanels<T extends { id: string }>(panels: readonly T[], order: readonly string[]): T[] {
+  if (order.length === 0) return [...panels];
+  const rank = new Map<string, number>();
+  for (const [index, id] of order.entries()) if (!rank.has(id)) rank.set(id, index);
+  return panels
+    .map((panel, index) => ({ panel, index, rank: rank.get(panel.id) }))
+    .sort((a, b) => {
+      if (a.rank === undefined) return b.rank === undefined ? a.index - b.index : 1;
+      if (b.rank === undefined) return -1;
+      return a.rank - b.rank;
+    })
+    .map((entry) => entry.panel);
+}
+
+/**
+ * `ids` with `draggedId` moved onto `targetId`.
+ *
+ * The insertion point is the target's ORIGINAL index, which is what makes the
+ * gesture read the same in both directions: dragging down lands the item just
+ * BELOW the row it was dropped on (removing the dragged one shifted that row up
+ * by one), dragging up lands it just ABOVE it. Returns a copy when either id is
+ * absent, so a caller can hand the result straight to a state setter.
+ */
+export function movePanel(ids: readonly string[], draggedId: string, targetId: string): string[] {
+  const from = ids.indexOf(draggedId);
+  const to = ids.indexOf(targetId);
+  if (from < 0 || to < 0 || from === to) return [...ids];
+  const next = [...ids];
+  next.splice(from, 1);
+  next.splice(to, 0, draggedId);
+  return next;
+}
+
+/**
+ * A reorder of the panels that are ON SCREEN, written back over the stored
+ * order so the panels that are NOT on screen keep their places.
+ *
+ * A bar can only drag what it draws, and it does not draw a switched-off panel
+ * — so committing the drawn sequence verbatim would silently drop every hidden
+ * id from the stored order, and switching that panel back on would append it at
+ * the end instead of returning it to where the user put it.
+ *
+ * The rule is positional: the visible slots in `stored`, in order, are filled
+ * with `nextVisible`, in order. Both lists are the same set of ids, so this is
+ * exactly the reorder the user made; a visible id `stored` never named (a
+ * freshly installed plugin) is appended, and an id in `nextVisible` that is not
+ * in `stored` is appended after it.
+ */
+export function mergeVisibleOrder(
+  stored: readonly string[],
+  visibleIds: readonly string[],
+  nextVisible: readonly string[],
+): string[] {
+  const visible = new Set(visibleIds);
+  const pending = [...nextVisible];
+  const placed = new Set<string>();
+  const out: string[] = [];
+  for (const id of stored) {
+    if (!visible.has(id)) {
+      out.push(id);
+      continue;
+    }
+    const next = pending.shift();
+    if (next === undefined) continue;
+    placed.add(next);
+    out.push(next);
+  }
+  for (const id of pending) if (!placed.has(id)) out.push(id);
+  return out;
+}

package/src/shared/lib/workspace/panel-widths.test.ts

@@ -0,0 +1,276 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  DEFAULT_EDITOR_FRACTIONS,
+  MIN_CHAT_PANEL_WIDTH,
+  MIN_EDITOR_PANEL_WIDTH,
+  PAIR_MAX_FRACTION,
+  PAIR_MAX_TOTAL_FRACTION,
+  fillerMinWidth,
+  mergePanelWidths,
+  pairMaxSize,
+  resolvePanelWidth,
+  type PanelWidths,
+} from '@/shared/lib/workspace/panel-widths';
+import { DEFAULT_RIGHT_PANEL_FRACTION } from '@/shared/lib/workspace/right-panels';
+
+describe('mergePanelWidths', () => {
+  test('merging one view keeps every other remembered width', () => {
+    const stored = {
+      editor: { px: 620, fraction: 0.54 },
+      diff: { fraction: 0.6 },
+      right: { files: { px: 300, fraction: 0.26 }, git: { px: 260 } },
+    };
+
+    const merged = mergePanelWidths(stored, { right: { browser: { px: 804, fraction: 0.7 } } });
+
+    expect(merged.right).toEqual({
+      files: { px: 300, fraction: 0.26 },
+      git: { px: 260 },
+      browser: { px: 804, fraction: 0.7 },
+    });
+    expect(merged.editor).toEqual({ px: 620, fraction: 0.54 });
+    expect(merged.diff).toEqual({ fraction: 0.6 });
+  });
+
+  test('the retired sidebar slot is dropped, never carried', () => {
+    // A blob written while the sidebar still lived in this map holds a `left`;
+    // keeping it would leave a second answer for a width that is now global.
+    // Named const, not an inline cast: the runtime shape really is wider than
+    // `PanelWidths`, and this is the only place that fact is expressed.
+    const legacyBlob = { left: 351, editor: { px: 620 } } as unknown as PanelWidths;
+    const merged = mergePanelWidths(legacyBlob, { editor: { px: 700 } });
+
+    expect(merged).toEqual({ editor: { px: 700 } });
+    expect('left' in merged).toBe(false);
+  });
+
+  test('a patch adds a unit without discarding the one already stored', () => {
+    // A drag reports px + fraction together, but the conversion pass reports a
+    // fraction alone; it must not erase the px fallback it was derived from.
+    const merged = mergePanelWidths({ editor: { px: 620 } }, { editor: { fraction: 0.54 } });
+
+    expect(merged.editor).toEqual({ px: 620, fraction: 0.54 });
+  });
+
+  test('a resized panel replaces only its own slot', () => {
+    const merged = mergePanelWidths(
+      { editor: { px: 620 }, diff: { px: 900 }, right: { files: { px: 300 } } },
+      { editor: { px: 480, fraction: 0.4 } },
+    );
+
+    expect(merged).toEqual({
+      editor: { px: 480, fraction: 0.4 },
+      diff: { px: 900 },
+      right: { files: { px: 300 } },
+    });
+  });
+});
+
+describe('resolvePanelWidth', () => {
+  const base = {
+    defaultFraction: 0.6,
+    defaultPx: 600,
+    min: 320,
+    siblingWidth: 0,
+    handleCount: 0,
+  };
+
+  test('opens at its default share of the measured area', () => {
+    expect(resolvePanelWidth({ ...base, available: 1000 })).toBe(600);
+  });
+
+  test('falls back to the pixel width before the area is known', () => {
+    // Not zero: a panel whose area has not been measured yet must still render
+    // at the width it is supposed to open at.
+    expect(resolvePanelWidth({ ...base, available: null })).toBe(600);
+    expect(resolvePanelWidth({ ...base, available: null, stored: { px: 512 } })).toBe(512);
+  });
+
+  test('a px-only value holds its pixel width; only a fraction follows the area', () => {
+    // The conversion is an identity (`px / available * available`), which is
+    // the point: a pixel value someone chose is honoured as written rather than
+    // being rescaled behind their back. It stops following the window only
+    // until that slot is dragged once, which stores a fraction alongside it.
+    expect(resolvePanelWidth({ ...base, available: 1000, stored: { px: 480 } })).toBe(480);
+    expect(resolvePanelWidth({ ...base, available: 2000, stored: { px: 480 } })).toBe(480);
+    // With both units stored, the fraction is what the panel follows.
+    expect(resolvePanelWidth({ ...base, available: 2000, stored: { px: 480, fraction: 0.24 } })).toBe(480);
+    expect(resolvePanelWidth({ ...base, available: 2000, stored: { px: 480, fraction: 0.3 } })).toBe(600);
+  });
+
+  test('a stored fraction beats the default share', () => {
+    // 0.45 of 1000 is 450: above the 320 floor and below the 0.6 default, so
+    // the result can only come from the stored fraction.
+    expect(resolvePanelWidth({ ...base, available: 1000, stored: { px: 480, fraction: 0.45 } })).toBe(450);
+  });
+
+  test('the ceiling leaves the chat its floor, the siblings theirs, and the handles their width', () => {
+    const available = 2000;
+    // Group budget = 2000 − 400 chat − 320 sibling − 6 handles = 1274, but the
+    // panel's OWN cap (0.6 × 2000 = 1200) is tighter, so it binds.
+    const expected = Math.round(PAIR_MAX_FRACTION * available);
+
+    expect(resolvePanelWidth({ ...base, available, siblingWidth: 320, handleCount: 2, stored: { fraction: 0.9 } })).toBe(expected);
+  });
+
+  test('the floor wins over a ceiling squeezed below it', () => {
+    // A window too narrow for the chat floor, a sibling and this panel: the
+    // panel keeps its minimum and the row clips, rather than collapsing.
+    expect(resolvePanelWidth({ ...base, available: 400, siblingWidth: 320, handleCount: 2 })).toBe(320);
+  });
+});
+
+describe('the editor/right-panel pair', () => {
+  // The editor and the right panel share one budget: their combined share may
+  // not exceed PAIR_MAX_TOTAL_FRACTION, and neither may exceed PAIR_MAX_FRACTION
+  // alone. `WorkspacePanels` resolves the right panel first (reserving the
+  // editor's WANTED share), then the editor (reserving the right panel's ACTUAL
+  // width) — so an editor asking for more than its default makes the right
+  // panel give way first.
+  const available = 4000; // large enough that the pair cap binds, not the chat floor
+  const rightPanelMin = 200;
+
+  test('the defaults sum to the pair total', () => {
+    expect(DEFAULT_EDITOR_FRACTIONS.editor + DEFAULT_RIGHT_PANEL_FRACTION).toBeCloseTo(PAIR_MAX_TOTAL_FRACTION, 5);
+  });
+
+  test('the defaults hold: right 0.3, editor 0.4, pair 0.7', () => {
+    const editorReservePx = Math.round(DEFAULT_EDITOR_FRACTIONS.editor * available);
+    const right = resolvePanelWidth({
+      defaultFraction: DEFAULT_RIGHT_PANEL_FRACTION,
+      defaultPx: 268,
+      available,
+      min: rightPanelMin,
+      pairReservePx: editorReservePx,
+      siblingWidth: MIN_EDITOR_PANEL_WIDTH,
+      handleCount: 2,
+    });
+    const editor = resolvePanelWidth({
+      defaultFraction: DEFAULT_EDITOR_FRACTIONS.editor,
+      defaultPx: 600,
+      available,
+      min: MIN_EDITOR_PANEL_WIDTH,
+      pairReservePx: right,
+      siblingWidth: right,
+      handleCount: 2,
+    });
+    expect(right).toBe(Math.round(0.3 * available));
+    expect(editor).toBe(Math.round(0.4 * available));
+    expect(editor + right).toBe(Math.round(PAIR_MAX_TOTAL_FRACTION * available));
+  });
+
+  test('an editor asking past its default makes the right panel give way', () => {
+    // Editor wants 0.5; the right panel's cap becomes 0.7 − 0.5 = 0.2.
+    const editorReservePx = Math.round(0.5 * available);
+    const right = resolvePanelWidth({
+      defaultFraction: DEFAULT_RIGHT_PANEL_FRACTION,
+      defaultPx: 268,
+      available,
+      min: rightPanelMin,
+      pairReservePx: editorReservePx,
+      siblingWidth: MIN_EDITOR_PANEL_WIDTH,
+      handleCount: 2,
+    });
+    expect(right).toBe(Math.round(0.2 * available));
+    // The editor then keeps its 0.5 (pair cap = 0.7 − 0.2 = 0.5).
+    const editor = resolvePanelWidth({
+      stored: { fraction: 0.5 },
+      defaultFraction: DEFAULT_EDITOR_FRACTIONS.editor,
+      defaultPx: 600,
+      available,
+      min: MIN_EDITOR_PANEL_WIDTH,
+      pairReservePx: right,
+      siblingWidth: right,
+      handleCount: 2,
+    });
+    expect(editor).toBe(Math.round(0.5 * available));
+    expect(editor + right).toBe(Math.round(PAIR_MAX_TOTAL_FRACTION * available));
+  });
+
+  test('neither panel can exceed its own maximum while the other is open', () => {
+    // A right panel asking for 0.6 (its own max) beside an editor at 0.4:
+    // the pair cap holds it to 0.3.
+    const right = resolvePanelWidth({
+      stored: { fraction: PAIR_MAX_FRACTION },
+      defaultFraction: DEFAULT_RIGHT_PANEL_FRACTION,
+      defaultPx: 268,
+      available,
+      min: rightPanelMin,
+      pairReservePx: Math.round(DEFAULT_EDITOR_FRACTIONS.editor * available),
+      siblingWidth: MIN_EDITOR_PANEL_WIDTH,
+      handleCount: 2,
+    });
+    expect(right).toBe(Math.round(0.3 * available));
+  });
+
+  test('with the sibling closed, one panel may use its own maximum', () => {
+    const editor = resolvePanelWidth({
+      stored: { fraction: PAIR_MAX_FRACTION },
+      defaultFraction: DEFAULT_EDITOR_FRACTIONS.editor,
+      defaultPx: 600,
+      available,
+      min: MIN_EDITOR_PANEL_WIDTH,
+      pairReservePx: 0,
+      siblingWidth: 0,
+      handleCount: 1,
+    });
+    expect(editor).toBe(Math.round(PAIR_MAX_FRACTION * available));
+  });
+});
+
+describe('fillerMinWidth (the chat floor that actually fits)', () => {
+  test('a healthy group leaves the wish untouched', () => {
+    // 1400 − (right 420 + handle 3) leaves far more than the wish.
+    expect(fillerMinWidth({ available: 1400, reservedPx: 423 })).toBe(MIN_CHAT_PANEL_WIDTH);
+  });
+
+  test('a cramped group lowers the floor to what is left over', () => {
+    // The 922px-window case: group 595, right panel 420 + one handle 3.
+    expect(fillerMinWidth({ available: 595, reservedPx: 423 })).toBe(172);
+  });
+
+  test('a group with nothing left gives the filler no floor', () => {
+    // Reserving past the group must never yield a negative min-width.
+    expect(fillerMinWidth({ available: 300, reservedPx: 500 })).toBe(0);
+  });
+
+  test('no measured area means the wish stands', () => {
+    expect(fillerMinWidth({ available: null, reservedPx: 423 })).toBe(MIN_CHAT_PANEL_WIDTH);
+    expect(fillerMinWidth({ available: 0, reservedPx: 423 })).toBe(MIN_CHAT_PANEL_WIDTH);
+  });
+});
+
+describe('pairMaxSize (the drag cap)', () => {
+  const available = 4000;
+  const rightMin = 200;
+  const editorMin = MIN_EDITOR_PANEL_WIDTH;
+
+  test('a closed sibling leaves the panel its own cap', () => {
+    expect(pairMaxSize({ available, siblingMin: 0, siblingOpen: false })).toBe(Math.round(PAIR_MAX_FRACTION * available));
+  });
+
+  test('an open sibling reserves its FLOOR, so the panel can grow past its current width', () => {
+    // Right panel's floor is 200; the editor may grow to 0.7×4000 − 200 = 2600,
+    // capped by its own 0.6×4000 = 2400. Reserving the sibling's WIDTH instead
+    // would pin this to the width it already has and freeze the separator.
+    expect(pairMaxSize({ available, siblingMin: rightMin, siblingOpen: true })).toBe(Math.round(PAIR_MAX_FRACTION * available));
+  });
+
+  test('the smaller of the own cap and the pair remainder wins', () => {
+    // A sibling whose floor is large (0.6 of the group) leaves only 0.1 — the
+    // pair remainder binds.
+    expect(pairMaxSize({ available, siblingMin: Math.round(0.6 * available), siblingOpen: true })).toBe(Math.round(0.1 * available));
+    // A negligible floor leaves the own cap 0.6 — that one binds.
+    expect(pairMaxSize({ available, siblingMin: 10, siblingOpen: true })).toBe(Math.round(PAIR_MAX_FRACTION * available));
+  });
+
+  test('no measured area means no cap', () => {
+    expect(pairMaxSize({ available: null, siblingMin: editorMin, siblingOpen: true })).toBeUndefined();
+  });
+});