@womp/kookie-ui 0.36.0 → 0.37.1

package/src/components/_internal/shell-resizable.tsx

@@ -3,7 +3,7 @@
 import * as React from 'react';
 import { useLayoutEffect } from 'radix-ui/internal';
 import { normalizeToPx } from '../../helpers/normalize-to-px.js';
-import type { PaneName, PaneSizePersistence } from '../shell.types.js';
+import type { PaneName } from '../shell.types.js';
 import type { PaneResizeContextValue } from './shell-resize.js';
 
 export type SizeChangeMeta = { reason: 'init' | 'resize' | 'controlled' };
@@ -30,16 +30,10 @@ export type ResizableOptions = {
   onResize: ((size: number) => void) | undefined;
   onResizeStart: ((size: number) => void) | undefined;
   onResizeEnd: ((size: number) => void) | undefined;
-  snapPoints: number[] | undefined;
-  snapTolerance: number | undefined;
-  collapseThreshold: number | undefined;
-  paneId: string | undefined;
-  persistence: PaneSizePersistence | undefined;
-  /** Whether the pane is presented as an overlay right now. An overlay keeps its designed size and persists nothing. */
+  /** Whether the pane is presented as an overlay right now. An overlay keeps its designed size. */
   overlaying: boolean;
   /** The same question asked at effect time, for a pane whose presentation is learnt after its first render. */
   overlayingNow: () => boolean;
-  requestCollapse: () => void;
   requestToggle: () => void;
 };
 
@@ -63,9 +57,9 @@ export function useInitialPaneSize(size: number | string | undefined, defaultSiz
   return initial;
 }
 
-/** Everything a resizable pane shares: size props, persistence, and the handle's context. */
+/** Everything a resizable pane shares: size props and the handle's context. */
 export function useResizablePane(options: ResizableOptions): PaneResizeContextValue {
-  const { name, elementRef, cssVarName, orientation, minSize, maxSize, resizable, size, defaultSize, paneId, persistence } = options;
+  const { name, elementRef, cssVarName, orientation, minSize, maxSize, size, defaultSize } = options;
 
   // The latest callbacks, so the size emitter does not change identity when a
   // consumer passes an inline function. A controlled `size` is reported again
@@ -107,7 +101,7 @@ export function useResizablePane(options: ResizableOptions): PaneResizeContextVa
   /**
    * The one way a size reaches the pane: the size variable, and the value
    * every handle of this pane announces. Once anything but `expandedSize` has
-   * written a size (a default, a controlled value, a persisted value or a
+   * written a size (a default, a controlled value or a
    * resize), the pane owns that size and a new `expandedSize` leaves it alone.
    */
   const ownedRef = React.useRef(false);
@@ -154,65 +148,6 @@ export function useResizablePane(options: ResizableOptions): PaneResizeContextVa
     emitSizeChange(clamped, { reason: 'controlled' });
   }, [size, minSize, maxSize, options.overlaying, toPx, writeSize, emitSizeChange]);
 
