@svgrid/grid 2.1.22 → 2.2.0

package/src/datetime/timezone.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest'
+import { zoneParts, zoneOffsetMs, toZonedLocal, fromZonedLocal, instantFromWallClock, normalizeTimeZone } from './timezone'
+
+const H = 3_600_000
+
+describe('timezone utils', () => {
+  // 2026-07-01 12:00 UTC (summer): NY = EDT (-4), Kolkata = +5:30, London = BST (+1)
+  const summer = new Date('2026-07-01T12:00:00Z')
+  // 2026-01-01 12:00 UTC (winter): NY = EST (-5), London = GMT (0)
+  const winter = new Date('2026-01-01T12:00:00Z')
+
+  it('zoneParts gives wall-clock in the target zone', () => {
+    expect(zoneParts(summer, 'America/New_York')).toMatchObject({ hour: 8, minute: 0 })
+    expect(zoneParts(summer, 'Asia/Kolkata')).toMatchObject({ hour: 17, minute: 30 })
+    expect(zoneParts(summer, 'Europe/London')).toMatchObject({ hour: 13, minute: 0 })
+    expect(zoneParts(winter, 'America/New_York')).toMatchObject({ hour: 7 })
+  })
+
+  it('zoneOffsetMs is DST-aware', () => {
+    expect(zoneOffsetMs(summer, 'America/New_York')).toBe(-4 * H)
+    expect(zoneOffsetMs(winter, 'America/New_York')).toBe(-5 * H)
+    expect(zoneOffsetMs(summer, 'Asia/Kolkata')).toBe(5.5 * H)
+    expect(zoneOffsetMs(winter, 'Europe/London')).toBe(0)
+  })
+
+  it('toZonedLocal exposes the zone wall-clock via local getters', () => {
+    const z = toZonedLocal(summer, 'Asia/Kolkata')
+    expect(z.getHours()).toBe(17)
+    expect(z.getMinutes()).toBe(30)
+  })
+
+  it('fromZonedLocal round-trips back to the same instant', () => {
+    for (const tz of ['America/New_York', 'Asia/Kolkata', 'Europe/London', 'Australia/Sydney']) {
+      for (const inst of [summer, winter]) {
+        const back = fromZonedLocal(toZonedLocal(inst, tz), tz)
+        expect(back.getTime()).toBe(Math.floor(inst.getTime() / 1000) * 1000)
+      }
+    }
+  })
+
+  it('instantFromWallClock maps a zone wall-clock to the right instant', () => {
+    // 09:00 in New York on 2026-07-01 (EDT -4) === 13:00 UTC.
+    const inst = instantFromWallClock(2026, 7, 1, 9, 0, 0, 'America/New_York')
+    expect(inst.toISOString()).toBe('2026-07-01T13:00:00.000Z')
+    // 09:00 in Kolkata (+5:30) === 03:30 UTC.
+    expect(instantFromWallClock(2026, 7, 1, 9, 0, 0, 'Asia/Kolkata').toISOString()).toBe('2026-07-01T03:30:00.000Z')
+  })
+
+  it('handles the DST spring-forward edge without drifting', () => {
+    // US spring-forward 2026-03-08: 02:00 EST -> 03:00 EDT. 09:00 that day is EDT (-4).
+    const inst = instantFromWallClock(2026, 3, 8, 9, 0, 0, 'America/New_York')
+    expect(inst.toISOString()).toBe('2026-03-08T13:00:00.000Z')
+    // The round trip is stable for a post-transition instant.
+    const back = fromZonedLocal(toZonedLocal(inst, 'America/New_York'), 'America/New_York')
+    expect(back.getTime()).toBe(inst.getTime())
+  })
+
+  it('undefined zone is the identity (browser local)', () => {
+    expect(toZonedLocal(summer, undefined)).toBe(summer)
+    expect(fromZonedLocal(summer, undefined)).toBe(summer)
+    expect(zoneOffsetMs(summer, undefined)).toBe(-summer.getTimezoneOffset() * 60_000)
+  })
+
+  it('normalizeTimeZone rejects bad ids', () => {
+    expect(normalizeTimeZone('America/New_York')).toBe('America/New_York')
+    expect(normalizeTimeZone('Not/AZone')).toBeUndefined()
+    expect(normalizeTimeZone(undefined)).toBeUndefined()
+  })
+})

