zidane-ui 9.0.4 → 9.1.3

package/src/workspace/headless/tree.ts

@@ -1,480 +0,0 @@
-/**
- * The side panel's layout tree: tab groups arranged in nested splits.
- *
- * GUI-only. The core `PanelState` (shared with the TUI) still knows one
- * flat strip and one active tab; here the strip is split into groups, each
- * with its own tabs and active tab, laid out in rows ('row': side by side)
- * and columns ('col': stacked). Tabs are panel ids and appear at most once
- * in the whole tree.
- *
- * Every operation is pure and returns a normalised tree: no empty group
- * (an emptied group collapses), no split with fewer than two children, no
- * split nested in one of the same direction, sizes positive and summing
- * to 1. The one exception is a tree with no tabs at all: a single empty
- * group, so there is always somewhere to pin the next tab.
- */
-
-/** How a split lays out its children: side by side (`row`) or stacked (`col`). */
-export type SplitDir = 'row' | 'col';
-
-/** A group of tabs: one strip, one body showing its active tab. */
-export interface PanelGroup {
-  /** Marks a group. */
-  t: 'group';
-  /** Its id (`g<n>`), never reused. */
-  id: string;
-  /** Its tab ids, in strip order. */
-  tabs: readonly string[];
-  /** The tab this group shows (null: its first). */
-  active: string | null;
-}
-
-/** Groups (or splits) side by side or stacked. */
-export interface PanelSplit {
-  /** Marks a split. */
-  t: 'split';
-  /** Its id (`s<n>`), never reused. */
-  id: string;
-  /** Side by side or stacked. */
-  dir: SplitDir;
-  /** Each child's share of the split, summing to 1. */
-  sizes: readonly number[];
-  /** Its children, top/left first. */
-  children: readonly PanelNode[];
-}
-
-/** A node of the group tree. */
-export type PanelNode = PanelGroup | PanelSplit;
-
-/** Where a drop lands on a group: into it, or a new group on one of its edges. */
-export type DropZone = 'center' | 'left' | 'right' | 'top' | 'bottom';
-/** The edge a new group splits off at. */
-export type SplitSide = Exclude<DropZone, 'center'>;
-
-const FIRST_GROUP_ID = 'g1';
-
-export function singleGroup(tabs: readonly string[], active: string | null = null, id = FIRST_GROUP_ID): PanelGroup {
-  const unique = [...new Set(tabs)];
-  return { t: 'group', id, tabs: unique, active: active !== null && unique.includes(active) ? active : null };
-}
-
-/**
- * Every group, depth first (top/left to bottom/right).
- *
- * @param node - The tree.
- */
-export function groupsOf(node: PanelNode): PanelGroup[] {
-  return node.t === 'group' ? [node] : node.children.flatMap(groupsOf);
-}
-
-/**
- * Every tab in the tree, group by group.
- *
- * @param node - The tree.
- */
-export function treeTabs(node: PanelNode): string[] {
-  return groupsOf(node).flatMap((g) => g.tabs);
-}
-
-/**
- * The group holding `tabId`, or null.
- *
- * @param node - The tree.
- * @param tabId - The tab.
- */
-export function findGroup(node: PanelNode, tabId: string): PanelGroup | null {
-  return groupsOf(node).find((g) => g.tabs.includes(tabId)) ?? null;
-}
-
-export function groupById(node: PanelNode, id: string): PanelGroup | null {
-  return groupsOf(node).find((g) => g.id === id) ?? null;
-}
-
-/** A rectangle inside the unit square: a group's share of the region. */
-export interface Box {
-  x: number;
-  y: number;
-  w: number;
-  h: number;
-}
-
-/** The line between two children of a split: after child `index`, at `at` (0-1) along `box`, the split's own box. */
-export interface Divider {
-  splitId: string;
-  index: number;
-  dir: SplitDir;
-  box: Box;
-  at: number;
-}
-
-export type ShapeWithSizes =
-  | { t: 'group'; id: string }
-  | { t: 'split'; id: string; dir: SplitDir; sizes: readonly number[]; children: readonly ShapeWithSizes[] };
-
-/**
- * Where everything sits: each group's box in the unit square and every
- * divider. Groups drawn from these boxes never change parent when the
- * tree reshapes, so a split or a collapse never remounts one. `resized`
- * gives one split other shares (a divider mid-drag).
- */
-export function layoutBoxes(
-  node: ShapeWithSizes,
-  resized?: { splitId: string; sizes: readonly number[] },
-): { groups: Map<string, Box>; dividers: Divider[] } {
-  const groups = new Map<string, Box>();
-  const dividers: Divider[] = [];
-  const walk = (n: ShapeWithSizes, box: Box) => {
-    if (n.t === 'group') {
-      groups.set(n.id, box);
-      return;
-    }
-    let offset = 0;
-    const sizes = resized?.splitId === n.id ? resized.sizes : n.sizes;
-    n.children.forEach((child, i) => {
-      const size = sizes[i] ?? 1 / n.children.length;
-      if (i > 0) dividers.push({ splitId: n.id, index: i - 1, dir: n.dir, box, at: offset });
-      walk(
-        child,
-        n.dir === 'row'
-          ? { x: box.x + offset * box.w, y: box.y, w: size * box.w, h: box.h }
-          : { x: box.x, y: box.y + offset * box.h, w: box.w, h: size * box.h },
-      );
-      offset += size;
-    });
-  };
-  walk(node, { x: 0, y: 0, w: 1, h: 1 });
-  return { groups, dividers };
-}
-
-/** A split's shares, null when the tree has no such split. */
-export function splitSizes(node: ShapeWithSizes, splitId: string): readonly number[] | null {
-  if (node.t === 'group') return null;
-  if (node.id === splitId) return node.sizes;
-  for (const child of node.children) {
-    const hit = splitSizes(child, splitId);
-    if (hit) return hit;
-  }
-  return null;
-}
-
-function allIds(node: PanelNode): string[] {
-  return node.t === 'group' ? [node.id] : [node.id, ...node.children.flatMap(allIds)];
-}
-
-/** A fresh id with `prefix` (`g` groups, `s` splits), unused in the tree. */
-export function nextId(node: PanelNode, prefix: 'g' | 's'): string {
-  let max = 0;
-  for (const id of allIds(node)) {
-    const m = id.startsWith(prefix) ? Number(id.slice(prefix.length)) : NaN;
-    if (Number.isInteger(m) && m > max) max = m;
-  }
-  return `${prefix}${max + 1}`;
-}
-
-function fixSizes(sizes: readonly number[], n: number): number[] {
-  const ok = sizes.length === n && sizes.every((s) => Number.isFinite(s) && s > 0);
-  if (!ok) return Array.from({ length: n }, () => 1 / n);
-  const sum = sizes.reduce((a, b) => a + b, 0);
-  return sizes.map((s) => s / sum);
-}
-
-function sameSizes(a: readonly number[], b: readonly number[]): boolean {
-  return a.length === b.length && a.every((x, i) => Math.abs(x - b[i]!) < 1e-9);
-}
-
-/**
- * Restore the invariants (see the header). Tabs seen twice keep their first
- * place; a group's `active` not among its tabs becomes null.
- */
-export function normalize(node: PanelNode): PanelNode {
-  const seen = new Set<string>();
-  const firstGroupId = groupsOf(node)[0]?.id ?? FIRST_GROUP_ID;
-  const walk = (n: PanelNode): PanelNode | null => {
-    if (n.t === 'group') {
-      const tabs = n.tabs.filter((id) => !seen.has(id) && (seen.add(id), true));
-      if (tabs.length === 0) return null;
-      const active = n.active !== null && tabs.includes(n.active) ? n.active : null;
-      return tabs.length === n.tabs.length && active === n.active ? n : { ...n, tabs, active };
-    }
-    const sizes = fixSizes(n.sizes, n.children.length);
-    const children: PanelNode[] = [];
-    const childSizes: number[] = [];
-    n.children.forEach((c, i) => {
-      const out = walk(c);
-      if (!out) return;
-      // A split inside one of the same direction is one split: its children take its share.
-      if (out.t === 'split' && out.dir === n.dir) {
-        out.children.forEach((cc, j) => {
-          children.push(cc);
-          childSizes.push(sizes[i]! * out.sizes[j]!);
-        });
-      } else {
-        children.push(out);
-        childSizes.push(sizes[i]!);
-      }
-    });
-    if (children.length === 0) return null;
-    if (children.length === 1) return children[0]!;
-    const fixed = fixSizes(childSizes, children.length);
-    const same =
-      children.length === n.children.length &&
-      children.every((c, i) => c === n.children[i]) &&
-      sameSizes(fixed, n.sizes);
-    return same ? n : { ...n, sizes: fixed, children };
-  };
-  return walk(node) ?? { t: 'group', id: firstGroupId, tabs: [], active: null };
-}
-
-/**
- * A stored tree, validated; null when it is not one.
- *
- * @param raw - What was stored.
- */
-export function parseTree(raw: unknown): PanelNode | null {
-  const ids = new Set<string>();
-  const read = (v: unknown, depth: number): PanelNode | null => {
-    if (!v || typeof v !== 'object' || depth > 8) return null;
-    const o = v as Record<string, unknown>;
-    if (typeof o.id !== 'string' || !o.id || ids.has(o.id)) return null;
-    ids.add(o.id);
-    if (o.t === 'group') {
-      const tabs = Array.isArray(o.tabs) ? o.tabs.filter((x): x is string => typeof x === 'string') : [];
-      return { t: 'group', id: o.id, tabs, active: typeof o.active === 'string' ? o.active : null };
-    }
-    if (o.t !== 'split' || (o.dir !== 'row' && o.dir !== 'col') || !Array.isArray(o.children)) return null;
-    const children: PanelNode[] = [];
-    for (const c of o.children) {
-      const child = read(c, depth + 1);
-      if (!child) return null;
-      children.push(child);
-    }
-    const sizes = Array.isArray(o.sizes) ? o.sizes.map((s) => (typeof s === 'number' ? s : NaN)) : [];
-    return { t: 'split', id: o.id, dir: o.dir, sizes, children };
-  };
-  const tree = read(raw, 0);
-  return tree ? normalize(tree) : null;
-}
-
-function mapGroups(node: PanelNode, fn: (g: PanelGroup) => PanelGroup): PanelNode {
-  if (node.t === 'group') return fn(node);
-  let changed = false;
-  const children = node.children.map((c) => {
-    const out = mapGroups(c, fn);
-    if (out !== c) changed = true;
-    return out;
-  });
-  return changed ? { ...node, children } : node;
-}
-
-/** Show `tabId` in its group (no-op when absent or already shown). */
-export function activateTab(node: PanelNode, tabId: string): PanelNode {
-  return mapGroups(node, (g) => (g.tabs.includes(tabId) && g.active !== tabId ? { ...g, active: tabId } : g));
-}
-
-/** Add `tabId` at the end of `groupId` (default: the first group) unless the tree has it already. */
-export function pinTab(node: PanelNode, tabId: string, groupId?: string | null): PanelNode {
-  if (findGroup(node, tabId)) return node;
-  const target = (groupId && groupById(node, groupId)) || groupsOf(node)[0]!;
-  return mapGroups(node, (g) => (g.id === target.id ? { ...g, tabs: [...g.tabs, tabId] } : g));
-}
-
-/** The neighbour a group shows once `tabId` leaves it: the next tab, else the previous. */
-function withoutTab(g: PanelGroup, tabId: string): PanelGroup {
-  const i = g.tabs.indexOf(tabId);
-  if (i < 0) return g;
-  const tabs = g.tabs.filter((x) => x !== tabId);
-  const active = g.active === tabId ? (tabs[Math.min(i, tabs.length - 1)] ?? null) : g.active;
-  return { ...g, tabs, active };
-}
-
-/** Remove a tab; a group left empty collapses. */
-export function closeTab(node: PanelNode, tabId: string): PanelNode {
-  if (!findGroup(node, tabId)) return node;
-  return normalize(mapGroups(node, (g) => withoutTab(g, tabId)));
-}
-
-/** The tree restricted to the tabs `keep` accepts (what is on screen): groups left empty collapse. */
-export function filterTabs(node: PanelNode, keep: (tabId: string) => boolean): PanelNode {
-  return normalize(mapGroups(node, (g) => (g.tabs.every(keep) ? g : { ...g, tabs: g.tabs.filter(keep) })));
-}
-
-/** Replace a group's tab order (a strip reorder). Tabs not already in the group are ignored. */
-export function setGroupTabs(node: PanelNode, groupId: string, tabs: readonly string[]): PanelNode {
-  return mapGroups(node, (g) => {
-    if (g.id !== groupId) return g;
-    const next = tabs.filter((id) => g.tabs.includes(id));
-    const order = [...next, ...g.tabs.filter((id) => !next.includes(id))];
-    return order.every((id, i) => id === g.tabs[i]) ? g : { ...g, tabs: order };
-  });
-}
-
-/** Move a tab into another group (at `index`, default the end) and show it there. */
-export function moveTab(node: PanelNode, tabId: string, toGroupId: string, index?: number): PanelNode {
-  const from = findGroup(node, tabId);
-  const to = groupById(node, toGroupId);
-  if (!from || !to) return node;
-  const moved = mapGroups(node, (g) => {
-    const base = g.id === from.id ? withoutTab(g, tabId) : g;
-    if (g.id !== to.id) return base;
-    const tabs = [...base.tabs];
-    tabs.splice(Math.max(0, Math.min(index ?? tabs.length, tabs.length)), 0, tabId);
-    return { ...base, tabs, active: tabId };
-  });
-  return normalize(moved);
-}
-
-/**
- * Put `tabId` in `groupId` just before `before` (null: at the end) and show
- * it there: a strip drop, within its own group (a reorder) or from another.
- */
-export function placeTab(node: PanelNode, tabId: string, groupId: string, before: string | null): PanelNode {
-  const to = groupById(node, groupId);
-  if (!to || !findGroup(node, tabId) || before === tabId) return node;
-  const rest = to.tabs.filter((id) => id !== tabId);
-  const at = before === null ? -1 : rest.indexOf(before);
-  return moveTab(node, tabId, groupId, at < 0 ? rest.length : at);
-}
-
-/**
- * A tab dropped on a group's body: `center` moves it into the group, an edge
- * splits the group there (`ids`: see `splitTab`). Dropping a tab into its
- * own group only shows it.
- */
-export function dropOnGroup(node: PanelNode, tabId: string, groupId: string, zone: DropZone, ids?: NewIds): PanelNode {
-  const from = findGroup(node, tabId);
-  if (!from || !groupById(node, groupId)) return node;
-  if (zone !== 'center') return splitTab(node, tabId, zone, groupId, ids);
-  return from.id === groupId ? activateTab(node, tabId) : moveTab(node, tabId, groupId);
-}
-
-/** Ids for the group and split a split creates. */
-export interface NewIds {
-  group: string;
-  split: string;
-}
-
-const SIDE_DIR: Record<SplitSide, SplitDir> = { left: 'row', right: 'row', top: 'col', bottom: 'col' };
-
-/**
- * Take `tabId` out into a new group on `side` of `targetGroupId` (default:
- * its own group). A tab alone in its group cannot be split off its own group.
- * `ids` names the new group and split; by default the next ones unused in
- * the tree (which may be an id a removed group had).
- */
-export function splitTab(
-  node: PanelNode,
-  tabId: string,
-  side: SplitSide,
-  targetGroupId?: string,
-  ids?: NewIds,
-): PanelNode {
-  const from = findGroup(node, tabId);
-  const target = groupById(node, targetGroupId ?? from?.id ?? '');
-  if (!from || !target || (from.id === target.id && from.tabs.length < 2)) return node;
-  const fresh: PanelGroup = { t: 'group', id: ids?.group ?? nextId(node, 'g'), tabs: [tabId], active: tabId };
-  const dir = SIDE_DIR[side];
-  const before = side === 'left' || side === 'top';
-  const splitId = ids?.split ?? nextId(node, 's');
-  const place = (n: PanelNode): PanelNode => {
-    if (n.t === 'group') {
-      const base = n.id === from.id ? withoutTab(n, tabId) : n;
-      if (n.id !== target.id) return base;
-      return {
-        t: 'split',
-        id: splitId,
-        dir,
-        sizes: [0.5, 0.5],
-        children: before ? [fresh, base] : [base, fresh],
-      };
-    }
-    // Inside a split of the same direction, `normalize` flattens the new one: the target's share halves.
-    return { ...n, children: n.children.map(place) };
-  };
-  return normalize(place(node));
-}
-
-/** New shares for a split's children (a resize), normalised. */
-export function resizeSplit(node: PanelNode, splitId: string, sizes: readonly number[]): PanelNode {
-  if (node.t === 'group') return node;
-  if (node.id === splitId) {
-    const fixed = fixSizes(sizes, node.children.length);
-    return sameSizes(fixed, node.sizes) ? node : { ...node, sizes: fixed };
-  }
-  let changed = false;
-  const children = node.children.map((c) => {
-    const out = resizeSplit(c, splitId, sizes);
-    if (out !== c) changed = true;
-    return out;
-  });
-  return changed ? { ...node, children } : node;
-}
-
-function findSplit(node: PanelNode, id: string): PanelSplit | null {
-  if (node.t === 'group') return null;
-  if (node.id === id) return node;
-  for (const child of node.children) {
-    const hit = findSplit(child, id);
-    if (hit) return hit;
-  }
-  return null;
-}
-
-/**
- * Which child of the stored split `splitId` holds each child of that split
- * as shown (given as its groups' ids). Hidden tabs collapse groups and can
- * flatten a split into its parent: null unless every shown child sits in a
- * stored child of its own, in order.
- */
-export function shownSlots(stored: PanelNode, splitId: string, shown: readonly (readonly string[])[]): number[] | null {
-  const split = findSplit(stored, splitId);
-  if (!split || shown.length < 2) return null;
-  const holders = split.children.map((c) => new Set(groupsOf(c).map((g) => g.id)));
-  const slots = shown.map((ids) => holders.findIndex((h) => ids.length > 0 && ids.every((id) => h.has(id))));
-  return slots.every((s, i) => s >= 0 && (i === 0 || s > slots[i - 1]!)) ? slots : null;
-}
-
-/**
- * New shares for the shown children of split `splitId` (a divider drag),
- * applied to the stored split: hidden children keep their share, the shown
- * ones split the rest.
- */
-export function resizeShownSplit(
-  stored: PanelNode,
-  splitId: string,
-  shown: readonly (readonly string[])[],
-  sizes: readonly number[],
-): PanelNode {
-  const split = findSplit(stored, splitId);
-  const slots = shownSlots(stored, splitId, shown);
-  if (!split || !slots || sizes.length !== slots.length) return stored;
-  const current = fixSizes(split.sizes, split.children.length);
-  const room = slots.reduce((sum, s) => sum + current[s]!, 0);
-  const total = sizes.reduce((sum, s) => sum + s, 0);
-  if (!(total > 0)) return stored;
-  const next = [...current];
-  slots.forEach((s, i) => (next[s] = (sizes[i]! / total) * room));
-  return resizeSplit(stored, splitId, next);
-}
-
-/**
- * Which zone of a group's rect a point is over: the outer `edge` fraction
- * of each side splits, the middle drops into the group. Nearest edge wins
- * in the corners.
- */
-export function dropTarget(
-  rect: { left: number; top: number; width: number; height: number },
-  point: { x: number; y: number },
-  edge = 0.25,
-): DropZone {
-  if (rect.width <= 0 || rect.height <= 0) return 'center';
-  const fx = (point.x - rect.left) / rect.width;
-  const fy = (point.y - rect.top) / rect.height;
-  const near: [DropZone, number][] = [
-    ['left', fx],
-    ['right', 1 - fx],
-    ['top', fy],
-    ['bottom', 1 - fy],
-  ];
-  const [zone, distance] = near.reduce((a, b) => (b[1] < a[1] ? b : a));
-  return distance < edge ? zone : 'center';
-}