-  // A persistence adapter from `paneId` when none is given. A given one is read through
-  // `latest`, so an inline object (the documented shape) does not reload the size every render.
-  const hasPersistence = persistence !== undefined;
-  const adapter = React.useMemo<PaneSizePersistence | undefined>(() => {
-    if (hasPersistence) {
-      return {
-        load: () => latest.current.persistence?.load?.(),
-        save: (value: number) => latest.current.persistence?.save?.(value),
-      };
-    }
-    if (!paneId) return undefined;
-    const key = `kookie-ui:shell:${name}:${paneId}`;
-    return {
-      load: () => {
-        if (typeof window === 'undefined') return undefined;
-        try {
-          const stored = window.localStorage.getItem(key);
-          return stored ? Number(stored) : undefined;
-        } catch (err) {
-          if (process.env.NODE_ENV !== 'production') console.warn(`Shell.${name}: failed to load persisted size`, err);
-          return undefined;
-        }
-      },
-      save: (value: number) => {
-        if (typeof window === 'undefined') return;
-        try {
-          window.localStorage.setItem(key, String(value));
-        } catch (err) {
-          if (process.env.NODE_ENV !== 'production') console.warn(`Shell.${name}: failed to save persisted size`, err);
-        }
-      },
-    };
-  }, [name, paneId, hasPersistence]);
-
-  // Persisted size, loaded in a layout effect and clamped, so a reload does
-  // not paint the default and then jump. Only where the pane is in the frame:
-  // an overlay keeps its designed size.
-  useLayoutEffect(() => {
-    if (!resizable || !adapter?.load || latest.current.overlayingNow()) return undefined;
-    let mounted = true;
-    const apply = (value: number | undefined) => {
-      if (!mounted || typeof value !== 'number' || !Number.isFinite(value)) return;
-      const clamped = clampTo(value, minSize, maxSize);
-      writeSize(clamped, true);
-      latest.current.onResize?.(clamped);
-    };
-    const loaded = adapter.load();
-    if (loaded instanceof Promise) {
-      loaded.then(apply).catch((err) => {
-        if (process.env.NODE_ENV !== 'production') console.warn(`Shell.${name}: failed to load persisted size`, err);
-      });
-    } else {
-      apply(loaded);
-    }
-    return () => {
-      mounted = false;
-    };
-  }, [resizable, adapter, options.overlaying, writeSize, minSize, maxSize, name]);
-
   // What the handle announces before any effect has run: the same starting size the pane's
   // first render uses, so the server HTML already states a value.
   const [startSize] = React.useState(() => {
@@ -230,11 +165,9 @@ export function useResizablePane(options: ResizableOptions): PaneResizeContextVa
     (value: number) => {
       latest.current.onResizeEnd?.(value);
       emitSizeChange(value, { reason: 'resize' });
-      adapter?.save?.(value);
     },
-    [emitSizeChange, adapter],
+    [emitSizeChange],
   );
-  const requestCollapse = React.useCallback(() => latest.current.requestCollapse(), []);
   const requestToggle = React.useCallback(() => latest.current.requestToggle(), []);
 
   return React.useMemo(
@@ -254,10 +187,6 @@ export function useResizablePane(options: ResizableOptions): PaneResizeContextVa
       onResizeEnd,
       target: name,
       collapsible: options.collapsible,
-      snapPoints: options.snapPoints,
-      snapTolerance: options.snapTolerance ?? 8,
-      collapseThreshold: options.collapseThreshold,
-      requestCollapse,
       requestToggle,
     }),
     [
@@ -276,10 +205,6 @@ export function useResizablePane(options: ResizableOptions): PaneResizeContextVa
       onResizeEnd,
       name,
       options.collapsible,
-      options.snapPoints,
-      options.snapTolerance,
-      options.collapseThreshold,
-      requestCollapse,
       requestToggle,
     ],
   );

package/src/components/_internal/shell-resize.tsx

@@ -24,10 +24,6 @@ export interface PaneResizeContextValue {
   onResizeEnd?: (size: number) => void;
   target: PaneName;
   collapsible: boolean;
-  snapPoints?: number[];
-  snapTolerance: number;
-  collapseThreshold?: number;
-  requestCollapse?: () => void;
   requestToggle?: () => void;
 }
 

package/src/components/_internal/shell-rest.ts

@@ -4,6 +4,8 @@ import type { PaneValue } from './shell-store.js';
 type ResponsiveBoolean = boolean | Partial<Record<Breakpoint, boolean>>;
 
 /** `open`/`defaultOpen` as the pane's own value type. */