package/src/datetime/timezone.ts

@@ -0,0 +1,134 @@
+/**
+ * Pure, framework-free IANA-timezone helpers, built on `Intl` (no date library).
+ *
+ * The scheduler renders in a chosen `timeZone` via a "pseudo-local" trick:
+ * {@link toZonedLocal} turns an absolute instant into a Date whose *local*
+ * wall-clock equals the wall-clock in `timeZone`, so all the existing
+ * local-based date math (startOfDay, minuteOfDay, layout) runs unchanged; then
+ * {@link fromZonedLocal} converts a user edit back to a real instant. When
+ * `timeZone` is undefined every function is the identity on the browser's zone.
+ *
+ * These functions are DST-aware and take no ambient "now" (safe for the model /
+ * headless contexts that forbid `Date.now()`).
+ */
+
+export type ZoneParts = {
+  year: number
+  month: number // 1-12
+  day: number
+  hour: number // 0-23
+  minute: number
+  second: number
+}
+
+const fmtCache = new Map<string, Intl.DateTimeFormat>()
+function partsFormat(timeZone: string): Intl.DateTimeFormat {
+  let f = fmtCache.get(timeZone)
+  if (!f) {
+    f = new Intl.DateTimeFormat('en-US', {
+      timeZone,
+      hourCycle: 'h23',
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+    })
+    fmtCache.set(timeZone, f)
+  }
+  return f
+}
+
+/** The wall-clock parts of `instant` in `timeZone` (browser-local if undefined). */
+export function zoneParts(instant: Date, timeZone?: string): ZoneParts {
+  if (!timeZone) {
+    return {
+      year: instant.getFullYear(),
+      month: instant.getMonth() + 1,
+      day: instant.getDate(),
+      hour: instant.getHours(),
+      minute: instant.getMinutes(),
+      second: instant.getSeconds(),
+    }
+  }
+  const map: Record<string, number> = {}
+  for (const p of partsFormat(timeZone).formatToParts(instant)) {
+    if (p.type !== 'literal') map[p.type] = Number(p.value)
+  }
+  let hour = map.hour ?? 0
+  if (hour === 24) hour = 0 // some engines emit '24' for midnight under h23
+  return { year: map.year!, month: map.month!, day: map.day!, hour, minute: map.minute ?? 0, second: map.second ?? 0 }
+}
+
+/** Milliseconds `timeZone` is ahead of UTC at `instant` (DST-aware; negative west of UTC). */
+export function zoneOffsetMs(instant: Date, timeZone?: string): number {
+  if (!timeZone) return -instant.getTimezoneOffset() * 60_000
+  const p = zoneParts(instant, timeZone)
+  const asUtc = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second)
+  // `asUtc` reads the wall-clock as if it were UTC; its distance from the real
+  // instant (truncated to whole seconds, matching the parts' resolution) is the offset.
+  return asUtc - Math.floor(instant.getTime() / 1000) * 1000
+}
+
+/** An instant -> a Date whose LOCAL fields equal its wall-clock in `timeZone`. */
+export function toZonedLocal(instant: Date, timeZone?: string): Date {
+  if (!timeZone) return instant
+  const p = zoneParts(instant, timeZone)
+  return new Date(p.year, p.month - 1, p.day, p.hour, p.minute, p.second, instant.getMilliseconds())
+}
+
+/** The instant whose wall-clock in `timeZone` is the given Y-M-D H:M:S. */
+export function instantFromWallClock(
+  year: number,
+  month: number, // 1-12
+  day: number,
+  hour: number,
+  minute: number,
+  second = 0,
+  timeZone?: string,
+  ms = 0,
+): Date {
+  if (!timeZone) return new Date(year, month - 1, day, hour, minute, second, ms)
+  const wallUtc = Date.UTC(year, month - 1, day, hour, minute, second, ms)
+  // Assume the wall-clock is UTC, subtract the offset there, then correct once
+  // in case the candidate instant lands on the other side of a DST transition.
+  const off1 = zoneOffsetMs(new Date(wallUtc), timeZone)
+  let inst = new Date(wallUtc - off1)
+  const off2 = zoneOffsetMs(inst, timeZone)
+  if (off2 !== off1) inst = new Date(wallUtc - off2)
+  return inst
+}
+
+/** Inverse of {@link toZonedLocal}: a pseudo-local Date -> the real instant. */
+export function fromZonedLocal(pseudo: Date, timeZone?: string): Date {
+  if (!timeZone) return pseudo
+  return instantFromWallClock(
+    pseudo.getFullYear(),
+    pseudo.getMonth() + 1,
+    pseudo.getDate(),
+    pseudo.getHours(),
+    pseudo.getMinutes(),
+    pseudo.getSeconds(),
+    timeZone,
+    pseudo.getMilliseconds(),
+  )
+}
+
+/** Short zone name at `instant`, e.g. "EDT" / "GMT+5:30" - for a ruler header. */
+export function zoneAbbr(instant: Date, timeZone?: string): string {
+  if (!timeZone) return ''
+  const parts = new Intl.DateTimeFormat('en-US', { timeZone, hour: '2-digit', timeZoneName: 'short' }).formatToParts(instant)
+  return parts.find((p) => p.type === 'timeZoneName')?.value ?? ''
+}
+
+/** Validate an IANA zone id; returns it if usable, else undefined (falls back to local). */
+export function normalizeTimeZone(timeZone?: string): string | undefined {
+  if (!timeZone) return undefined
+  try {
+    new Intl.DateTimeFormat('en-US', { timeZone })
+    return timeZone
+  } catch {
+    return undefined
+  }
+}

