@pascal-app/editor 1.0.0-beta.3 → 1.0.0-beta.5

package/src/lib/inspector-card-mode.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  type InspectorCardMode,
+  resolveActiveExtension,
+  toggleCard,
+  toggleExtension,
+} from './inspector-card-mode'
+
+const collapsed: InspectorCardMode = { collapsed: true, activeExtensionId: null }
+const regular: InspectorCardMode = { collapsed: false, activeExtensionId: null }
+const engineering: InspectorCardMode = { collapsed: false, activeExtensionId: 'bones:eng' }
+
+// EITHER/OR contract (replaces #667's appended-section behavior): the
+// expanded card shows the regular controls OR one extension's content,
+// never both. These gates encode every transition of the mode machine.
+
+describe('toggleCard (chevron / header press)', () => {
+  test('folded card expands to the REGULAR controls — no extension', () => {
+    expect(toggleCard(collapsed)).toEqual(regular)
+  })
+
+  test('regular expanded card folds', () => {
+    expect(toggleCard(regular)).toEqual(collapsed)
+  })
+
+  test('extension mode returns to the regular controls, staying expanded', () => {
+    // The chevron exits extension mode first; it does NOT fold from there.
+    expect(toggleCard(engineering)).toEqual(regular)
+  })
+})
+
+describe('toggleExtension (header icon press)', () => {
+  test('folded card opens straight into extension-only mode', () => {
+    expect(toggleExtension(collapsed, 'bones:eng')).toEqual(engineering)
+  })
+
+  test('regular expanded card swaps to extension-only mode', () => {
+    expect(toggleExtension(regular, 'bones:eng')).toEqual(engineering)
+  })
+
+  test('pressing the ACTIVE extension icon again returns to regular mode', () => {
+    expect(toggleExtension(engineering, 'bones:eng')).toEqual(regular)
+  })
+
+  test('pressing another extension icon switches extension modes directly', () => {
+    expect(toggleExtension(engineering, 'other:ext')).toEqual({
+      collapsed: false,
+      activeExtensionId: 'other:ext',
+    })
+  })
+})
+
+describe('resolveActiveExtension', () => {
+  const bones = { id: 'bones:eng' }
+  const other = { id: 'other:ext' }
+  const extensions = [bones, other]
+
+  test('null id → regular mode (no extension)', () => {
+    expect(resolveActiveExtension(null, extensions)).toBeNull()
+  })
+
+  test('matching id → that extension fills the body', () => {
+    expect(resolveActiveExtension('bones:eng', extensions)).toBe(bones)
+    expect(resolveActiveExtension('other:ext', extensions)).toBe(other)
+  })
+
+  test('stale id (kind changed / plugin gated off) falls back to regular', () => {
+    expect(resolveActiveExtension('bones:eng', [])).toBeNull()
+    expect(resolveActiveExtension('gone:ext', extensions)).toBeNull()
+  })
+})
+
+describe('full user flows (QA script)', () => {
+  test('chevron → regular only; fold; icon → extension only; icon again → regular', () => {
+    let mode = collapsed
+    mode = toggleCard(mode) // chevron
+    expect(mode).toEqual(regular)
+    mode = toggleCard(mode) // fold
+    expect(mode).toEqual(collapsed)
+    mode = toggleExtension(mode, 'bones:eng') // bones icon
+    expect(mode).toEqual(engineering)
+    mode = toggleExtension(mode, 'bones:eng') // bones icon again
+    expect(mode).toEqual(regular)
+  })
+
+  test('extension mode exits via the chevron too', () => {
+    let mode = toggleExtension(collapsed, 'bones:eng')
+    expect(mode).toEqual(engineering)
+    mode = toggleCard(mode) // chevron
+    expect(mode).toEqual(regular)
+  })
+})

package/src/lib/inspector-card-mode.ts