+export function toPaneValue(value: boolean | undefined): PaneValue | undefined;
+export function toPaneValue(value: ResponsiveBoolean | undefined): PaneValue | Partial<Record<Breakpoint, PaneValue>> | undefined;
 export function toPaneValue(value: ResponsiveBoolean | undefined): PaneValue | Partial<Record<Breakpoint, PaneValue>> | undefined {
   if (value === undefined) return undefined;
   if (typeof value === 'boolean') return value ? 'open' : 'closed';
@@ -32,14 +34,3 @@ export const endAnchoredGrowth = (isRtl: boolean): 1 | -1 => (isRtl ? 1 : -1);
 
 /** A pane anchored at the block end grows as its top edge moves up. */
 export const bottomAnchoredGrowth = (): 1 | -1 => -1;
-
-/**
- * `height` and `resizer` left PaneBaseProps in 0.8.0: no pane ever read them.
- * A call site written against 0.7 can still pass them, so they are dropped
- * here rather than reaching the DOM as invalid attributes.
- */
-export function withoutRemovedPaneProps<T extends object>(props: T): T {
-  if (!('height' in props) && !('resizer' in props)) return props;
-  const { height: _height, resizer: _resizer, ...rest } = props as T & { height?: unknown; resizer?: unknown };
-  return rest as T;
-}

package/src/components/_internal/shell-sidebar.tsx

@@ -7,15 +7,15 @@ import { PaneResizeContext } from './shell-resize.js';
 import { PaneHandle, SidebarHandle } from './shell-handles.js';
 import { usePane, paneAttributes, usePresentationTable } from './shell-pane.js';
 import { splitHandles, useInitialPaneSize, useResizablePane, type SizeChangeMeta } from './shell-resizable.js';
-import { useFrameRegistration, warnOnce, type PaneValue } from './shell-store.js';
-import { navigationRest, startAnchoredGrowth, withoutRemovedPaneProps } from './shell-rest.js';
+import { useFrameRegistration, type PaneValue } from './shell-store.js';
+import { navigationRest, startAnchoredGrowth } from './shell-rest.js';
 import { readBreakpoint } from '../../hooks/use-breakpoint.js';
 import { PaneChromeScope } from './pane-chrome.js';
 import { PageScope } from './page-scope.js';
-import type { Breakpoint, CSSPropertiesWithVars, PaneBaseProps, Responsive, SidebarMode } from '../shell.types.js';
+import type { Breakpoint, CSSPropertiesWithVars, PaneBaseProps, PaneOpenChangeReason, Responsive, SidebarMode } from '../shell.types.js';
 
-type SidebarStateChangeMeta = { reason: 'init' | 'toggle' | 'responsive' | 'dismiss' };
-type SidebarControlledProps = { state: Responsive<SidebarMode>; onStateChange?: (state: SidebarMode, meta: SidebarStateChangeMeta) => void; defaultState?: never };
+type SidebarStateChangeMeta = { reason: PaneOpenChangeReason };
+type SidebarControlledProps = { state: SidebarMode; onStateChange?: (state: SidebarMode, meta: SidebarStateChangeMeta) => void; defaultState?: never };
 type SidebarUncontrolledProps = { defaultState?: SidebarMode | Partial<Record<Breakpoint, SidebarMode>>; onStateChange?: (state: SidebarMode, meta: SidebarStateChangeMeta) => void; state?: never };
 type SidebarPublicProps = PaneBaseProps & {
   size?: number | string;
@@ -37,6 +37,8 @@ type SidebarComponent = React.ForwardRefExoticComponent<SidebarPublicProps & Rea
 const toValue = (mode: SidebarMode): PaneValue => (mode === 'collapsed' ? 'closed' : 'open');
 const toMode = (value: PaneValue): SidebarMode => (value === 'closed' ? 'collapsed' : 'expanded');
 
+function modeToValue(state: SidebarMode | undefined): PaneValue | undefined;
+function modeToValue(state: Responsive<SidebarMode> | undefined): PaneValue | Partial<Record<Breakpoint, PaneValue>> | undefined;
 function modeToValue(state: Responsive<SidebarMode> | undefined): PaneValue | Partial<Record<Breakpoint, PaneValue>> | undefined {
   if (state === undefined) return undefined;
   if (typeof state === 'string') return toValue(state);
@@ -62,16 +64,9 @@ export const Sidebar = React.forwardRef<HTMLDivElement, SidebarPublicProps>((pro
     maxSize = 400,
     resizable = false,
     collapsible = true,
-    onExpand,
-    onCollapse,
     onResize,
     onResizeStart,
     onResizeEnd,
-    snapPoints,
-    snapTolerance,
-    collapseThreshold,
-    paneId,
-    persistence,
     children,
     style,
     state,
@@ -98,17 +93,10 @@ export const Sidebar = React.forwardRef<HTMLDivElement, SidebarPublicProps>((pro
     presentationTable: table,
     builtIn: navigationRest,
     onChange: (value, reason) => onStateChange?.(toMode(value), { reason }),
-    onExpand,
-    onCollapse,
     size: expandedSize,
   });
   useFrameRegistration('sidebar', flush);
 
-  React.useEffect(() => {
-    if (snapPoints !== undefined || collapseThreshold !== undefined || paneId !== undefined || persistence !== undefined) {
-      warnOnce('Shell.Sidebar: `snapPoints`, `collapseThreshold`, `paneId` and `persistence` are deprecated and are removed in 1.0. Keep the size in your own state with `size`/`onSizeChange`.');
-    }
-  }, [snapPoints, collapseThreshold, paneId, persistence]);
 
   const elementRef = React.useRef<HTMLElement | null>(null);
   const composedRef = useComposedRefs(ref, pane.setElement, elementRef);
@@ -134,14 +122,8 @@ export const Sidebar = React.forwardRef<HTMLDivElement, SidebarPublicProps>((pro
     onResize,
     onResizeStart,
     onResizeEnd,
-    snapPoints,
-    snapTolerance,
-    collapseThreshold,
-    paneId,
-    persistence,
     overlaying: pane.overlaying,
     overlayingNow: () => table[readBreakpoint()] === 'overlay',
-    requestCollapse: () => pane.setValue('closed', 'toggle'),
     requestToggle: () => pane.toggle('toggle'),
   });
 
@@ -151,13 +133,10 @@ export const Sidebar = React.forwardRef<HTMLDivElement, SidebarPublicProps>((pro
       <PaneResizeContext.Provider value={resize}>{handles.length > 0 ? handles : <PaneHandle />}</PaneResizeContext.Provider>
     ) : null;
 
-  // A peek previews the width the next toggle opens to.
-  const peekWidth = pane.peeking ? `var(--sidebar-size, ${expandedSize}px)` : undefined;
-
   const initialSize = useInitialPaneSize(size, defaultSize, minSize, maxSize);
   return (
     <div
-      {...withoutRemovedPaneProps(domProps)}
+      {...domProps}
       role={domProps.role ?? 'navigation'}
       id={pane.id}
       ref={composedRef}
@@ -172,7 +151,6 @@ export const Sidebar = React.forwardRef<HTMLDivElement, SidebarPublicProps>((pro
           ...(initialSize ? { '--sidebar-size': initialSize } : {}),
           '--sidebar-min-size': `${minSize}px`,
           '--sidebar-max-size': `${maxSize}px`,
-          ...(peekWidth ? { '--peek-sidebar-width': peekWidth } : {}),
         } as CSSPropertiesWithVars
       }
     >

package/src/components/_internal/shell-store.tsx

@@ -117,12 +117,10 @@ export type ShellStore = {
    * it, would be a new identity on every read.
    */
   version: number;
-  /** The pane a hovered Trigger is previewing, if any. Layout only. */
-  peek: PaneName | null;
 };
 
 export function createShellStore(): ShellStore {
-  return { entries: new Map(), listeners: new Set(), version: 0, peek: null };
+  return { entries: new Map(), listeners: new Set(), version: 0 };
 }
 
 export function notifyShellStore(store: ShellStore) {
@@ -137,12 +135,6 @@ export function subscribeShellStore(store: ShellStore, listener: () => void) {
   };
 }
 
-export function setShellPeek(store: ShellStore, peek: PaneName | null) {
-  if (store.peek === peek) return;
-  store.peek = peek;
-  notifyShellStore(store);
-}
-
 export const ShellStoreContext = React.createContext<ShellStore | null>(null);
 
 export function useShellStore(part: string): ShellStore {
@@ -158,19 +150,6 @@ export function usePaneEntry(store: ShellStore, name: PaneName): PaneEntry | und
   return React.useSyncExternalStore(subscribe, getSnapshot, () => undefined);
 }
 
-/**
- * Whether this pane is the one being previewed. A boolean per pane rather than
- * the peek target itself, so hovering one Trigger re-renders one pane, not all.
- */
-export function usePeeking(store: ShellStore, name: PaneName): boolean {
-  const subscribe = React.useCallback((listener: () => void) => subscribeShellStore(store, listener), [store]);
-  return React.useSyncExternalStore(
-    subscribe,
-    () => store.peek === name,
-    () => false,
-  );
-}
-
 /* ── Off the frame ─────────────────────────────────────────────────────────── */
 
 export type FramePaneId = 'rail' | 'panel' | 'sidebar' | 'content' | 'inspector' | 'bottom';
@@ -191,15 +170,3 @@ export function useFrameRegistration(id: FramePaneId, flush: boolean) {
     return () => unregisterOffFrame(id);
   }, [id, flush, registerOffFrame, unregisterOffFrame]);
 }
-
-/* ── Development warnings ──────────────────────────────────────────────────── */
-
-const warned = new Set<string>();
-
-/** A deprecation warning, once per message per page load. Development only. */
-export function warnOnce(message: string) {
-  if (process.env.NODE_ENV === 'production') return;
-  if (warned.has(message)) return;
-  warned.add(message);
-  console.warn(`[kookie-ui] ${message}`);
-}

package/src/components/accordion.props.tsx

@@ -2,7 +2,7 @@ import { asChildPropDef } from '../props/as-child.prop.js';
 import { colorPropDef } from '../props/color.prop.js';
 import { radiusPropDef } from '../props/radius.prop.js';
 
-import type { PropDef } from '../props/prop-def.js';
+import type { GetPropDefTypes, PropDef } from '../props/prop-def.js';
 
 const sizes = ['1', '2', '3', '4'] as const;
 const variants = ['raised', 'soft', 'surface', 'outline', 'ghost'] as const;
@@ -53,9 +53,7 @@ export {
 export type AccordionRootOwnProps = {
   size?: (typeof sizes)[number];
   variant?: (typeof variants)[number];
-  color?: string;
-  radius?: string;
-};
+} & GetPropDefTypes<typeof colorPropDef & typeof radiusPropDef>;
 
 export type AccordionItemOwnProps = {
   asChild?: boolean;

package/src/components/checkbox-group.primitive.tsx

@@ -37,16 +37,6 @@ interface CheckboxGroupProps extends PrimitiveDivProps {
   required?: React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>['required'];
   disabled?: React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>['disabled'];
   dir?: 'ltr' | 'rtl';
-  /**
-   * @deprecated Has no effect. Each checkbox is its own tab stop, as with native checkboxes,
-   * so there is no arrow-key navigation to orient.
-   */
-  orientation?: 'horizontal' | 'vertical';
-  /**
-   * @deprecated Has no effect. Each checkbox is its own tab stop, as with native checkboxes,
-   * so there is no arrow-key navigation to loop.
-   */
-  loop?: boolean;
   defaultValue?: string[];
   value?: CheckboxGroupContextValue['value'];
   onValueChange?: (value: string[]) => void;
@@ -61,9 +51,7 @@ const CheckboxGroup = React.forwardRef<CheckboxGroupElement, CheckboxGroupProps>
       value: valueProp,
       required = false,
       disabled = false,
-      orientation: _orientation,
       dir,
-      loop: _loop,
       onValueChange,
       ...groupProps
     } = props;

package/src/components/context-menu.tsx

@@ -38,7 +38,7 @@ import {
 } from './_internal/base-menu.utils.js';
 
 import type { ComponentPropsWithout, RemovedProps } from '../helpers/component-props.js';
-import type { GetPropDefTypes, Responsive } from '../props/prop-def.js';
+import type { GetPropDefTypes } from '../props/prop-def.js';
 
 interface ContextMenuRootProps
   extends React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Root> {}
@@ -95,10 +95,6 @@ interface ContextMenuContentProps
    * Use this when rendering virtualized lists inside the context menu.
    */
   virtualized?: boolean;
-  /**
-   * @deprecated Has no effect. ContextMenu submenus always cascade.
-   */
-  submenuBehavior?: Responsive<'cascade' | 'drill-down'>;
 }
 const ContextMenuContent = React.forwardRef<ContextMenuContentElement, ContextMenuContentProps>(
   (ownProps, forwardedRef) => {
@@ -113,7 +109,6 @@ const ContextMenuContent = React.forwardRef<ContextMenuContentElement, ContextMe
       color,
       container,
       forceMount,
-      submenuBehavior: _submenuBehavior,
       virtualized = false,
       ...contentProps
     } = extractProps(props, contextMenuContentPropDefs);

package/src/components/schemas/index.ts

@@ -74,7 +74,6 @@ export type {
   ResponsiveMode,
   ResponsiveSidebarMode,
   ResponsivePresentation,
-  PaneSizePersistence,
 } from './shell.schema.js';
 
 /**

package/src/components/schemas/shell.schema.ts

@@ -24,7 +24,7 @@ const PaneModeSchema = z.enum(['expanded', 'collapsed']).describe('Pane state mo
 const SidebarModeSchema = z.enum(['collapsed', 'expanded']).describe('Sidebar state');
 const PresentationValueSchema = z.enum(['fixed', 'overlay', 'stacked']).describe('Presentation mode');
 const _BreakpointSchema = z.enum(['initial', 'xs', 'sm', 'md', 'lg', 'xl']).describe('Responsive breakpoint');
-const PaneTargetSchema = z.enum(['left', 'rail', 'panel', 'sidebar', 'inspector', 'bottom']).describe('Pane target. `left` is deprecated: use `rail`.');
+const PaneTargetSchema = z.enum(['rail', 'panel', 'sidebar', 'inspector', 'bottom']).describe('Pane target');
 const TriggerActionSchema = z.enum(['toggle', 'expand', 'collapse']).describe('Trigger action');
 const OpenChangeReasonSchema = z.enum(['toggle', 'dismiss']).describe('Why the state changed: `toggle` for a trigger or the resize handle, `dismiss` for Escape or the scrim');
 const SizeChangeReasonSchema = z.enum(['init', 'resize', 'controlled']).describe('Why the size changed');
@@ -49,21 +49,13 @@ const ResponsiveSidebarModeSchema = responsive(SidebarModeSchema).describe('Resp
 const ResponsivePresentationSchema = responsive(PresentationValueSchema).describe('Responsive presentation configuration');
 const ResponsiveOpenSchema = responsive(z.boolean()).describe('Responsive open state');
 
-// Size persistence adapter (deprecated)
-const PaneSizePersistenceSchema = z
-  .object({
-    load: z.function({ output: z.union([z.number(), z.promise(z.number()), z.undefined()]) }).optional(),
-    save: z.function({ input: [z.number()], output: z.union([z.void(), z.promise(z.void())]) }).optional(),
-  })
-  .describe('Deprecated, removed in 1.0. Keep the size in your own state with `size`/`onSizeChange`.');
-
 const StyleSchema = z
   .record(z.string(), z.union([z.string(), z.number()]))
   .optional()
   .describe('Inline styles');
 
 const OpenPropsSchema = {
-  open: z.union([z.boolean(), ResponsiveOpenSchema]).optional().describe('The open state, when controlled. A responsive object is deprecated.'),
+  open: z.boolean().optional().describe('The open state, when controlled'),
   defaultOpen: z
     .union([z.boolean(), ResponsiveOpenSchema])
     .optional()
@@ -80,8 +72,6 @@ const PaneBaseShape = {
   presentation: ResponsivePresentationSchema.optional(),
   expandedSize: z.number().optional(),
   flush: z.boolean().optional().describe('Whether the pane joins the app frame. Defaults to true. `false` pulls it off the frame as a card.'),
-  onExpand: z.function({ output: z.void() }).optional().describe('Deprecated: use `onOpenChange`'),
-  onCollapse: z.function({ output: z.void() }).optional().describe('Deprecated: use `onOpenChange`'),
   className: z.string().optional().describe('Additional CSS class name'),
   style: StyleSchema,
   children: z.any().optional(),
@@ -107,11 +97,6 @@ const ResizeShape = {
     .describe('Called during a drag, at most once per animation frame'),
   onResizeStart: z.function({ input: [z.number()], output: z.void() }).optional(),
   onResizeEnd: z.function({ input: [z.number()], output: z.void() }).optional(),
-  snapPoints: z.array(z.number()).optional().describe('Deprecated, removed in 1.0'),
-  snapTolerance: z.number().optional().describe('Deprecated, removed in 1.0'),
-  collapseThreshold: z.number().optional().describe('Deprecated, removed in 1.0'),
-  paneId: z.string().optional().describe('Deprecated, removed in 1.0'),
-  persistence: PaneSizePersistenceSchema.optional(),
 };
 
 /**
@@ -183,7 +168,7 @@ export const ShellSidebarSchema = z
   .object({
     ...PaneBaseShape,
     ...ResizeShape,
-    state: z.union([SidebarModeSchema, ResponsiveSidebarModeSchema]).optional().describe('The state, when controlled. A responsive object is deprecated.'),
+    state: SidebarModeSchema.optional().describe('The state, when controlled'),
     defaultState: ResponsiveSidebarModeSchema.optional().describe('The starting state. With no value the sidebar is open where it is in the frame and closed where it is an overlay.'),
     onStateChange: z
       .function({ input: [SidebarModeSchema, z.object({ reason: OpenChangeReasonSchema })], output: z.void() })
@@ -251,7 +236,6 @@ export const ShellTriggerSchema = z
   .object({
     target: PaneTargetSchema.describe('Which pane to drive'),
     action: TriggerActionSchema.default('toggle').describe('Action to perform'),
-    peekOnHover: z.boolean().default(false).describe('Deprecated, removed in 1.0. Shows a preview of a closed pane on hover.'),
     type: z.enum(['button', 'submit', 'reset']).default('button').describe('The button type'),
     className: z.string().optional().describe('Additional CSS class name'),
     style: StyleSchema,
@@ -298,7 +282,6 @@ export type TriggerAction = z.infer<typeof TriggerActionSchema>;
 export type ResponsiveMode = z.infer<typeof _ResponsiveModeSchema>;
 export type ResponsiveSidebarMode = z.infer<typeof ResponsiveSidebarModeSchema>;
 export type ResponsivePresentation = z.infer<typeof ResponsivePresentationSchema>;
-export type PaneSizePersistence = z.infer<typeof PaneSizePersistenceSchema>;
 
 /**
  * Development-only helper to validate and normalize Shell props

package/src/components/shell.context.tsx

@@ -1,34 +1,18 @@
 'use client';
 
 /**
- * Since 0.8.0 the Shell has two contexts: the pane registry (the store) and
- * the set of panes off the frame. They live in `_internal/shell-store.tsx`. This module keeps
- * the two hooks consumers can reach: `useSidebarMode`, and the deprecated
- * `useShell`.
+ * The Shell has two contexts: the pane registry (the store) and the set of panes off the frame.
+ * They live in `_internal/shell-store.tsx`. This module keeps the hook consumers can reach:
+ * `useSidebarMode`.
  */
 import * as React from 'react';
-import { useBreakpoint } from '../hooks/use-breakpoint.js';
-import type { Breakpoint, PaneMode, PaneName, PaneTarget, PresentationValue, SidebarMode } from './shell.types.js';
-import { setShellPeek, subscribeShellStore, useShellStore, warnOnce, type PaneValue, type ShellStore } from './_internal/shell-store.js';
+import type { SidebarMode } from './shell.types.js';
+import { subscribeShellStore, useShellStore, type PaneValue } from './_internal/shell-store.js';
 
 const toSidebarMode = (value: PaneValue | undefined): SidebarMode | undefined => (value === undefined ? undefined : value === 'closed' ? 'collapsed' : 'expanded');
 
 const fromSidebarMode = (mode: SidebarMode): PaneValue => (mode === 'collapsed' ? 'closed' : 'open');
 
-const toPaneMode = (value: PaneValue | undefined): PaneMode => (value === undefined || value === 'closed' ? 'collapsed' : 'expanded');
-
-const paneName = (target: PaneTarget): PaneName => (target === 'left' ? 'rail' : target);
-
-/** Re-renders on every change to the registry. For the deprecated whole-shell reader only. */
-function useStoreVersion(store: ShellStore) {
-  const subscribe = React.useCallback((listener: () => void) => subscribeShellStore(store, listener), [store]);
-  return React.useSyncExternalStore(
-    subscribe,
-    () => store.version,
-    () => 0,
-  );
-}
-
 /**
  * The Sidebar's mode, and a setter. The setter is a user action: it reports
  * through the Sidebar's `onStateChange` the way a Trigger does.
@@ -49,94 +33,3 @@ export function useSidebarMode(): { sidebarMode: SidebarMode; setSidebarMode: (m
   );
   return { sidebarMode: toSidebarMode(value) ?? 'expanded', setSidebarMode };
 }
-
-export interface ShellContextValue {
-  leftMode: PaneMode;
-  setLeftMode: (mode: PaneMode) => void;
-  /** The Rail's open state, resolved, when it is controlled. */
-  leftControlledOpen?: boolean;
-  panelMode: PaneMode;
-  setPanelMode: (mode: PaneMode) => void;
-  sidebarMode: SidebarMode;
-  setSidebarMode: (mode: SidebarMode) => void;
-  inspectorMode: PaneMode;
-  setInspectorMode: (mode: PaneMode) => void;
-  bottomMode: PaneMode;
-  setBottomMode: (mode: PaneMode) => void;
-  peekTarget: PaneTarget | null;
-  setPeekTarget: (target: PaneTarget | null) => void;
-  peekPane: (target: PaneTarget) => void;
-  clearPeek: () => void;
-  /** Whether a Rail is mounted. */
-  hasLeft: boolean;
-  /** No effect since 0.8.0: the registry knows which panes are mounted. */
-  setHasLeft: (has: boolean) => void;
-  /** Whether a Sidebar is mounted. */
-  hasSidebar: boolean;
-  /** No effect since 0.8.0: the registry knows which panes are mounted. */
-  setHasSidebar: (has: boolean) => void;
-  currentBreakpoint: Breakpoint;
-  currentBreakpointReady: boolean;
-  /** The Rail's presentation at the current breakpoint, when known. */
-  leftResolvedPresentation?: PresentationValue;
-  togglePane: (target: PaneTarget) => void;
-  expandPane: (target: PaneTarget) => void;
-  collapsePane: (target: PaneTarget) => void;
-}
-
-const noop = () => {};
-
-/**
- * @deprecated The whole-shell reader re-renders its consumer on every change
- * to any pane. Use `Shell.Trigger` to drive a pane, `Shell.useSidebarMode`
- * for the Sidebar, and each pane's `open`/`onOpenChange` for its state.
- * Removed in 1.0.
- *
- * Keeps 0.7's shape. The setters act as a user would: they report through
- * the pane's own callback with `reason: 'toggle'`, and a controlled pane
- * changes only when the app passes the new value.
- */
-export function useShell(): ShellContextValue {
-  const store = useShellStore('useShell');
-  React.useEffect(() => {
-    warnOnce("Shell.useShell is deprecated and is removed in 1.0. Use Shell.Trigger, Shell.useSidebarMode, or a pane's own open/onOpenChange.");
-  }, []);
-  useStoreVersion(store);
-  const { breakpoint, ready } = useBreakpoint();
-  const actions = React.useMemo(() => {
-    const setMode = (name: PaneName) => (mode: PaneMode) => store.entries.get(name)?.setValue(mode === 'collapsed' ? 'closed' : 'open', 'toggle');
-    const setPeekTarget = (target: PaneTarget | null) => setShellPeek(store, target === null ? null : paneName(target));
-    return {
-      setLeftMode: setMode('rail'),
-      setPanelMode: setMode('panel'),
-      setInspectorMode: setMode('inspector'),
-      setBottomMode: setMode('bottom'),
-      setSidebarMode: (mode: SidebarMode) => store.entries.get('sidebar')?.setValue(fromSidebarMode(mode), 'toggle'),
-      setPeekTarget,
-      peekPane: (target: PaneTarget) => setPeekTarget(target),
-      clearPeek: () => setPeekTarget(null),
-      setHasLeft: noop,
-      setHasSidebar: noop,
-      togglePane: (target: PaneTarget) => store.entries.get(paneName(target))?.toggle('toggle'),
-      expandPane: (target: PaneTarget) => store.entries.get(paneName(target))?.setValue('open', 'toggle'),
-      collapsePane: (target: PaneTarget) => store.entries.get(paneName(target))?.setValue('closed', 'toggle'),
-    };
-  }, [store]);
-  const value = (name: PaneName) => store.entries.get(name)?.value;
-  const rail = store.entries.get('rail');
-  return {
-    leftMode: toPaneMode(value('rail')),
-    leftControlledOpen: rail?.value === undefined ? undefined : rail.value !== 'closed',
-    panelMode: toPaneMode(value('panel')),
-    sidebarMode: toSidebarMode(value('sidebar')) ?? 'expanded',
-    inspectorMode: toPaneMode(value('inspector')),
-    bottomMode: toPaneMode(value('bottom')),
-    peekTarget: store.peek,
-    hasLeft: store.entries.has('rail'),
-    hasSidebar: store.entries.has('sidebar'),
-    currentBreakpoint: breakpoint,
-    currentBreakpointReady: ready,
-    leftResolvedPresentation: rail?.presentation,
-    ...actions,
-  };
-}