package/src/dock-context.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared context for <SvDockLayout> and its recursive <DockNodeView>. Carries
+ * the pane-content snippet and the handful of callbacks the tree view needs, so
+ * the recursive renderer reaches them without prop-drilling through every level.
+ */
+import type { Snippet } from 'svelte'
+import type { DockPane, DockTabs, DockZone } from './dock-model'
+
+export type DockContext = {
+  /** Renders a pane's content. Called as `{@render pane(dockPane)}`. */
+  pane: Snippet<[DockPane]>
+  /**
+   * Optional stack-header controls for a leaf (maximize / auto-hide / pop-out /
+   * float), rendered once per leaf at the right of its tab strip.
+   */
+  leafActions?: Snippet<[DockTabs]>
+  /** Make tab `index` active in the given leaf. */
+  activate: (tabsId: string, index: number) => void
+  /** Close (remove) a pane. */
+  close: (paneId: string) => void
+  /** Start dragging a pane's tab to re-dock it. */
+  beginDrag: (event: PointerEvent, paneId: string, tabsId: string) => void
+  /** Commit new size weights for a group after a splitter drag. */
+  resize: (groupId: string, sizes: number[]) => void
+  /** Minimum pane size (px) along the split axis. */
+  minSize: () => number
+  /**
+   * The leaf the pointer is over while dragging, for the dock guide. `zone` is
+   * the guide chip under the pointer (drop docks there) or `null` (over the leaf
+   * but off the guide - the drop will float). `centerOnly` shows just the centre
+   * chip (floating windows accept tabs only).
+   */
+  dropTarget: () => { tabsId: string; zone: DockZone | null; centerOnly?: boolean } | null
+  /** The live tab-reorder target, for the insertion-line indicator. */
+  reorderTarget?: () => { tabsId: string; index: number } | null
+  /** Which side of each leaf the tab strip sits on. Default `'top'`. */
+  headerPosition?: () => 'top' | 'bottom' | 'left' | 'right'
+  /** The id of the currently focused leaf, for the active-panel highlight. */
+  focusedLeaf?: () => string | null
+  /** Keep inactive tabs mounted (hidden) so their content state persists. */
+  keepAlive?: () => boolean
+  /** For a single-pane leaf, suppress the redundant tab button (e.g. an auto-hide fly-out,
+   *  where the edge strip already names the panel). Leaf actions still render. */
+  hideSingleTab?: () => boolean
+}
+
+export const DOCK_CONTEXT = Symbol('svgrid-dock')

package/src/dock-manager-model.test.ts