@@ -0,0 +1,60 @@
+/**
+ * Mode machine for the floating inspector card (`PanelWrapper`).
+ *
+ * The card is in exactly one of three modes — the two expanded modes are
+ * EITHER/OR, never combined:
+ *
+ * - collapsed: header only;
+ * - regular: the node kind's own controls (`children`) — no plugin
+ *   inspector-extension sections appended;
+ * - extension: ONE plugin inspector-extension's content fills the body
+ *   (its own section chrome), the regular controls are hidden.
+ *
+ * Transitions:
+ * - chevron / header press ({@link toggleCard}): collapsed → regular,
+ *   regular → collapsed, extension → regular (exit extension mode first,
+ *   stay expanded);
+ * - extension icon press ({@link toggleExtension}): enters that
+ *   extension's mode from anywhere (expanding a folded card); pressing
+ *   the ACTIVE extension's icon again returns to regular.
+ */
+
+export interface InspectorCardMode {
+  /** Card folded to its header. */
+  collapsed: boolean
+  /** Extension whose content fills the body; null = regular controls. */
+  activeExtensionId: string | null
+}
+
+/** Chevron / header press. */
+export function toggleCard(mode: InspectorCardMode): InspectorCardMode {
+  // Folded → expand to the regular controls.
+  if (mode.collapsed) return { collapsed: false, activeExtensionId: null }
+  // Extension mode → back to the regular controls (stay expanded).
+  if (mode.activeExtensionId !== null) return { collapsed: false, activeExtensionId: null }
+  // Regular expanded → fold.
+  return { collapsed: true, activeExtensionId: null }
+}
+
+/** Header extension-icon press. */
+export function toggleExtension(mode: InspectorCardMode, extensionId: string): InspectorCardMode {
+  // The active extension's icon pressed again → back to the regular controls.
+  if (!mode.collapsed && mode.activeExtensionId === extensionId) {
+    return { collapsed: false, activeExtensionId: null }
+  }
+  // Anywhere else (folded, regular, another extension) → this extension only.
+  return { collapsed: false, activeExtensionId: extensionId }
+}
+
+/**
+ * The extension whose content should fill the card body, or null for the
+ * regular controls. A stale `activeExtensionId` (selection changed kind,
+ * plugin uninstalled, registry reset) safely falls back to regular mode.
+ */
+export function resolveActiveExtension<E extends { id: string }>(
+  activeExtensionId: string | null,
+  extensions: readonly E[],
+): E | null {
+  if (activeExtensionId === null) return null
+  return extensions.find((extension) => extension.id === activeExtensionId) ?? null
+}

package/src/lib/measurement-parser.ts