package/src/workspace/headless/view.ts

@@ -1,159 +0,0 @@
-/**
- * The layout as shown: the stored tree (`tree.ts`, `panel-tree.ts`)
- * restricted to the tabs the app offers here, each group's active tab
- * resolved. Pure.
- */
-import type { PanelContent, PanelIcon } from 'zidane/chat/pure';
-
-import { filterTabs, groupsOf, shownSlots, treeTabs, type PanelNode, type SplitDir } from './tree';
-
-/**
- * A tab the workspace can show. An app's own kinds are `builtin: true` and
- * render through its `WorkspaceTabRegistry`; `builtin: false` is an
- * extension panel whose content loads from `WorkspaceHost.panels`.
- * `zidane/chat/pure`'s `PanelTab` (the desktop app's catalog) is one.
- */
-export interface WorkspaceTab {
-  /** The tab's id: unique in the catalog, what the layout stores. */
-  id: string;
-  /** The pill's label. */
-  label: string;
-  /** The pill's icon (`gui`: an icon class). */
-  icon?: PanelIcon;
-  /** The app renders it; `false`: an extension panel. */
-  builtin: boolean;
-}
-
-/** One group of tabs on screen: its own strip and active tab. */
-export interface PanelGroupView<T extends WorkspaceTab = WorkspaceTab> {
-  /** Marks a group. */
-  t: 'group';
-  /** The stored group's id. */
-  id: string;
-  /** Its tabs offered here, in strip order. */
-  tabs: readonly T[];
-  /** The tab it shows. */
-  activeTab: T;
-}
-
-/** A split on screen: its children side by side (`row`) or stacked (`col`). */
-export interface PanelSplitView<T extends WorkspaceTab = WorkspaceTab> {
-  /** Marks a split. */
-  t: 'split';
-  /** The stored split's id. */
-  id: string;
-  /** Side by side or stacked. */
-  dir: SplitDir;
-  /** The children's shares as stored. */
-  sizes: readonly number[];
-  /** Its children on screen. */
-  children: readonly PanelViewNode<T>[];
-  /** Its dividers map onto the stored split (`shownSlots`); one hidden tabs flattened has none. */
-  resizable: boolean;
-}
-
-/** A node of the tree as shown. */
-export type PanelViewNode<T extends WorkspaceTab = WorkspaceTab> = PanelGroupView<T> | PanelSplitView<T>;
-
-/**
- * A tab has something for the user. `attention` is the warn-toned, pulsing
- * kind (the agent is waiting on an answer); `info` is a quiet count (open
- * todos). Kept per scope so a badge earned on one session never shows on
- * another and comes back when switching back.
- */
-export interface TabAttention {
-  /** The count on the badge. */
-  count: number;
-  /** Waiting on the user (warn-toned) or a quiet count. */
-  tone: 'attention' | 'info';
-  /** Something is happening in the tab right now (the agent driving the browser): a running arc, no count. */
-  live?: boolean;
-}
-
-/**
- * Whether two attentions show the same. `live` is part of the value: a flip from counting to "in use" must land.
- *
- * @param a - One attention.
- * @param b - The other.
- */
-export function sameAttention(a: TabAttention, b: TabAttention): boolean {
-  return a.count === b.count && a.tone === b.tone && (a.live === true) === (b.live === true);
-}
-
-/** An extension panel's last content, with its loading and pending flags. */
-export interface PanelContentEntry {
-  /** The last content loaded, or null. */
-  content: PanelContent | null;
-  /** A load is running. */
-  loading: boolean;
-  /** Content changed while the tab was not visible. */
-  pending: boolean;
-  /** Why the last load or action failed, in the extension's words; null when it did not. */
-  error: string | null;
-}
-
-/**
- * The tree as shown: only tabs the catalog offers here, groups left empty
- * collapsed, each group's active tab resolved (its pick, else its first).
- * With `fillEmpty` a strip whose tabs are all hidden here shows the
- * catalog's first tab instead (not stored until the user picks).
- *
- * @param tree - The stored tree.
- * @param catalog - The tabs offered here.
- * @param fillEmpty - Show the first offered tab when no stored tab is offered.
- */
-export function viewOf<T extends WorkspaceTab>(
-  tree: PanelNode,
-  catalog: readonly T[],
-  fillEmpty = false,
-): PanelViewNode<T> | null {
-  const byId = new Map(catalog.map((t) => [t.id, t]));
-  let shown = filterTabs(tree, (id) => byId.has(id));
-  if (treeTabs(shown).length === 0) {
-    if (!fillEmpty || catalog.length === 0) return null;
-    shown = { t: 'group', id: groupsOf(tree)[0]!.id, tabs: [catalog[0]!.id], active: null };
-  }
-  const build = (node: PanelNode): PanelViewNode<T> => {
-    if (node.t === 'split') {
-      const children = node.children.map(build);
-      const resizable = shownSlots(tree, node.id, children.map(groupIdsOf)) !== null;
-      return { t: 'split', id: node.id, dir: node.dir, sizes: node.sizes, children, resizable };
-    }
-    const tabs = node.tabs.map((id) => byId.get(id)!);
-    const activeTab = tabs.find((t) => t.id === node.active) ?? tabs[0]!;
-    return { t: 'group', id: node.id, tabs, activeTab };
-  };
-  return build(shown);
-}
-
-/**
- * Every group on screen, top/left to bottom/right.
- *
- * @param node - The tree as shown.
- */
-export function groupViews<T extends WorkspaceTab>(node: PanelViewNode<T>): PanelGroupView<T>[] {
-  return node.t === 'group' ? [node] : node.children.flatMap((child) => groupViews(child));
-}
-
-/**
- * The ids of every group under `node`, in order.
- *
- * @param node - The tree as shown.
- */
-export const groupIdsOf = (node: PanelViewNode<WorkspaceTab>): string[] => groupViews(node).map((g) => g.id);
-
-/**
- * The split `id` as shown, null when it is not on screen.
- *
- * @param node - The tree as shown.
- * @param id - The split.
- */
-export function splitView<T extends WorkspaceTab>(node: PanelViewNode<T>, id: string): PanelSplitView<T> | null {
-  if (node.t === 'group') return null;
-  if (node.id === id) return node;
-  for (const child of node.children) {
-    const hit = splitView(child, id);
-    if (hit) return hit;
-  }
-  return null;
-}

