@dashfoo/react 0.7.0 → 0.8.2

package/README.md

@@ -66,7 +66,7 @@ a sized parent and add your CSS (see the [attribute reference](#data-dashfoo-att
 | `onModelChange`           | `(model: Dashfoo, action?: Action) => void`                             | (none)  | Called after every change with the next model and the action that caused it.                                                                                                                                                                                                                                                                                                                                                                |
 | `components`              | `Record<string, ComponentType<{ node: TabNode }>>`                      | (none)  | Registry mapping `tab.component` keys to components.                                                                                                                                                                                                                                                                                                                                                                                        |
 | `factory`                 | `(tab: TabNode) => ReactNode`                                           | (none)  | Render override. When provided, it resolves every tab and `components` is ignored.                                                                                                                                                                                                                                                                                                                                                          |
-| `persist`                 | `string \| { key; storage?; debounceMs? }`                              | (none)  | Auto-save the model (uncontrolled mode only). A bare string is a localStorage key.                                                                                                                                                                                                                                                                                                                                                          |
+| `persist`                 | `string \| { key; storage?; debounceMs? }`                              | (none)  | Auto-save the model. The props type only accepts it alongside `defaultModel`. A bare string is a localStorage key.                                                                                                                                                                                                                                                                                                                          |
 | `onAction`                | `(action: Action) => Action \| null`                                    | (none)  | Intercept each action before it commits: return it, a replacement, or `null` to veto.                                                                                                                                                                                                                                                                                                                                                       |
 | `onActiveTabsetChange`    | `(id: string \| undefined) => void`                                     | (none)  | Fires when the active tabset changes.                                                                                                                                                                                                                                                                                                                                                                                                       |
 | `onMaximizedTabsetChange` | `(id: string \| undefined) => void`                                     | (none)  | Fires when a tabset is maximized or restored.                                                                                                                                                                                                                                                                                                                                                                                               |
@@ -265,20 +265,16 @@ _restructure_ on small screens, give `DashfooLayout` a `responsive` prop:
 ```
 
 At or below `maxWidth` (measured on the layout's own container, not the viewport),
-the layout renders as a single stacked column and **locks every structural
-interaction** (tab/tabset drag, split resize), leaving tap-to-switch and
-maximize. This mirrors VS Code: docking is a desktop interaction, so narrow
-screens get a read-only, navigable view instead of unusable hit targets.
+the layout renders as a single stacked column and **locks docking and split resizing** (tab/tabset drag, split resize), leaving tap-to-switch. Tabs remain selectable, closable and renamable; existing float controls remain available.
 
-The stacked view is a **derived projection**: the model in the store is never
-mutated, so the layout is never remounted and widening past `maxWidth` restores
+The stacked view is a **derived projection**: the projection does not replace the model in the store, and the row hierarchy stays mounted and widening past `maxWidth` restores
 the desktop arrangement exactly. Undo history, persistence, selection, and
 mounted panels all survive the breakpoint cross. The theme grows tab hit targets
 to 44px under `@media (pointer: coarse)` so tap-to-switch stays usable.
 
-Hand-built layouts (the `Layout.*` primitives) get the same behavior with
+Hand-built layouts (the `Layout.*` primitives) can compose a stacked view with
 `useContainerWidth` + `stackModel`; for _distinct_ per-breakpoint models, use
-`useResponsiveModel`. Both feed reactive props with no `key`/remount.
+`useResponsiveModel`. Both feed reactive props; changing the tree hierarchy can remount nested panels.
 
 ## Floating panels
 
@@ -356,7 +352,7 @@ const Layout = () => {
 a custom store (sessionStorage, in-memory, your own). A pending save flushes on
 unmount and on page hide (reload, tab close, navigation, the page going to the
 background), so the last change is never lost, even inside the debounce window.
-It applies to uncontrolled mode only; in controlled mode, save the model yourself
+The props type only accepts `persist` alongside `defaultModel`; in controlled mode, save the model yourself
 in `onModelChange`.
 
 The lower-level `usePersistence` load/save primitive (that `persist` is built on)
@@ -518,7 +514,7 @@ pattern as `Panel`:
 
 | Part                    | Element                                  | Role                                                                                                                        |
 | ----------------------- | ---------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
-| `Layout.Root`           | `div[data-dashfoo="layout"]`             | Creates the layout store. Takes `model`, `dispatch`, `renderTab`, and the chrome flags `DashfooLayout` accepts.             |
+| `Layout.Root`           | `div[data-dashfoo="layout"]`             | Creates the layout store. Takes `model`, `dispatch`, `renderers`, and the chrome flags `DashfooLayout` accepts.             |
 | `Layout.DragLayer`      | none (overlays)                          | Opts the tree into drag-dock. Omit it and everything else still works, just without dragging.                               |
 | `Layout.Rows`           | rrp split tree                           | Renders a `RowNode` recursively. `renderTabset` swaps in a custom tabset composition at every leaf.                         |
 | `Layout.Tabset`         | the stock `Tabset.*` composition         | The stock tabset composition, for leaves that don't need custom chrome.                                                     |
@@ -530,7 +526,7 @@ pattern as `Panel`:
 | `Tabset.Trigger`        | `button[data-dashfoo="tab"]`             | The tab button: select on click, rename on double-click, draggable. Children override the label.                            |
 | `Tabset.RenameInput`    | `input[data-dashfoo="tab-rename"]`       | Inline rename editor; renders only while its tab is being renamed.                                                          |
 | `Tabset.CloseButton`    | `button[data-dashfoo="tab-close"]`       | Closes the tab with focus restore; hides when the tab isn't closable.                                                       |
-| `Tabset.Content`        | `div[data-dashfoo="tabcontent"]`         | The `role="tabpanel"` pane(s); honors `keepMounted`. Children render-prop overrides `renderTab`.                            |
+| `Tabset.Content`        | `div[data-dashfoo="tabcontent"]`         | The `role="tabpanel"` pane(s); honors `keepMounted`. Children render-prop overrides `renderers.tab`.                        |
 | `Tabset.Toolbar`        | `div[data-dashfoo="tabset-toolbar"]`     | Trailing toolbar container.                                                                                                 |
 | `Tabset.OverflowMenu`   | menu button                              | Lists clipped tabs; hides when nothing overflows.                                                                           |
 | `Tabset.Grip`           | `button[data-dashfoo="tabset-grip"]`     | Drag handle for the whole tabset; hides when tabset dragging is off.                                                        |
@@ -571,7 +567,7 @@ const MyTabset = ({ node }: { node: TabsetNode }) => (
 const MyLayout = () => {
   const store = useDashfooStore({ defaultModel });
   return (
-    <Layout.Root dispatch={store.dispatch} model={store.model} renderTab={renderTab}>
+    <Layout.Root dispatch={store.dispatch} model={store.model} renderers={{ tab: renderTab }}>
       <Layout.DragLayer>
         <Layout.Rows node={store.model.layout} renderTabset={(node) => <MyTabset node={node} />} />
       </Layout.DragLayer>
@@ -613,6 +609,7 @@ type PanelTitleProps;
 // Layout primitives (build your own layout)
 Layout; // Layout.Root / Layout.DragLayer / Layout.Rows / Layout.Tabset
 type LayoutRootProps;
+type LayoutRenderers;
 type LayoutDragLayerProps;
 type LayoutRowsProps;
 type LayoutTabsetProps;
@@ -664,3 +661,19 @@ from `@dashfoo/core`.
 ## License
 
 MIT
+
+### Closable tab semantics and refs
+
+`data-dashfoo="tablist"` identifies the scrolling viewport. Inside it, a
+semantic `role="tablist"` owns the tab triggers by id using `aria-owns`.
+Close buttons and inline rename inputs are siblings in the accessibility tree,
+so they remain independently accessible without becoming invalid tablist children.
+Keep `Tabset.Trigger` inside `Tabset.Tab` and use the parts together; avoid
+styling the internal semantic marker. Native compound parts forward refs on
+React 18.3 and React 19. Docking itself remains pointer-only.
+
+The built-in compact projection retains nested row identities so mounted widget state survives ordinary breakpoint changes. Entering compact mode from a maximized view, moving a tab between tabsets, or supplying a different tree can remount content; keep durable application state outside panel components. The lower-level `stackModel` helper flattens the tree, so hand-composed layouts using it can also remount nested panels.
+
+`Tabset.Content` forwards its ref to the active panel, including when inactive panels are retained with `keepMounted`.
+
+Existing floats remain overlays in compact mode. Their displayed bounds fit the viewport without changing saved geometry; float controls remain available to minimize or dock them back.

package/dist/index.d.ts

@@ -52,10 +52,9 @@ type DashfooHandle = {
   selectTab: (tabsetId: string, index: number) => void;
   undo: () => void;
 };
-type DashfooLayoutProps = {
+type DashfooLayoutCommonProps = {
   closableTabs?: boolean;
   components?: Record<string, TabComponent>;
-  defaultModel?: Dashfoo;
   draggableTabs?: boolean;
   draggableTabsets?: boolean;
   editable?: boolean;
@@ -63,12 +62,10 @@ type DashfooLayoutProps = {
   floatable?: boolean;
   keepMounted?: boolean;
   maximizable?: boolean;
-  model?: Dashfoo;
   onAction?: (action: Action) => Action | null;
   onActiveTabsetChange?: (tabsetId: string | undefined) => void;
   onMaximizedTabsetChange?: (tabsetId: string | undefined) => void;
   onModelChange?: (model: Dashfoo, action?: Action) => void;
-  persist?: PersistInput;
   renamableTabs?: boolean;
   renderTabLabel?: (tab: TabNode) => ReactNode;
   renderTabsetToolbar?: (tabset: TabsetNode) => ReactNode;
@@ -79,9 +76,18 @@ type DashfooLayoutProps = {
   };
   snap?: SnapConfig;
 };
+type DashfooLayoutProps = DashfooLayoutCommonProps & ({
+  defaultModel: Dashfoo;
+  model?: never;
+  persist?: PersistInput;
+} | {
+  defaultModel?: never;
+  model: Dashfoo;
+  persist?: never;
+});
 declare const DashfooLayout: import("react").ForwardRefExoticComponent<DashfooLayoutProps & import("react").RefAttributes<DashfooHandle>>;
 //#endregion
-//#region src/components/drag-root.d.ts
+//#region src/components/dashfoo-drag-provider.d.ts
 declare const DashfooDragProvider: ({ children }: {
   children: ReactNode;
 }) => ReactNode;
@@ -96,33 +102,33 @@ declare const useExternalTabSource: ({ createTab, disabled, label }: ExternalTab
   ref: (element: Element | null) => void;
 };
 /**
- * Both drag readers are documented as working anywhere under the provider, which
- * includes a custom overlay mounted beside the layout rather than inside a drag
- * layer, so they read the root's actor. Outside a provider entirely there is no
- * actor to read and they report the empty state instead of throwing: a component
- * that renders both inside and outside a layout should not crash in one of them.
+ * Reads the root's actor, so it works from an overlay mounted beside the layout
+ * rather than inside a drag layer. Outside a provider it reports the empty state
+ * instead of throwing.
  */
 declare const useDragSubject: () => DragSubject | null;
 declare const useDropIntent: () => DropIntent | null;
 //#endregion
-//#region src/components/drag-adapter.d.ts
+//#region src/components/drag-provider.d.ts
 type DragProviderProps = {
   children: ReactNode;
   onCommit?: (action: Action) => void;
   splitDock?: boolean;
 };
+/**
+ * Mounts its own root when there is none above it. Decided on the first render:
+ * a root that disappears later means a torn-down tree, which `DragScope` reports.
+ */
+declare const DragProvider: (props: DragProviderProps) => ReactNode;
 //#endregion
 //#region src/components/float-layer.d.ts
 type FloatLayerProps = {
   children: ReactNode;
   floats: Array<FloatNode>;
-  /**
-   * Accepted for backwards compatibility only. Floating panels now inherit
-   * every global-derived capability from the layout store above them, so this
-   * is no longer read; it disappears in the next major.
-   */
+  /** Unread: floats inherit every global-derived capability from the layout store above them. */
   global?: GlobalAttributes;
 };
+declare const FloatLayer: ({ children, floats }: FloatLayerProps) => ReactNode;
 //#endregion
 //#region src/hooks/layout-store.d.ts
 type LayoutState = {
@@ -161,67 +167,75 @@ type LayoutRootProps = Omit<ComponentProps<"div">, "children"> & {
   maximizable?: boolean;
   model: Dashfoo;
   renamableTabs?: boolean;
-  renderTab: (tab: TabNode) => ReactNode;
-  renderTabLabel?: (tab: TabNode) => ReactNode;
-  renderTabsetToolbar?: (tabset: TabsetNode) => ReactNode;
+  renderers: LayoutRenderers;
   resizableSplits?: boolean;
   /** When false, the tree itself is frozen: no dragging, splitting or floating. Tabs stay closable and renamable. */
   restructurable?: boolean;
   rootRef?: Ref<HTMLDivElement>;
   snap?: SnapConfig;
 };
+type LayoutRenderers = {
+  tab: (tab: TabNode) => ReactNode;
+  tabLabel?: (tab: TabNode) => ReactNode;
+  tabsetToolbar?: (tabset: TabsetNode) => ReactNode;
+};
+declare const LayoutRoot: ({ children, closableTabs, dispatch, draggableTabs, draggableTabsets, editable, floatable, keepMounted, maximizable, model, renamableTabs, renderers, resizableSplits, restructurable, rootRef, snap, style, ...props }: LayoutRootProps) => ReactNode;
 //#endregion
 //#region src/components/row-view.d.ts
 type RowViewProps = {
   node: RowNode;
   renderTabset?: (node: TabsetNode) => ReactNode;
 };
+declare const RowView: ({ node, renderTabset }: RowViewProps) => ReactNode;
 //#endregion
 //#region src/components/tabset/tabset-view.d.ts
 type TabsetViewProps = {
   node: TabsetNode;
 };
+declare const TabsetView: ({ node }: TabsetViewProps) => ReactNode;
 //#endregion
 //#region src/components/layout.d.ts
 declare const Layout: {
-  readonly DragLayer: (props: DragProviderProps) => import("react").ReactNode;
-  readonly FloatLayer: ({ children, floats }: FloatLayerProps) => import("react").ReactNode;
-  readonly Root: ({ children, closableTabs, dispatch, draggableTabs, draggableTabsets, editable, floatable, keepMounted, maximizable, model, renamableTabs, renderTab, renderTabLabel, renderTabsetToolbar, resizableSplits, restructurable, rootRef, snap, style, ...props }: LayoutRootProps) => import("react").ReactNode;
-  readonly Rows: ({ node, renderTabset }: RowViewProps) => import("react").ReactNode;
-  readonly Tabset: ({ node }: TabsetViewProps) => import("react").ReactNode;
+  readonly DragLayer: typeof DragProvider;
+  readonly FloatLayer: typeof FloatLayer;
+  readonly Root: typeof LayoutRoot;
+  readonly Rows: typeof RowView;
+  readonly Tabset: typeof TabsetView;
 };
 //#endregion
-//#region src/components/panel.d.ts
-type PanelRootProps = ComponentProps<"div">;
-type PanelHeaderProps = ComponentProps<"div">;
+//#region src/components/panel-badge.d.ts
+type PanelBadgeProps = ComponentProps<"span">;
+//#endregion
+//#region src/components/panel-body.d.ts
 type PanelBodyProps = ComponentProps<"div">;
-type PanelTitleProps = ComponentProps<"span">;
+//#endregion
+//#region src/components/panel-header.d.ts
+type PanelHeaderProps = ComponentProps<"div">;
+//#endregion
+//#region src/components/panel-icon.d.ts
 type PanelIconProps = ComponentProps<"span">;
-type PanelBadgeProps = ComponentProps<"span">;
+//#endregion
+//#region src/components/panel-root.d.ts
+type PanelRootProps = ComponentProps<"div">;
+//#endregion
+//#region src/components/panel-title.d.ts
+type PanelTitleProps = ComponentProps<"span">;
+//#endregion
+//#region src/components/panel.d.ts
 declare const Panel: {
-  readonly Badge: (props: PanelBadgeProps) => ReactNode;
-  readonly Body: (props: PanelBodyProps) => ReactNode;
-  readonly Header: (props: PanelHeaderProps) => ReactNode;
-  readonly Icon: (props: PanelIconProps) => ReactNode;
-  readonly Root: (props: PanelRootProps) => ReactNode;
-  readonly Title: (props: PanelTitleProps) => ReactNode;
+  readonly Badge: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+  readonly Body: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+  readonly Header: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+  readonly Icon: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+  readonly Root: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+  readonly Title: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
 };
 //#endregion
-//#region src/components/tabset/tabset-tab-controls.d.ts
-type TabsetRenameInputProps = ComponentProps<"input">;
-type TabsetCloseButtonProps = ComponentProps<"button">;
-//#endregion
 //#region src/components/tabset/tabset-content.d.ts
 type TabsetContentProps = Omit<ComponentProps<"div">, "children"> & {
   children?: (tab: TabNode) => ReactNode;
 };
 //#endregion
-//#region src/components/tabset/tabset-toolbar.d.ts
-type TabsetToolbarProps = ComponentProps<"div">;
-type TabsetGripProps = ComponentProps<"button">;
-type TabsetMaximizeButtonProps = ComponentProps<"button">;
-type TabsetFloatButtonProps = ComponentProps<"button">;
-//#endregion
 //#region src/components/tabset/tabset-root.d.ts
 type TabsetRootProps = ComponentProps<"div"> & {
   node: TabsetNode;
@@ -233,28 +247,41 @@ type TabsetTabProps = ComponentProps<"span"> & {
 };
 type TabsetTriggerProps = ComponentProps<"button">;
 //#endregion
+//#region src/components/tabset/tabset-overflow-menu.d.ts
+declare const TabsetOverflowMenu: () => ReactNode;
+//#endregion
+//#region src/components/tabset/tabset-rename-input.d.ts
+type TabsetRenameInputProps = ComponentProps<"input">;
+type TabsetCloseButtonProps = ComponentProps<"button">;
+//#endregion
 //#region src/components/tabset/tabset-tablist.d.ts
 type TabsetTabStripProps = ComponentProps<"div">;
 type TabsetTablistProps = ComponentProps<"div">;
 //#endregion
+//#region src/components/tabset/tabset-toolbar.d.ts
+type TabsetToolbarProps = ComponentProps<"div">;
+type TabsetGripProps = ComponentProps<"button">;
+type TabsetMaximizeButtonProps = ComponentProps<"button">;
+type TabsetFloatButtonProps = ComponentProps<"button">;
+//#endregion
 //#region src/components/tabset/tabset.d.ts
 declare const Tabset: {
-  readonly CloseButton: ({ children, onClick, ...props }: TabsetCloseButtonProps) => import("react").ReactNode;
-  readonly Content: ({ children, style, ...props }: TabsetContentProps) => import("react").ReactNode;
-  readonly FloatButton: ({ children, onClick, ...props }: TabsetFloatButtonProps) => import("react").ReactNode;
-  readonly Grip: ({ children, ref: userRef, ...props }: TabsetGripProps) => import("react").ReactNode;
-  readonly MaximizeButton: ({ children, onClick, ...props }: TabsetMaximizeButtonProps) => import("react").ReactNode;
-  readonly OverflowMenu: () => import("react").ReactNode;
-  readonly RenameInput: (props: TabsetRenameInputProps) => import("react").ReactNode;
-  readonly Root: ({ children, node, ref: userRef, style, ...props }: TabsetRootProps) => import("react").ReactNode;
-  readonly Tab: ({ children, ref: userRef, tab, ...props }: TabsetTabProps) => import("react").ReactNode;
-  readonly Tablist: ({ onKeyDown, ref: userRef, style, ...props }: TabsetTablistProps) => import("react").ReactNode;
-  readonly TabStrip: ({ style, ...props }: TabsetTabStripProps) => import("react").ReactNode;
-  readonly Toolbar: ({ style, ...props }: TabsetToolbarProps) => import("react").ReactNode;
-  readonly Trigger: ({ children, onClick, onDoubleClick, ref: userRef, ...props }: TabsetTriggerProps) => import("react").ReactNode;
+  readonly CloseButton: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+  readonly Content: import("react").ForwardRefExoticComponent<Omit<TabsetContentProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+  readonly FloatButton: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+  readonly Grip: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+  readonly MaximizeButton: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+  readonly OverflowMenu: typeof TabsetOverflowMenu;
+  readonly RenameInput: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+  readonly Root: import("react").ForwardRefExoticComponent<Omit<TabsetRootProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+  readonly Tab: import("react").ForwardRefExoticComponent<Omit<TabsetTabProps, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+  readonly Tablist: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+  readonly TabStrip: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+  readonly Toolbar: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+  readonly Trigger: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
 };
 //#endregion
-//#region src/components/tab-overflow.d.ts
+//#region src/components/tab-overflow-menu.d.ts
 type OverflowItem = {
   id: string;
   name: string;
@@ -271,11 +298,12 @@ type TabsetState = {
   isMaximized: boolean;
   node: TabsetNode;
   overflowItems: Array<OverflowItem>;
+  /** The tab a `closeTab` is waiting on, so a vetoed close cannot restore focus. */
+  pendingCloseTabId: string | null;
   registerRenameInput: () => () => void;
   registerTablist: (element: HTMLDivElement | null) => void;
   renameInputCount: number;
   renameTab: (tabId: string, name: string) => void;
-  restoreFocus: boolean;
   selectOverflowTab: (tabId: string) => void;
   selectTab: (index: number, options?: {
     focus?: boolean;
@@ -341,7 +369,9 @@ type UseDashfooStoreOptions = {
   onMaximizedTabsetChange?: (tabsetId: string | undefined) => void;
   onModelChange?: (model: Dashfoo, action?: Action) => void;
 };
+/** The mode is latched on the first render; running both sources leaves the
+ * unread one describing a document nobody rendered. */
 declare const useDashfooStore: (options: UseDashfooStoreOptions) => DashfooStore;
 //#endregion
-export { type Breakpoint, DashfooDragProvider, type DashfooHandle, DashfooLayout, type DashfooLayoutProps, type DashfooStore, type ExternalTabSourceOptions, Layout, type DragProviderProps as LayoutDragLayerProps, type FloatLayerProps as LayoutFloatLayerProps, type LayoutRootProps, type RowViewProps as LayoutRowsProps, type LayoutState, type TabsetViewProps as LayoutTabsetProps, Panel, type PanelBadgeProps, type PanelBodyProps, type PanelHeaderProps, type PanelIconProps, type PanelRootProps, type PanelTitleProps, type PersistConfig, type Persistence, type ResponsiveModel, type StorageAdapter, type TabComponent, type TabContextValue, Tabset, type TabsetCloseButtonProps, type TabsetContentProps, type TabsetFloatButtonProps, type TabsetGripProps, type TabsetMaximizeButtonProps, type TabsetRenameInputProps, type TabsetRootProps, type TabsetState, type TabsetTabProps, type TabsetTabStripProps, type TabsetTablistProps, type TabsetToolbarProps, type TabsetTriggerProps, type UseDashfooStoreOptions, type UseResponsiveModelOptions, activeBreakpoint, localStorageAdapter, matchBreakpoint, memoryStorageAdapter, useContainerWidth, useDashfooStore, useDragSubject, useDropIntent, useExternalTabSource, useLayout, usePersistence, useResponsiveModel, useTab, useTabset };
+export { type Breakpoint, DashfooDragProvider, type DashfooHandle, DashfooLayout, type DashfooLayoutCommonProps, type DashfooLayoutProps, type DashfooStore, type ExternalTabSourceOptions, Layout, type DragProviderProps as LayoutDragLayerProps, type FloatLayerProps as LayoutFloatLayerProps, type LayoutRenderers, type LayoutRootProps, type RowViewProps as LayoutRowsProps, type LayoutState, type TabsetViewProps as LayoutTabsetProps, Panel, type PanelBadgeProps, type PanelBodyProps, type PanelHeaderProps, type PanelIconProps, type PanelRootProps, type PanelTitleProps, type PersistConfig, type Persistence, type ResponsiveModel, type StorageAdapter, type TabComponent, type TabContextValue, Tabset, type TabsetCloseButtonProps, type TabsetContentProps, type TabsetFloatButtonProps, type TabsetGripProps, type TabsetMaximizeButtonProps, type TabsetRenameInputProps, type TabsetRootProps, type TabsetState, type TabsetTabProps, type TabsetTabStripProps, type TabsetTablistProps, type TabsetToolbarProps, type TabsetTriggerProps, type UseDashfooStoreOptions, type UseResponsiveModelOptions, activeBreakpoint, localStorageAdapter, matchBreakpoint, memoryStorageAdapter, useContainerWidth, useDashfooStore, useDragSubject, useDropIntent, useExternalTabSource, useLayout, usePersistence, useResponsiveModel, useTab, useTabset };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/hooks/persistence.ts","../src/components/dashfoo-layout.tsx","../src/components/drag-root.tsx","../src/hooks/drag-hooks.tsx","../src/components/drag-adapter.tsx","../src/components/float-layer.tsx","../src/hooks/layout-store.ts","../src/components/layout-root.tsx","../src/components/row-view.tsx","../src/components/tabset/tabset-view.tsx","../src/components/layout.tsx","../src/components/panel.tsx","../src/components/tabset/tabset-tab-controls.tsx","../src/components/tabset/tabset-content.tsx","../src/components/tabset/tabset-toolbar.tsx","../src/components/tabset/tabset-root.tsx","../src/components/tabset/tabset-tab.tsx","../src/components/tabset/tabset-tablist.tsx","../src/components/tabset/tabset.ts","../src/components/tab-overflow.tsx","../src/components/tabset/tabset-store.ts","../src/hooks/responsive.ts","../src/hooks/store.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/hooks/persistence.ts","../src/components/dashfoo-layout.tsx","../src/components/dashfoo-drag-provider.tsx","../src/hooks/drag-hooks.tsx","../src/components/drag-provider.tsx","../src/components/float-layer.tsx","../src/hooks/layout-store.ts","../src/components/layout-root.tsx","../src/components/row-view.tsx","../src/components/tabset/tabset-view.tsx","../src/components/layout.tsx","../src/components/panel-badge.tsx","../src/components/panel-body.tsx","../src/components/panel-header.tsx","../src/components/panel-icon.tsx","../src/components/panel-root.tsx","../src/components/panel-title.tsx","../src/components/panel.tsx","../src/components/tabset/tabset-content.tsx","../src/components/tabset/tabset-root.tsx","../src/components/tabset/tabset-tab.tsx","../src/components/tabset/tabset-overflow-menu.tsx","../src/components/tabset/tabset-rename-input.tsx","../src/components/tabset/tabset-tablist.tsx","../src/components/tabset/tabset-toolbar.tsx","../src/components/tabset/tabset.ts","../src/components/tab-overflow-menu.tsx","../src/components/tabset/tabset-store.ts","../src/hooks/responsive.ts","../src/hooks/store.ts"],"mappings":"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"}