@@ -1,3 +1,6 @@
+// Must precede the lingo import: lingo clones its kind table with
+// structuredClone while its module body evaluates. See the file's own comment.
+import './structured-clone-fallback'
 import { type Kind, parseQuantity, quantity } from '@pascal-app/lingo'
 
 /**

package/src/lib/measurements.test.ts

@@ -75,6 +75,10 @@ describe('linear measurements', () => {
   test('formats metric measurements in whole millimeters', () => {
     expect(formatLinearMeasurement(3.456, 'metric', 'millimeters')).toBe('3456mm')
     expect(formatLinearMeasurement(-0.1524, 'metric', 'millimeters')).toBe('-152mm')
+    expect(formatLinearMeasurement(0.2, 'metric', 'millimeters')).toBe('200mm')
+    expect(formatLinearMeasurement(18.4, 'metric', 'millimeters')).toBe('18400mm')
+    expect(formatLinearMeasurement(0.0005, 'metric', 'millimeters')).toBe('1mm')
+    expect(formatLinearMeasurement(-0.0005, 'metric', 'millimeters')).toBe('-1mm')
   })
 
   test('formats imperial measurements as feet and inches', () => {

package/src/lib/paint-scope.test.ts

@@ -81,8 +81,8 @@ describe('paintScopeLabel', () => {
 function item(id: string, assetId: string): ItemNode {
   return { id, type: 'item', asset: { id: assetId } } as unknown as ItemNode
 }
-function slab(id: string, polygon: Array<[number, number]>): SlabNode {
-  return { id, type: 'slab', polygon } as unknown as SlabNode
+function slab(id: string, polygon: Array<[number, number]>, levelId = 'l1'): SlabNode {
+  return { id, type: 'slab', polygon, parentId: levelId } as unknown as SlabNode
 }
 function wall(
   id: string,
@@ -451,4 +451,60 @@ describe('resolvePaintScopeTargets', () => {
     })
     expect(keys(result).sort()).toEqual(['inA:surface', 'inB:surface'])
   })
+
+  it('slab room stops at the level boundary', () => {
+    // Stacked storeys share a footprint, so the upper slab's centroid sits inside
+    // the ground floor's space polygon. Painting downstairs must not reach it.
+    const ground = slab(
+      'ground',
+      [
+        [1, 1],
+        [3, 1],
+        [3, 3],
+        [1, 3],
+      ],
+      'l1',
+    )
+    const upstairs = slab(
+      'upstairs',
+      [
+        [1, 1],
+        [3, 1],
+        [3, 3],
+        [1, 3],
+      ],
+      'l2',
+    )
+    const footprint: Array<[number, number]> = [
+      [0, 0],
+      [10, 0],
+      [10, 10],
+      [0, 10],
+    ]
+    const result = resolve({
+      node: ground,
+      role: 'surface',
+      scope: 'room',
+      nodes: [ground, upstairs],
+      spaces: [
+        {
+          id: 's1',
+          levelId: 'l1',
+          polygon: footprint,
+          wallIds: [],
+          boundaryFaces: [],
+          isExterior: false,
+        },
+        {
+          id: 's2',
+          levelId: 'l2',
+          polygon: footprint,
+          wallIds: [],
+          boundaryFaces: [],
+          isExterior: false,
+        },
+      ],
+    })
+    expect(keys(result)).toEqual(['ground:surface'])
+  })
 })

package/src/lib/paint-scope.ts

@@ -355,13 +355,19 @@ export function resolvePaintScopeTargets(args: {
   if (node.type === 'slab' && scope === 'room') {
     const centroid = polygonCentroid((node as SlabNode).polygon)
     if (!centroid) return single
-    const space = Object.values(spaces).find((candidate) =>
-      pointInPolygon2D(centroid, candidate.polygon),
+    // Space polygons are per-level footprints, and stacked storeys share a
+    // footprint — so the level has to gate both the space lookup and the fan-out
+    // or one click paints the floor above too.
+    const levelId = node.parentId ?? resolveLevelId(node, nodes)
+    if (!levelId) return single
+    const space = Object.values(spaces).find(
+      (candidate) => candidate.levelId === levelId && pointInPolygon2D(centroid, candidate.polygon),
     )
     if (!space) return single
     return Object.values(nodes)
       .filter((other) => {
         if (other.type !== 'slab') return false
+        if ((other.parentId ?? resolveLevelId(other, nodes)) !== levelId) return false
         const otherCentroid = polygonCentroid((other as SlabNode).polygon)
         return otherCentroid != null && pointInPolygon2D(otherCentroid, space.polygon)
       })

package/src/lib/selection-routing.test.ts

@@ -30,7 +30,7 @@ describe('resolveSelectedIdsForNodeClick', () => {
       resolveSelectedIdsForNodeClick({
         baseSelectedIds: ['wall_1'],
         currentSelectedIds: [],
-        modifierKeys: { meta: true, ctrl: false, shift: false },
+        modifierKeys: { meta: true, ctrl: false, shift: false, alt: false },
         nodeId: 'item_1',
       }),
     ).toEqual(['wall_1', 'item_1'])
@@ -41,11 +41,22 @@ describe('resolveSelectedIdsForNodeClick', () => {
       resolveSelectedIdsForNodeClick({
         baseSelectedIds: ['wall_1', 'item_1'],
         currentSelectedIds: [],
-        modifierKeys: { meta: false, ctrl: false, shift: true },
+        modifierKeys: { meta: false, ctrl: false, shift: true, alt: false },
         nodeId: 'item_1',
       }),
     ).toEqual(['wall_1'])
   })
+
+  test('plain click expands session groups', () => {
+    expect(
+      resolveSelectedIdsForNodeClick({
+        currentSelectedIds: [],
+        modifierKeys: { meta: false, ctrl: false, shift: false, alt: false },
+        nodeId: 'item_2',
+        expandIdsForNode: () => ['item_2', 'item_1'],
+      }),
+    ).toEqual(['item_2', 'item_1'])
+  })
 })
 
 describe('emitCanvasNodeSelection', () => {
@@ -64,23 +75,27 @@ describe('emitCanvasNodeSelection', () => {
 
 describe('selectionModifiersFromEvent', () => {
   test('falls back to tracked modifier state when the click event omits keys', () => {
-    expect(selectionModifiersFromEvent({}, { meta: false, ctrl: true, shift: false })).toEqual({
+    expect(
+      selectionModifiersFromEvent({}, { meta: false, ctrl: true, shift: false, alt: false }),
+    ).toEqual({
       meta: false,
       ctrl: true,
       shift: false,
+      alt: false,
     })
   })
 
   test('prefers explicit event key state over stale tracked modifiers', () => {
     expect(
       selectionModifiersFromEvent(
-        { metaKey: false, ctrlKey: false, shiftKey: false },
-        { meta: true, ctrl: true, shift: true },
+        { metaKey: false, ctrlKey: false, shiftKey: false, altKey: false },
+        { meta: true, ctrl: true, shift: true, alt: true },
       ),
     ).toEqual({
       meta: false,
       ctrl: false,
       shift: false,
+      alt: false,
     })
   })
 })

package/src/lib/selection-routing.ts

@@ -10,6 +10,8 @@ export type SelectionModifierKeys = {
   meta: boolean
   ctrl: boolean
   shift: boolean
+  /** Alt alone: select one session-group member without expanding. */
+  alt: boolean
 }
 
 export type NodeSelectionTarget = {
@@ -59,17 +61,19 @@ export function selectionModifiersFromEvent(
     metaKey?: boolean
     ctrlKey?: boolean
     shiftKey?: boolean
+    altKey?: boolean
     nativeEvent?: {
       metaKey?: boolean
       ctrlKey?: boolean
       shiftKey?: boolean
+      altKey?: boolean
     }
   } | null,
   fallback?: Partial<SelectionModifierKeys>,
 ): SelectionModifierKeys {
   const fromEvent = (
     key: keyof SelectionModifierKeys,
-    eventKey: 'metaKey' | 'ctrlKey' | 'shiftKey',
+    eventKey: 'metaKey' | 'ctrlKey' | 'shiftKey' | 'altKey',
   ) => {
     if (typeof event?.[eventKey] === 'boolean') return event[eventKey]
     if (typeof event?.nativeEvent?.[eventKey] === 'boolean') return event.nativeEvent[eventKey]
@@ -80,6 +84,7 @@ export function selectionModifiersFromEvent(
     meta: fromEvent('meta', 'metaKey'),
     ctrl: fromEvent('ctrl', 'ctrlKey'),
     shift: fromEvent('shift', 'shiftKey'),
+    alt: fromEvent('alt', 'altKey'),
   }
 }
 
@@ -88,11 +93,14 @@ export function resolveSelectedIdsForNodeClick({
   currentSelectedIds,
   modifierKeys,
   nodeId,
+  expandIdsForNode,
 }: {
   baseSelectedIds?: readonly string[]
   currentSelectedIds: readonly string[]
   modifierKeys: SelectionModifierKeys
   nodeId: string
+  /** Session-group expand on plain click (not on modifier/Alt). */
+  expandIdsForNode?: (nodeId: string) => string[] | null
 }): string[] {
   if (isSelectionModifierActive(modifierKeys)) {
     const selectedIds = baseSelectedIds ?? currentSelectedIds
@@ -102,6 +110,12 @@ export function resolveSelectedIdsForNodeClick({
     return [...selectedIds, nodeId]
   }
 
+  if (modifierKeys.alt) {
+    return [nodeId]
+  }
+
+  const expanded = expandIdsForNode?.(nodeId)
+  if (expanded && expanded.length > 1) return expanded
   return [nodeId]
 }
 

package/src/lib/session-groups.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  canCreateSessionGroup,
+  createSessionGroup,
+  expandSessionGroupMembers,
+  liveSessionGroups,
+  nextSessionGroupId,
+  resetSessionGroupIdSerial,
+  type SessionSelectionGroup,
+  selectionIntersectsSessionGroup,
+  selectionMatchesSessionGroup,
+  ungroupSessionSelection,
+} from './session-groups'
+
+function group(id: string, memberIds: string[], label = id): SessionSelectionGroup {
+  return { id, memberIds, label }
+}
+
+describe('session-groups', () => {
+  test('createSessionGroup requires two live members', () => {
+    resetSessionGroupIdSerial()
+    expect(
+      createSessionGroup([], ['a'], { idFactory: () => 'g1', labelFactory: () => 'G1' }).created,
+    ).toBeNull()
+  })
+
+  test('create and expand and ungroup', () => {
+    resetSessionGroupIdSerial(0)
+    const { groups, created } = createSessionGroup([], ['a', 'b', 'c'], {
+      idFactory: () => 'g1',
+      labelFactory: () => 'Group 1',
+    })
+    expect(created?.memberIds).toEqual(['a', 'b', 'c'])
+    expect(expandSessionGroupMembers(groups, 'b')).toEqual(['b', 'a', 'c'])
+    expect(selectionMatchesSessionGroup(groups, ['a', 'b', 'c'])?.label).toBe('Group 1')
+    expect(canCreateSessionGroup(groups, ['a', 'b', 'c'])).toBe(false)
+    expect(canCreateSessionGroup(groups, ['a', 'b'])).toBe(true)
+    expect(ungroupSessionSelection(groups, ['a']).groups).toEqual([])
+  })
+
+  test('liveSessionGroups hides groups that fall under two live members', () => {
+    resetSessionGroupIdSerial(0)
+    expect(nextSessionGroupId()).toBe('session-group-1')
+    expect(liveSessionGroups([group('g1', ['a', 'gone'])], new Set(['a']))).toEqual([])
+    expect(liveSessionGroups([group('g1', ['a', 'b', 'gone'])], new Set(['a', 'b']))).toEqual([
+      group('g1', ['a', 'b']),
+    ])
+    expect(selectionIntersectsSessionGroup([group('g1', ['a', 'b'])], ['b'])).toBe(true)
+  })
+
+  test('a deleted member is excluded from reads but kept in membership for undo', () => {
+    const groups = [group('g1', ['a', 'b', 'c'], 'Suite')]
+
+    // `a` deleted: reads narrow to the survivors...
+    expect(expandSessionGroupMembers(groups, 'b', new Set(['b', 'c']))).toEqual(['b', 'c'])
+    // ...and `a` and `b` deleted drops the group below the floor, so it goes inert.
+    expect(expandSessionGroupMembers(groups, 'c', new Set(['c']))).toBeNull()
+    expect(selectionIntersectsSessionGroup(groups, ['c'], new Set(['c']))).toBe(false)
+
+    // Undo restores the nodes, and membership was never rewritten — so the whole
+    // group comes back. A destructive prune would have lost `a` (or the group).
+    expect(expandSessionGroupMembers(groups, 'a', new Set(['a', 'b', 'c']))).toEqual([
+      'a',
+      'b',
+      'c',
+    ])
+  })
+
+  test('ungroup leaves inert groups alone so undo can revive them', () => {
+    const groups = [group('g1', ['a', 'b'], 'Pair')]
+    // Only `a` is live, so the group is invisible to the user — Ctrl+Shift+G on
+    // `a` must not dissolve what it cannot see.
+    const result = ungroupSessionSelection(groups, ['a'], new Set(['a']))
+    expect(result.dissolved).toEqual([])
+    expect(result.groups).toEqual(groups)
+  })
+
+  test('grouping a member of an existing group dissolves that group whole', () => {
+    resetSessionGroupIdSerial(0)
+    const groups = [group('g1', ['a', 'b', 'c'], 'Suite')]
+    const { groups: next, created } = createSessionGroup(groups, ['c', 'd'], {
+      idFactory: () => 'g2',
+      labelFactory: () => 'Group 2',
+    })
+    expect(created?.memberIds).toEqual(['c', 'd'])
+    expect(next).toEqual([group('g2', ['c', 'd'], 'Group 2')])
+  })
+})

package/src/lib/session-groups.ts

@@ -0,0 +1,201 @@
+/**
+ * Pure helpers for editor-only session selection groups.
+ * Not scene-graph nodes; not saved with the project.
+ * Ctrl/Cmd+G creates, Ctrl/Cmd+Shift+G dissolves; plain click expands.
+ *
+ * Stored membership is never rewritten to drop deleted nodes — `liveIds`
+ * filtering happens on every read instead. A destructive prune would make
+ * delete-then-undo lose the restored node's group, and would drop the group
+ * outright once it fell under the two-member floor.
+ */
+
+export type SessionSelectionGroup = {
+  id: string
+  memberIds: readonly string[]
+  label: string
+}
+
+export type SessionGroupIdFactory = () => string
+
+let sessionGroupSerial = 0
+
+export function nextSessionGroupId(): string {
+  sessionGroupSerial += 1
+  return `session-group-${sessionGroupSerial}`
+}
+
+export function nextSessionGroupLabel(): string {
+  return `Group ${Math.max(1, sessionGroupSerial)}`
+}
+
+export function resetSessionGroupIdSerial(value = 0): void {
+  sessionGroupSerial = value
+}
+
+function uniquePreserveOrder(ids: readonly string[]): string[] {
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const id of ids) {
+    if (!id || seen.has(id)) continue
+    seen.add(id)
+    out.push(id)
+  }
+  return out
+}
+
+function isLive(id: string, liveIds?: ReadonlySet<string> | null): boolean {
+  if (!liveIds) return true
+  return liveIds.has(id)
+}
+
+function withLabel(
+  group: SessionSelectionGroup,
+  memberIds: readonly string[],
+): SessionSelectionGroup {
+  return {
+    id: group.id,
+    label: group.label || 'Group',
+    memberIds,
+  }
+}
+
+function liveMembers(group: SessionSelectionGroup, liveIds?: ReadonlySet<string> | null): string[] {
+  return uniquePreserveOrder(group.memberIds.filter((id) => isLive(id, liveIds)))
+}
+
+/**
+ * Read-time view: groups narrowed to their live members, dropping any that fall
+ * under two. A group below the floor is inert, not gone — deleting members never
+ * touches storage, so undo brings it back.
+ */
+export function liveSessionGroups(
+  groups: readonly SessionSelectionGroup[],
+  liveIds?: ReadonlySet<string> | null,
+): SessionSelectionGroup[] {
+  const next: SessionSelectionGroup[] = []
+  for (const group of groups) {
+    const members = liveMembers(group, liveIds)
+    if (members.length < 2) continue
+    next.push(withLabel(group, members))
+  }
+  return next
+}
+
+export function createSessionGroup(
+  groups: readonly SessionSelectionGroup[],
+  memberIds: readonly string[],
+  options?: {
+    liveIds?: ReadonlySet<string> | null
+    idFactory?: SessionGroupIdFactory
+    labelFactory?: () => string
+  },
+): {
+  groups: SessionSelectionGroup[]
+  created: SessionSelectionGroup | null
+  alreadyGrouped: boolean
+} {
+  const liveIds = options?.liveIds
+  const members = uniquePreserveOrder(memberIds.filter((id) => isLive(id, liveIds)))
+  if (members.length < 2) {
+    return { groups: [...groups], created: null, alreadyGrouped: false }
+  }
+
+  const memberSet = new Set(members)
+  const exact = liveSessionGroups(groups, liveIds).find(
+    (group) =>
+      group.memberIds.length === members.length && group.memberIds.every((id) => memberSet.has(id)),
+  )
+  if (exact) {
+    return { groups: [...groups], created: exact, alreadyGrouped: true }
+  }
+
+  // Grouping a selection takes its members out of whatever group they were in,
+  // dissolving that group whole rather than leaving a remnant.
+  const kept = groups.filter((group) => !group.memberIds.some((id) => memberSet.has(id)))
+  const id = (options?.idFactory ?? nextSessionGroupId)()
+  const label =
+    options?.labelFactory?.() ??
+    (options?.idFactory ? `Group ${kept.length + 1}` : nextSessionGroupLabel())
+  const created: SessionSelectionGroup = { id, label, memberIds: members }
+  return { groups: [...kept, created], created, alreadyGrouped: false }
+}
+
+export function ungroupSessionSelection(
+  groups: readonly SessionSelectionGroup[],
+  selectedIds: readonly string[],
+  liveIds?: ReadonlySet<string> | null,
+): { groups: SessionSelectionGroup[]; dissolved: SessionSelectionGroup[] } {
+  const selected = new Set(selectedIds)
+  if (selected.size === 0) {
+    return { groups: [...groups], dissolved: [] }
+  }
+
+  const kept: SessionSelectionGroup[] = []
+  const dissolved: SessionSelectionGroup[] = []
+  for (const group of groups) {
+    // Only a live-viable group is visible to the user, so only that can be
+    // dissolved. An inert one (members deleted) is left alone for undo.
+    const live = liveMembers(group, liveIds)
+    if (live.length >= 2 && live.some((id) => selected.has(id))) {
+      dissolved.push(withLabel(group, live))
+    } else {
+      kept.push(group)
+    }
+  }
+  return { groups: kept, dissolved }
+}
+
+export function expandSessionGroupMembers(
+  groups: readonly SessionSelectionGroup[],
+  nodeId: string,
+  liveIds?: ReadonlySet<string> | null,
+): string[] | null {
+  if (!nodeId) return null
+  for (const group of groups) {
+    if (!group.memberIds.includes(nodeId)) continue
+    const members = liveMembers(group, liveIds)
+    if (members.length < 2) return null
+    if (members[0] === nodeId) return members
+    return [nodeId, ...members.filter((id) => id !== nodeId)]
+  }
+  return null
+}
+
+export function selectionMatchesSessionGroup(
+  groups: readonly SessionSelectionGroup[],
+  selectedIds: readonly string[],
+  liveIds?: ReadonlySet<string> | null,
+): SessionSelectionGroup | null {
+  if (selectedIds.length < 2) return null
+  const selected = uniquePreserveOrder(selectedIds.filter((id) => isLive(id, liveIds)))
+  if (selected.length < 2) return null
+  const selectedSet = new Set(selected)
+  for (const group of liveSessionGroups(groups, liveIds)) {
+    if (group.memberIds.length !== selected.length) continue
+    if (group.memberIds.every((id) => selectedSet.has(id))) return group
+  }
+  return null
+}
+
+export function selectionIntersectsSessionGroup(
+  groups: readonly SessionSelectionGroup[],
+  selectedIds: readonly string[],
+  liveIds?: ReadonlySet<string> | null,
+): boolean {
+  if (selectedIds.length === 0) return false
+  const selected = new Set(selectedIds)
+  for (const group of liveSessionGroups(groups, liveIds)) {
+    if (group.memberIds.some((id) => selected.has(id))) return true
+  }
+  return false
+}
+
+export function canCreateSessionGroup(
+  groups: readonly SessionSelectionGroup[],
+  selectedIds: readonly string[],
+  liveIds?: ReadonlySet<string> | null,
+): boolean {
+  const live = uniquePreserveOrder(selectedIds.filter((id) => isLive(id, liveIds)))
+  if (live.length < 2) return false
+  return selectionMatchesSessionGroup(groups, live, liveIds) === null
+}