package/src/workspace/index.ts

@@ -1,22 +0,0 @@
-/**
- * `zidane-ui/workspace`: the side panel over a `WorkspaceHost`.
- * `WorkspaceProvider` (the layout of the scope on screen, its actions, the
- * extension panels' content and the badges) and its hooks, `SidePanel` (the
- * shell: tab groups drawn flat, their strips with drag and drop, the parked
- * tab bodies, the resize edge) with the app's `WorkspaceTabRegistry`,
- * `usePanelVisible` for tab bodies, and the window's horizontal budget
- * (`LayoutBudgetProvider`), the panel's key commands
- * (`useWorkspaceKeyCommands`). The React-free model is
- * `zidane-ui/workspace/headless`.
- */
-export * from './WorkspaceProvider';
-export * from './useWorkspaceLabels';
-export * from './SidePanel';
-export { type WorkspaceTabRegistry } from './TabParking';
-export * from './panel-visibility';
-export * from './LayoutBudget';
-export * from './useScopeLayout';
-export * from './PanelContentView';
-export * from './tab-scopes';
-export * from './panel-group-keys';
-export * from './workspace-key-commands';

package/src/workspace/panel-group-keys.ts

@@ -1,36 +0,0 @@
-/**
- * The side panel's tab groups from the keyboard: split the active tab into
- * a new group on the right or below. Only offered when it can act (a palette
- * lists what is offered): the panel is open and its focused group holds a
- * second tab.
- */
-import { useMemo } from 'react';
-
-import type { KeybindingHandlers } from '../keybindings/KeybindingsProvider';
-import { groupViews } from './headless/view';
-import { useWorkspaceActions, useWorkspaceView } from './WorkspaceProvider';
-
-/**
- * The `splitTabRight` / `splitTabDown` handlers for the {@link WorkspaceProvider} above, or none while they cannot act.
- *
- * @param enabled - The panel is this window's to drive (false: offer nothing).
- */
-export function usePanelGroupHandlers(enabled: boolean): KeybindingHandlers {
-  const actions = useWorkspaceActions();
-  const { state, tree, focusedGroupId, activeTab } = useWorkspaceView();
-  const open = enabled && state.open && !!tree;
-  const activeId = open ? (activeTab?.id ?? null) : null;
-  const canSplit =
-    !!activeId && !!tree && (groupViews(tree).find((g) => g.id === focusedGroupId)?.tabs.length ?? 0) > 1;
-
-  return useMemo(
-    () =>
-      canSplit && activeId
-        ? {
-            splitTabRight: () => actions.splitTab(activeId, 'right'),
-            splitTabDown: () => actions.splitTab(activeId, 'down'),
-          }
-        : {},
-    [actions, activeId, canSplit],
-  );
-}