@notis_ai/cli 0.2.0-beta.157.1 → 0.2.0-beta.159.1

package/template/packages/sdk/src/hooks/useCollectionInteractions.ts

@@ -17,12 +17,17 @@ import {
 } from '../interactions/actions';
 import {
   activateShortcutCollection,
+  releaseShortcutCollection,
   createShortcutCollectionOwner,
   useShortcuts,
   type ShortcutDefinition,
   type ShortcutScope,
 } from '../interactions/shortcuts';
 
+import type { MultiSelectActionBarProps } from '../components/MultiSelectActionBar';
+import { isInteractionElementVisible } from '../interactions/visibility';
+import { useLongPressSelection } from './useLongPressSelection';
+
 export const COLLECTION_ITEM_ATTRIBUTE = 'data-notis-collection-item-id';
 const LEGACY_ROW_ATTRIBUTE = 'data-notis-row-id';
 const INTERACTIVE_SELECTOR = 'button, a, input, textarea, select, [role="button"], [contenteditable]:not([contenteditable="false"])';
@@ -93,6 +98,8 @@ export interface UseCollectionInteractionsOptions<T> {
   enabled?: boolean;
   bindKeyboardShortcuts?: boolean;
   enableDragSelect?: boolean;
+  /** Touch-only long press; optional per view. */
+  enableLongPressSelection?: boolean;
   /** Plain item clicks activate the item and clear checkbox selection by default. */
   clearSelectionOnPlainClick?: boolean;
   dragThreshold?: number;
@@ -114,6 +121,7 @@ export interface CollectionInteractionController<T> {
   lastClickedId: string | null;
   dragRect: SelectionMarqueeRect | null;
   actions: ResolvedCollectionAction[];
+  getActionBarProps: () => Pick<MultiSelectActionBarProps, 'selectedCount' | 'actions' | 'collectionOwnerId' | 'isAvailable' | 'shortcutsEnabled' | 'onClearSelection'>;
 
   isSelected: (id: string) => boolean;
   getSelectedItems: () => T[];
@@ -128,7 +136,7 @@ export interface CollectionInteractionController<T> {
   onCheckboxClick: (id: string) => (event: ReactMouseEvent) => void;
   onRowMouseDown: (id: string) => (event: ReactMouseEvent) => void;
   getRowProps: (id: string) => Record<string, string>;
-  getItemProps: (id: string) => {
+  getItemProps: (id: string) => Partial<ReturnType<ReturnType<typeof useLongPressSelection>>> & {
     [COLLECTION_ITEM_ATTRIBUTE]: string;
     [LEGACY_ROW_ATTRIBUTE]: string;
     tabIndex: number;
@@ -213,6 +221,7 @@ export function useCollectionInteractions<T>(
     enabled = true,
     bindKeyboardShortcuts = true,
     enableDragSelect = selectionMode === 'multiple',
+    enableLongPressSelection = false,
     clearSelectionOnPlainClick = true,
     dragThreshold = 5,
     shortcuts: shortcutOverrides,
@@ -240,6 +249,8 @@ export function useCollectionInteractions<T>(
   const selectedIdsRef = useRef(selectedIds);
   const activeIdRef = useRef(activeId);
   const anchorIdRef = useRef(anchorId);
+  // Keep manually selected rows outside the current keyboard range on reversal.
+  const keyboardRangeBaseRef = useRef<Set<string> | null>(null);
   const onSelectionChangeRef = useRef(onSelectionChange);
   const onActiveIdChangeRef = useRef(onActiveIdChange);
   const onAnchorIdChangeRef = useRef(onAnchorIdChange);
@@ -247,6 +258,11 @@ export function useCollectionInteractions<T>(
   const onActivateRef = useRef(onActivate);
   const resolveNextIdRef = useRef(resolveNextId);
   const containerRef = useRef<HTMLElement | null>(null);
+  const [containerElement, setContainerElement] = useState<HTMLElement | null>(null);
+  const setContainerRef = useCallback((node: HTMLElement | null) => {
+    containerRef.current = node;
+    setContainerElement(node);
+  }, []);
   const shortcutCollectionOwnerRef = useRef<string | null>(null);
   if (!shortcutCollectionOwnerRef.current) {
     shortcutCollectionOwnerRef.current = createShortcutCollectionOwner();
@@ -254,6 +270,9 @@ export function useCollectionInteractions<T>(
 
   itemsRef.current = items;
   getIdRef.current = getId;
+  if (!setsEqual(selectedIdsRef.current, selectedIds) || anchorIdRef.current !== anchorId) {
+    keyboardRangeBaseRef.current = null;
+  }
   selectedIdsRef.current = selectedIds;
   activeIdRef.current = activeId;
   anchorIdRef.current = anchorId;
@@ -316,6 +335,7 @@ export function useCollectionInteractions<T>(
   const activate = useCallback((id: string) => {
     const item = itemsRef.current.find((candidate) => getIdRef.current(candidate) === id);
     if (!item || !selectableIdsRef.current.includes(id)) return;
+    keyboardRangeBaseRef.current = null;
     setActive(id, 'activate');
     setAnchor(id, 'activate');
     onActivateRef.current?.(item, id);
@@ -323,6 +343,7 @@ export function useCollectionInteractions<T>(
 
   const toggle = useCallback((id: string) => {
     if (selectionMode === 'none' || !selectableIdsRef.current.includes(id)) return;
+    keyboardRangeBaseRef.current = null;
     const next = new Set(selectedIdsRef.current);
     if (next.has(id)) next.delete(id);
     else {
@@ -334,6 +355,7 @@ export function useCollectionInteractions<T>(
   }, [commitSelection, selectionMode, setAnchor]);
 
   const select = useCallback((ids: string[]) => {
+    keyboardRangeBaseRef.current = null;
     const next = new Set(ids);
     const last = ids[ids.length - 1] ?? null;
     setAnchor(last, 'toggle');
@@ -341,12 +363,14 @@ export function useCollectionInteractions<T>(
   }, [commitSelection, setAnchor]);
 
   const clear = useCallback(() => {
+    keyboardRangeBaseRef.current = null;
     setAnchor(null, 'clear');
     commitSelection(new Set(), 'clear');
   }, [commitSelection, setAnchor]);
 
   const selectAll = useCallback(() => {
     if (selectionMode === 'none') return;
+    keyboardRangeBaseRef.current = null;
     const ids = selectionMode === 'single' ? selectableIdsRef.current.slice(0, 1) : selectableIdsRef.current;
     const last = ids[ids.length - 1] ?? null;
     setAnchor(last, 'select-all');
@@ -361,12 +385,16 @@ export function useCollectionInteractions<T>(
       commitSelection(new Set([toId]), reason);
       return;
     }
-    commitSelection(new Set(ids.slice(Math.min(from, to), Math.max(from, to) + 1)), reason);
+    commitSelection(new Set([
+      ...(keyboardRangeBaseRef.current ?? []),
+      ...ids.slice(Math.min(from, to), Math.max(from, to) + 1),
+    ]), reason);
   }, [commitSelection]);
 
   const selectRange = useCallback((fromId: string, toId: string) => {
     const ids = selectableIdsRef.current;
     if (selectionMode === 'none' || !ids.includes(toId)) return;
+    keyboardRangeBaseRef.current = null;
     const resolvedFromId = ids.includes(fromId)
       ? fromId
       : activeIdRef.current && ids.includes(activeIdRef.current)
@@ -390,6 +418,9 @@ export function useCollectionInteractions<T>(
 
   useEffect(() => {
     const allowed = new Set(selectableIds);
+    if (keyboardRangeBaseRef.current) {
+      keyboardRangeBaseRef.current = new Set(Array.from(keyboardRangeBaseRef.current).filter((id) => allowed.has(id)));
+    }
     const pruned = new Set(Array.from(selectedIdsRef.current).filter((id) => allowed.has(id)));
     if (!setsEqual(pruned, selectedIdsRef.current)) commitSelection(pruned, 'items-changed');
     if (activeIdRef.current && !allowed.has(activeIdRef.current)) setActive(null, 'items-changed');
@@ -398,11 +429,39 @@ export function useCollectionInteractions<T>(
     }
   }, [commitSelection, selectableIds, setActive, setAnchor]);
 
+  const focusItem = useCallback((id: string) => {
+    const nodes = containerRef.current?.querySelectorAll<HTMLElement>(`[${COLLECTION_ITEM_ATTRIBUTE}]`);
+    const node = nodes ? Array.from(nodes).find(
+      (candidate) => candidate.getAttribute(COLLECTION_ITEM_ATTRIBUTE) === id && isInteractionElementVisible(candidate),
+    ) : null;
+    node?.focus({ preventScroll: true });
+    node?.scrollIntoView?.({ block: 'nearest', inline: 'nearest' });
+  }, []);
+
+  const focusPointerItem = useCallback((id: string) => {
+    setActive(id, 'activate');
+    focusItem(id);
+  }, [focusItem, setActive]);
+
+  const selectPointerRange = useCallback((id: string) => {
+    const rangeAnchor = anchorIdRef.current ?? activeIdRef.current ?? id;
+    const ids = selectableIdsRef.current;
+    const from = ids.indexOf(rangeAnchor);
+    const to = ids.indexOf(id);
+    const range = new Set(ids.slice(Math.min(from, to), Math.max(from, to) + 1));
+    const base = keyboardRangeBaseRef.current ?? new Set(Array.from(selectedIdsRef.current).filter((selected) => !range.has(selected)));
+    keyboardRangeBaseRef.current = base;
+    setAnchor(rangeAnchor, 'range');
+    replaceRange(rangeAnchor, id, 'range');
+    focusPointerItem(id);
+  }, [focusPointerItem, replaceRange, setAnchor]);
+
   const moveActive = useCallback((direction: CollectionNavigationDirection, extend = false) => {
     const ids = selectableIdsRef.current;
     if (ids.length === 0) return;
     const current = activeIdRef.current;
-    let next = resolveNextIdRef.current?.({
+    // Range gestures follow the displayed order, independent of asymmetric grid geometry.
+    let next = extend ? null : resolveNextIdRef.current?.({
       direction,
       currentId: current,
       items: itemsRef.current,
@@ -419,23 +478,21 @@ export function useCollectionInteractions<T>(
     if (!next || next === current) return;
     const stableAnchor = anchorIdRef.current ?? current ?? next;
     if (extend) {
+      keyboardRangeBaseRef.current ??= new Set(
+        Array.from(selectedIdsRef.current).filter((id) => id !== stableAnchor),
+      );
       if (!anchorIdRef.current) {
         setAnchor(stableAnchor, 'range');
       }
       replaceRange(stableAnchor, next, 'range');
     } else {
+      keyboardRangeBaseRef.current = new Set();
       setAnchor(next, 'navigate');
     }
     setActive(next, extend ? 'range' : 'navigate');
     const nextId = next;
-    requestAnimationFrame(() => {
-      const nodes = containerRef.current?.querySelectorAll<HTMLElement>(`[${COLLECTION_ITEM_ATTRIBUTE}]`);
-      const node = nodes ? Array.from(nodes).find(
-        (candidate) => candidate.getAttribute(COLLECTION_ITEM_ATTRIBUTE) === nextId,
-      ) : null;
-      node?.focus({ preventScroll: true });
-    });
-  }, [replaceRange, setActive, setAnchor]);
+    requestAnimationFrame(() => focusItem(nextId));
+  }, [focusItem, replaceRange, setActive, setAnchor]);
 
   const keyboard = useMemo<CollectionKeyboardShortcuts>(
     () => ({ ...DEFAULT_SHORTCUTS, ...(shortcutOverrides || {}) }),
@@ -478,11 +535,29 @@ export function useCollectionInteractions<T>(
     });
     return definitions;
   }, [activate, clear, keyboard, moveActive, selectAll, selectionMode, toggle]);
+  const isAvailable = useCallback(() => isInteractionElementVisible(containerRef.current), []);
+  useEffect(() => {
+    const owner = shortcutCollectionOwnerRef.current!;
+    const container = containerElement;
+    const Observer = container?.ownerDocument.defaultView?.MutationObserver;
+    const observer = Observer ? new Observer(() => {
+      if (!isAvailable()) releaseShortcutCollection(owner);
+    }) : null;
+    let element: Element | null = container;
+    while (element) {
+      observer?.observe(element, { attributes: true, attributeFilter: ['hidden', 'inert', 'aria-hidden', 'style', 'class'] });
+      const root: Node = element.getRootNode();
+      element = element.parentElement ?? ('host' in root ? (root as ShadowRoot).host : null);
+    }
+    return () => { observer?.disconnect(); releaseShortcutCollection(owner); };
+  }, [containerElement, isAvailable]);
+
   useShortcuts(keyDefinitions, {
     enabled: enabled && bindKeyboardShortcuts,
     scope: shortcutScope,
     priority: shortcutPriority,
     collectionOwnerId: shortcutCollectionOwnerRef.current,
+    isAvailable,
   });
 
   const activateCollectionShortcuts = useCallback(() => {
@@ -604,23 +679,34 @@ export function useCollectionInteractions<T>(
     event.preventDefault();
     event.stopPropagation();
     toggle(id);
+    focusPointerItem(id);
     armSuppressNextClick();
-  }, [armSuppressNextClick, enabled, toggle]);
+  }, [armSuppressNextClick, enabled, focusPointerItem, toggle]);
 
   const onCheckboxClick = useCallback((id: string) => (event: ReactMouseEvent) => {
     event.stopPropagation();
+    if (!enabled) return;
     if (event.shiftKey && selectionMode === 'multiple') {
-      const rangeAnchor = anchorIdRef.current ?? activeIdRef.current ?? id;
-      selectRange(rangeAnchor, id);
-    } else toggle(id);
-  }, [selectRange, selectionMode, toggle]);
+      selectPointerRange(id);
+    } else {
+      toggle(id);
+      focusPointerItem(id);
+    }
+  }, [enabled, focusPointerItem, selectPointerRange, selectionMode, toggle]);
 
   const getRowProps = useCallback((id: string) => ({
     [COLLECTION_ITEM_ATTRIBUTE]: id,
     [LEGACY_ROW_ATTRIBUTE]: id,
   }), []);
 
+  const longPress = useLongPressSelection((id) => {
+    if (!enabled || selectionMode === 'none') return;
+    activateCollectionShortcuts();
+    toggle(id);
+    focusPointerItem(id);
+  });
   const getItemProps = useCallback((id: string) => ({
+    ...(enableLongPressSelection ? longPress(id) : {}),
     [COLLECTION_ITEM_ATTRIBUTE]: id,
     [LEGACY_ROW_ATTRIBUTE]: id,
     tabIndex: activeIdRef.current === id || (!activeIdRef.current && selectableIdsRef.current[0] === id) ? 0 : -1,
@@ -633,15 +719,14 @@ export function useCollectionInteractions<T>(
     },
     onMouseDown: onRowMouseDown(id),
     onClick: (event: ReactMouseEvent) => {
-      if (event.defaultPrevented) return;
+      if (!enabled || event.defaultPrevented) return;
       if (!selectableIdsRef.current.includes(id)) return;
       const target = event.target as HTMLElement | null;
       const interactiveTarget = target?.closest(INTERACTIVE_SELECTOR);
       if (interactiveTarget && interactiveTarget !== event.currentTarget) return;
       if (event.shiftKey && selectionMode === 'multiple') {
         event.preventDefault();
-        const rangeAnchor = anchorIdRef.current ?? activeIdRef.current ?? id;
-        selectRange(rangeAnchor, id);
+        selectPointerRange(id);
         return;
       }
       if (event.metaKey || event.ctrlKey) return;
@@ -649,19 +734,19 @@ export function useCollectionInteractions<T>(
       activate(id);
     },
     onKeyDown: (event: ReactKeyboardEvent) => {
-      if (event.key !== ' ' || event.metaKey || event.ctrlKey || event.altKey) return;
+      if (!enabled || event.key !== ' ' || event.metaKey || event.ctrlKey || event.altKey) return;
       if (event.target !== event.currentTarget) return;
       event.preventDefault();
       if (selectionMode === 'none') activate(id);
       else toggle(id);
     },
-  }), [activate, activateCollectionShortcuts, clear, clearSelectionOnPlainClick, onRowMouseDown, selectRange, selectionMode, setActive, toggle]);
+  }), [activate, activateCollectionShortcuts, clear, clearSelectionOnPlainClick, enabled, enableLongPressSelection, longPress, onRowMouseDown, selectPointerRange, selectionMode, setActive, toggle]);
 
   const getCheckboxProps = useCallback((id: string) => ({
     isSelected: selectedIdsRef.current.has(id),
-    disabled: !selectableIdsRef.current.includes(id),
+    disabled: !enabled || !selectableIdsRef.current.includes(id),
     onClick: onCheckboxClick(id),
-  }), [onCheckboxClick]);
+  }), [enabled, onCheckboxClick]);
 
   const getSelectedItems = useCallback(() => getItemsForIds(selectedIdsRef.current), [getItemsForIds]);
   const isSelected = useCallback((id: string) => selectedIds.has(id), [selectedIds]);
@@ -681,14 +766,38 @@ export function useCollectionInteractions<T>(
       icon: action.icon,
       shortcut,
       destructive: action.destructive ?? action.intent === 'delete',
-      disabled,
+      disabled: !enabled || disabled,
       pending: action.pending,
-      onRun: () => action.onRun(actionContext),
+      onRun: () => { if (!enabled || disabled || action.pending) return; return action.onRun(actionContext); },
     };
-  }), [actionContext, actionDefinitions]);
+  }), [actionContext, actionDefinitions, enabled]);
+
+  // Optimistic filtering can remove the last selected row before a request settles.
+  // Keep pending keys on the visible controller, independently of toolbar mounting.
+  useShortcuts(resolvedActions.flatMap((action): ShortcutDefinition[] => (
+    action.shortcut && (action.pending || action.disabled)
+      ? [{ id: `collection.pending.${action.id}`, keys: action.shortcut, allowRepeat: true, onTrigger: () => undefined }]
+      : []
+  )), {
+    enabled: bindKeyboardShortcuts && resolvedActions.some((action) => action.pending),
+    scope: shortcutScope,
+    priority: shortcutPriority + 25,
+    collectionOwnerId: shortcutCollectionOwnerRef.current!,
+    isAvailable,
+  });
+
+  const getActionBarProps = useCallback(() => ({
+    selectedCount: selectedIds.size,
+    actions: resolvedActions,
+    collectionOwnerId: shortcutCollectionOwnerRef.current!,
+    isAvailable,
+    // Pending work may disable collection gestures but must retain its action keys.
+    shortcutsEnabled: bindKeyboardShortcuts && (enabled || resolvedActions.some((action) => action.pending)),
+    onClearSelection: enabled ? clear : undefined,
+  }), [selectedIds.size, resolvedActions, isAvailable, enabled, bindKeyboardShortcuts, clear]);
 
   const getContainerProps = useCallback(() => ({
-    ref: (node: HTMLElement | null) => { containerRef.current = node; },
+    ref: setContainerRef,
     onMouseDown: (event: ReactMouseEvent) => {
       activateCollectionShortcuts();
       handleContainerMouseDown(event);
@@ -696,7 +805,7 @@ export function useCollectionInteractions<T>(
     onFocusCapture: activateCollectionShortcuts,
     onClickCapture: handleContainerClickCapture,
     style: { userSelect: 'none' as const },
-  }), [activateCollectionShortcuts, handleContainerClickCapture, handleContainerMouseDown]);
+  }), [activateCollectionShortcuts, handleContainerClickCapture, handleContainerMouseDown, setContainerRef]);
 
   return {
     selectedIds,
@@ -707,6 +816,7 @@ export function useCollectionInteractions<T>(
     lastClickedId: anchorId,
     dragRect,
     actions: resolvedActions,
+    getActionBarProps,
     isSelected,
     getSelectedItems,
     setActive,

package/template/packages/sdk/src/hooks/useDocuments.ts

@@ -19,6 +19,8 @@ export interface UseDocumentsOptions {
   offset?: number;
   /** Fetch every page, starting at offset, instead of returning only one page. */
   fetchAll?: boolean;
+  /** App-view lists can omit bodies until opening/searching a document. Default: true. */
+  includeContent?: boolean;
   enabled?: boolean;
 }
 
@@ -47,7 +49,7 @@ export function useDocuments(
 ): UseDocumentsResult {
   const runtime = useNotisRuntime();
   const query = useQuery<DocumentRecord[]>(
-    ['documents', databaseSlug, options.filter ?? null, options.pageSize ?? null, options.offset ?? 0, Boolean(options.fetchAll)],
+    ['documents', databaseSlug, options.filter ?? null, options.pageSize ?? null, options.offset ?? 0, Boolean(options.fetchAll), options.includeContent !== false],
     async () => {
       if (!runtime) throw new Error('Notis runtime not available');
       const allDocuments: unknown[] = [];
@@ -58,6 +60,7 @@ export function useDocuments(
           query: {
             ...(options.filter ?? {}),
             ...(options.pageSize !== undefined ? { page_size: options.pageSize } : {}),
+            ...(options.includeContent === false ? { include_content: false } : {}),
           },
           ...(offset > 0 ? { offset } : {}),
         }, { dedupe: true, readOnly: true });

package/template/packages/sdk/src/hooks/useLongPressSelection.ts

@@ -0,0 +1,79 @@
+'use client';
+
+import { useCallback, useEffect, useRef } from 'react';
+import type {
+  MouseEvent as ReactMouseEvent,
+  PointerEvent as ReactPointerEvent,
+} from 'react';
+
+const LONG_PRESS_MS = 500;
+const MOVE_TOLERANCE_PX = 10;
+const INTERACTIVE_SELECTOR = [
+  'button',
+  'a[href]',
+  'input',
+  'textarea',
+  'select',
+  'summary',
+  '[contenteditable]:not([contenteditable="false"])',
+  '[role="button"]',
+  '[role="link"]',
+  '[role="menuitem"]',
+  '[role="option"]',
+  '[role="switch"]',
+  '[role="tab"]',
+].join(', ');
+
+/** Adds a touch-only long-press entry point without rendering idle checkboxes. */
+export function useLongPressSelection(onSelect: (id: string) => void) {
+  const onSelectRef = useRef(onSelect);
+  onSelectRef.current = onSelect;
+  const timerRef = useRef<number | null>(null);
+  const startRef = useRef<{ x: number; y: number } | null>(null);
+  const suppressClickRef = useRef(false);
+
+  const cancel = useCallback(() => {
+    if (timerRef.current !== null) window.clearTimeout(timerRef.current);
+    timerRef.current = null;
+    startRef.current = null;
+  }, []);
+
+  useEffect(() => cancel, [cancel]);
+
+  return useCallback((id: string) => ({
+    onPointerDown: (event: ReactPointerEvent<HTMLElement>) => {
+      if (event.pointerType !== 'touch' || event.button !== 0) return;
+      const target = event.target;
+      if (
+        target instanceof HTMLElement
+        && target !== event.currentTarget
+        && target.closest(INTERACTIVE_SELECTOR)
+      ) return;
+      cancel();
+      startRef.current = { x: event.clientX, y: event.clientY };
+      timerRef.current = window.setTimeout(() => {
+        timerRef.current = null;
+        startRef.current = null;
+        suppressClickRef.current = true;
+        onSelectRef.current(id);
+      }, LONG_PRESS_MS);
+    },
+    onPointerMove: (event: ReactPointerEvent<HTMLElement>) => {
+      const start = startRef.current;
+      if (!start) return;
+      if (
+        Math.abs(event.clientX - start.x) > MOVE_TOLERANCE_PX
+        || Math.abs(event.clientY - start.y) > MOVE_TOLERANCE_PX
+      ) cancel();
+    },
+    onPointerUp: cancel,
+    onPointerCancel: cancel,
+    onClickCapture: (event: ReactMouseEvent<HTMLElement>) => {
+      if (!suppressClickRef.current) return false;
+      suppressClickRef.current = false;
+      event.preventDefault();
+      event.stopPropagation();
+      return true;
+    },
+  }), [cancel]);
+}

package/template/packages/sdk/src/hooks/useMultiSelect.ts

@@ -43,10 +43,7 @@ export interface MultiSelectController<T> {
   onCheckboxClick: (id: string) => (event: ReactMouseEvent) => void;
   onRowMouseDown: (id: string) => (event: ReactMouseEvent) => void;
   getRowProps: (id: string) => { [ROW_ATTR]: string };
-  getItemProps: (id: string) => {
-    [ROW_ATTR]: string;
-    onMouseDown: (event: ReactMouseEvent) => void;
-  };
+  getItemProps: CollectionInteractionController<T>['getItemProps'];
   getCheckboxProps: (id: string) => {
     isSelected: boolean;
     onClick: (event: ReactMouseEvent) => void;
@@ -72,10 +69,7 @@ export function useMultiSelect<T>(options: UseMultiSelectOptions<T>): MultiSelec
   });
 
   const getRowProps = useCallback((id: string) => ({ [ROW_ATTR]: id }), []);
-  const getItemProps = useCallback((id: string) => ({
-    [ROW_ATTR]: id,
-    onMouseDown: controller.onRowMouseDown(id),
-  }), [controller.onRowMouseDown]);
+  const getItemProps = controller.getItemProps;
 
   return {
     selectedIds: controller.selectedIds,

package/template/packages/sdk/src/index.ts

@@ -151,3 +151,6 @@ export type {
 export { useToolQuery } from './hooks/useToolQuery';
 
 export { Skeleton, ViewSkeleton } from './components/Skeleton';
+
+export { useLongPressSelection } from './hooks/useLongPressSelection';
+export { isInteractionElementVisible } from './interactions/visibility';

package/template/packages/sdk/src/interactions/actions.ts

@@ -1,6 +1,10 @@
 import type { ReactNode } from 'react';
 
-export type CollectionActionIntent = 'archive' | 'star' | 'delete' | 'custom';
+export type CollectionActionIntent =
+  | 'archive' | 'star' | 'delete'
+  | 'enable' | 'disable' | 'pause' | 'resume'
+  | 'move' | 'add-to-folder' | 'complete' | 'start-progress'
+  | 'custom';
 
 export interface CollectionActionContext<T> {
   selectedIds: string[];
@@ -13,6 +17,7 @@ export interface CollectionAction<T> {
   intent?: CollectionActionIntent;
   label?: string;
   icon?: ReactNode;
+  /** Omit to use the intent default, supply a key to override, or false to remove it. */
   shortcut?: string | false;
   destructive?: boolean;
   disabled?: boolean | ((context: CollectionActionContext<T>) => boolean);
@@ -35,6 +40,14 @@ const ACTION_DEFAULTS: Record<Exclude<CollectionActionIntent, 'custom'>, { label
   archive: { label: 'Archive', shortcut: 'E' },
   star: { label: 'Star', shortcut: 'S' },
   delete: { label: 'Delete', shortcut: '#' },
+  enable: { label: 'Enable', shortcut: 'E' },
+  disable: { label: 'Disable', shortcut: 'D' },
+  pause: { label: 'Pause', shortcut: 'P' },
+  resume: { label: 'Resume', shortcut: 'R' },
+  move: { label: 'Move', shortcut: 'M' },
+  'add-to-folder': { label: 'Add to folder', shortcut: 'F' },
+  complete: { label: 'Mark complete', shortcut: 'C' },
+  'start-progress': { label: 'Start progress', shortcut: 'P' },
 };
 
 export function collectionActionDefaults(intent: CollectionActionIntent | undefined): {