@@ -0,0 +1,275 @@
+import { describe, expect, it } from 'vitest'
+import { pane, tabs, group, allPaneIds, type DockNode, type DockTabs } from './dock-model'
+import {
+  floatPane,
+  dockPaneOnto,
+  dockWindowOnto,
+  reorderTab,
+  autoHideLeaf,
+  autoHidePaneToSide,
+  pinAutoHidden,
+  closePane,
+  moveWindow,
+  resizeWindow,
+  bringToFront,
+  setWindowMinimized,
+  toggleWindowMaximized,
+  closeWindow,
+  autoHideWindow,
+  toggleMaximizeLeaf,
+  findLeafById,
+  addPaneToMain,
+  locatePane,
+  surfaceOfTabs,
+  allManagerPaneIds,
+  allManagerIds,
+  dedupeManagerNodeIds,
+  setManagerActive,
+  type DockManagerState,
+} from './dock-manager-model'
+
+function counter() {
+  let n = 0
+  return () => `m${n++}`
+}
+const rect = { x: 100, y: 100, width: 320, height: 240 }
+
+/** main = [A | B], no floats, no auto-hide. Returns the SHARED id generator so
+ *  follow-up ops mint ids from the same sequence (no collisions - mirrors how
+ *  SvDockManager uses a single genId). */
+function base(): { state: DockManagerState; A: DockTabs; B: DockTabs; g: () => string } {
+  const g = counter()
+  const A = tabs(g, [pane('a', 'A')])
+  const B = tabs(g, [pane('b', 'B')])
+  return { state: { main: group(g, 'row', [A, B]) as DockNode, floating: [], autoHide: [] }, A, B, g }
+}
+
+describe('floatPane', () => {
+  it('pops a pane into a floating window and collapses its old leaf', () => {
+    const { state, g } = base()
+    const next = floatPane(state, 'a', rect, g)
+    expect(next.floating).toHaveLength(1)
+    expect(next.floating[0]!.leaf.panes.map((p) => p.id)).toEqual(['a'])
+    // main collapsed to the bare B leaf.
+    expect(next.main?.type).toBe('tabs')
+    expect(allPaneIds(next.main!)).toEqual(['b'])
+    expect(locatePane(next, 'a')).toEqual({ kind: 'floating', windowId: next.floating[0]!.id })
+  })
+
+  it('is a no-op for a pane already alone in its float', () => {
+    const { state, g } = base()
+    const once = floatPane(state, 'a', rect, g)
+    const twice = floatPane(once, 'a', rect, g)
+    expect(twice).toBe(once)
+  })
+})
+
+describe('dockPaneOnto - cross surface', () => {
+  it('docks a floating pane back into a main leaf as a tab', () => {
+    const { state, B, g } = base()
+    const floated = floatPane(state, 'a', rect, g)
+    const docked = dockPaneOnto(floated, 'a', B.id, 'center', g)
+    expect(docked.floating).toHaveLength(0)
+    const leaf = docked.main as DockTabs
+    expect(leaf.panes.map((p) => p.id)).toEqual(['b', 'a'])
+  })
+
+  it('edge-docks within main', () => {
+    const { state, A, g } = base()
+    const floated = floatPane(state, 'a', rect, g) // main is now just B
+    // Re-dock A to the LEFT of B (A's old leaf id is gone; target B).
+    const bId = surfaceOfTabs(floated, (floated.main as DockTabs).id) === 'main' ? (floated.main as DockTabs).id : ''
+    const docked = dockPaneOnto(floated, 'a', bId, 'left', g)
+    expect(allPaneIds(docked.main!)).toEqual(['a', 'b'])
+    void A
+  })
+})
+
+describe('reorderTab', () => {
+  it('reorders tabs inside a leaf (main)', () => {
+    const g = counter()
+    const leaf = tabs(g, [pane('a', 'A'), pane('b', 'B'), pane('c', 'C')], 0)
+    const state: DockManagerState = { main: leaf, floating: [], autoHide: [] }
+    const next = reorderTab(state, leaf.id, 0, 2)
+    expect((next.main as DockTabs).panes.map((p) => p.id)).toEqual(['b', 'c', 'a'])
+    // active followed pane A.
+    expect((next.main as DockTabs).active).toBe(2)
+  })
+
+  it('reorders tabs inside a floating window', () => {
+    const { state, g } = base()
+    let s = floatPane(state, 'a', rect, g)
+    s = dockPaneOnto(s, 'b', s.floating[0]!.leaf.id, 'center', g) // float now [a, b]
+    const wid = s.floating[0]!.leaf.id
+    const next = reorderTab(s, wid, 0, 1)
+    expect(next.floating[0]!.leaf.panes.map((p) => p.id)).toEqual(['b', 'a'])
+  })
+})
+
+describe('auto-hide + pin', () => {
+  it('collapses a main leaf to an edge, then pins it back', () => {
+    const { state, B, g } = base()
+    const hidden = autoHideLeaf(state, B.id, 'right')
+    expect(hidden.autoHide).toHaveLength(1)
+    expect(hidden.autoHide[0]!.side).toBe('right')
+    expect(allPaneIds(hidden.main!)).toEqual(['a']) // only A left tiled
+    expect(allManagerPaneIds(hidden)).toEqual(['a', 'b']) // B still exists, hidden
+
+    const pinned = pinAutoHidden(hidden, hidden.autoHide[0]!.id, g)
+    expect(pinned.autoHide).toHaveLength(0)
+    expect(pinned.main?.type).toBe('group')
+    expect(allPaneIds(pinned.main!)).toEqual(['a', 'b']) // B re-docked on the right
+  })
+})
+
+describe('auto-hide to any of the 4 sides', () => {
+  it.each(['left', 'right', 'top', 'bottom'] as const)('collapses + pins back on the %s edge', (side) => {
+    const { state, B, g } = base()
+    const hidden = autoHideLeaf(state, B.id, side)
+    expect(hidden.autoHide[0]!.side).toBe(side)
+    const pinned = pinAutoHidden(hidden, hidden.autoHide[0]!.id, g)
+    const root = pinned.main as Extract<DockNode, { type: 'group' }>
+    expect(root.type).toBe('group')
+    // Row for left/right, column for top/bottom.
+    expect(root.direction).toBe(side === 'left' || side === 'right' ? 'row' : 'column')
+    expect(allPaneIds(pinned.main!).sort()).toEqual(['a', 'b'])
+  })
+
+  it('pins back with the requested size fraction (not 50/50)', () => {
+    const { state, B, g } = base()
+    const hidden = autoHideLeaf(state, B.id, 'right')
+    const pinned = pinAutoHidden(hidden, hidden.autoHide[0]!.id, g, 0.2)
+    const root = pinned.main as Extract<DockNode, { type: 'group' }>
+    // Right side => [content, pinnedLeaf]; the pinned leaf takes ~0.2.
+    expect(root.sizes[1]).toBeCloseTo(0.2, 1)
+    expect(root.sizes[0]).toBeCloseTo(0.8, 1)
+  })
+})
+
+describe('autoHidePaneToSide (drag a tab to an edge)', () => {
+  it('pulls a single pane out to an edge as its own entry', () => {
+    const g = counter()
+    const leaf = tabs(g, [pane('a', 'A'), pane('b', 'B')])
+    const s: DockManagerState = { main: leaf, floating: [], autoHide: [] }
+    const next = autoHidePaneToSide(s, 'a', 'bottom', g)
+    expect(next.autoHide).toHaveLength(1)
+    expect(next.autoHide[0]!.side).toBe('bottom')
+    expect(next.autoHide[0]!.leaf.panes.map((p) => p.id)).toEqual(['a'])
+    // 'b' stays in the tiled leaf.
+    expect(allPaneIds(next.main!)).toEqual(['b'])
+  })
+})
+
+describe('dockWindowOnto', () => {
+  it('docks a whole window edge-wise into main', () => {
+    const { state, A, g } = base()
+    const floated = floatPane(state, 'b', rect, g) // main = A, float = [B]
+    const wid = floated.floating[0]!.id
+    const next = dockWindowOnto(floated, wid, A.id, 'right', g)
+    expect(next.floating).toHaveLength(0)
+    expect(allPaneIds(next.main!)).toEqual(['a', 'b'])
+  })
+})
+
+describe('maximize a tiled leaf + addPaneToMain', () => {
+  it('toggles maximizedLeaf and finds a leaf by id', () => {
+    const { state, A } = base()
+    expect(findLeafById(state, A.id)?.id).toBe(A.id)
+    const on = toggleMaximizeLeaf(state, A.id)
+    expect(on.maximizedLeaf).toBe(A.id)
+    expect(toggleMaximizeLeaf(on, A.id).maximizedLeaf).toBeNull()
+  })
+
+  it('adds a pane into the first main leaf (or as main when empty)', () => {
+    const { state } = base()
+    const next = addPaneToMain(state, pane('z', 'Z'), counter())
+    expect(allManagerPaneIds(next)).toContain('z')
+    const empty: DockManagerState = { main: null, floating: [], autoHide: [] }
+    const filled = addPaneToMain(empty, pane('z', 'Z'), counter())
+    expect(filled.main?.type).toBe('tabs')
+    expect(allManagerPaneIds(filled)).toEqual(['z'])
+  })
+})
+
+describe('window controls', () => {
+  it('minimizes, maximizes (toggle), closes, and auto-hides a window', () => {
+    const { state, g } = base()
+    let s = floatPane(state, 'a', rect, g)
+    const wid = s.floating[0]!.id
+    s = setWindowMinimized(s, wid, true)
+    expect(s.floating[0]!.minimized).toBe(true)
+    s = toggleWindowMaximized(s, wid)
+    expect(s.floating[0]!.maximized).toBe(true)
+    expect(s.floating[0]!.minimized).toBe(false) // max clears min
+    s = toggleWindowMaximized(s, wid)
+    expect(s.floating[0]!.maximized).toBe(false)
+    // auto-hide the window to the left edge
+    s = autoHideWindow(s, wid, 'left', g)
+    expect(s.floating).toHaveLength(0)
+    expect(s.autoHide[0]!.side).toBe('left')
+    expect(s.autoHide[0]!.leaf.panes.map((p) => p.id)).toEqual(['a'])
+  })
+
+  it('closeWindow drops the window and its panes', () => {
+    const { state, g } = base()
+    const s = floatPane(state, 'a', rect, g)
+    const next = closeWindow(s, s.floating[0]!.id)
+    expect(next.floating).toHaveLength(0)
+    expect(allManagerPaneIds(next)).toEqual(['b'])
+  })
+})
+
+describe('window ops + close', () => {
+  it('moves, resizes, and restacks windows; closes a pane anywhere', () => {
+    const { state, g } = base()
+    let s = floatPane(state, 'a', rect, g)
+    const wid = s.floating[0]!.id
+    s = moveWindow(s, wid, 40, 60)
+    s = resizeWindow(s, wid, 500, 400)
+    expect(s.floating[0]).toMatchObject({ x: 40, y: 60, width: 500, height: 400 })
+    const z0 = s.floating[0]!.z
+    s = bringToFront(s, wid)
+    expect(s.floating[0]!.z).toBeGreaterThan(z0)
+    s = closePane(s, 'a')
+    expect(s.floating).toHaveLength(0)
+    expect(allManagerPaneIds(s)).toEqual(['b'])
+  })
+})
+
+describe('setManagerActive', () => {
+  it('sets active in a main leaf and in a float', () => {
+    const g = counter()
+    const leaf = tabs(g, [pane('a', 'A'), pane('b', 'B')], 0)
+    const s: DockManagerState = { main: leaf, floating: [], autoHide: [] }
+    expect((setManagerActive(s, leaf.id, 1).main as DockTabs).active).toBe(1)
+  })
+})
+
+describe('dedupeManagerNodeIds', () => {
+  it('reassigns duplicate node ids so keyed sibling lists never collide', () => {
+    // A restored workspace where two sibling leaves share a generated id (the id
+    // counter had reset across reloads) - the shape that threw each_key_duplicate.
+    const dup: DockManagerState = {
+      main: {
+        type: 'group', id: 'dm-1000000', direction: 'row', sizes: [0.5, 0.5],
+        children: [
+          { type: 'tabs', id: 'dm-1000000', panes: [pane('rail', 'Pages')], active: 0 },
+          { type: 'tabs', id: 'dm-1000000', panes: [pane('main', 'Canvas')], active: 0 },
+        ],
+      } as DockNode,
+      floating: [], autoHide: [],
+    }
+    const fixed = dedupeManagerNodeIds(dup)
+    const ids = allManagerIds(fixed)
+    // Every node id is now unique...
+    const nodeIds = ids.filter((i) => i.startsWith('dm-'))
+    expect(new Set(nodeIds).size).toBe(nodeIds.length)
+    // ...while pane ids (which key content) are preserved.
+    expect(allManagerPaneIds(fixed).sort()).toEqual(['main', 'rail'])
+  })
+
+  it('is value-equal on an already-unique workspace', () => {
+    const { state } = base()
+    expect(dedupeManagerNodeIds(state)).toBe(state)
+  })
+})