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

package/template/packages/sdk/src/interactions/shortcuts.tsx

@@ -42,6 +42,8 @@ export interface UseShortcutsOptions {
   sequenceTimeoutMs?: number;
   /** Internal owner used to route collection shortcuts to the last interacted collection. */
   collectionOwnerId?: string;
+  /** Evaluated at dispatch time, including for retained hidden app views. */
+  isAvailable?: () => boolean;
 }
 
 interface ShortcutRegistration {
@@ -52,6 +54,8 @@ interface ShortcutRegistration {
   enabled: boolean;
   sequenceTimeoutMs: number;
   collectionOwnerId?: string;
+  /** Evaluated at dispatch time, including for retained hidden app views. */
+  isAvailable?: () => boolean;
   getShortcuts: () => ShortcutDefinition[];
 }
 
@@ -92,6 +96,11 @@ export function createShortcutCollectionOwner(): string {
   return `collection-${state.nextOwnerId++}`;
 }
 
+export function releaseShortcutCollection(ownerId: string): void {
+  const state = getShortcutCollectionState();
+  if (state.activeOwnerId === ownerId) state.activeOwnerId = null;
+}
+
 export function activateShortcutCollection(ownerId: string): void {
   getShortcutCollectionState().activeOwnerId = ownerId;
 }
@@ -233,7 +242,7 @@ function applicableRegistrations(
   registrations: Iterable<ShortcutRegistration>,
 ): ShortcutRegistration[] {
   const ordered = Array.from(registrations)
-    .filter((registration) => registration.enabled)
+    .filter((registration) => registration.enabled && registration.isAvailable?.() !== false)
     .sort((a, b) => b.priority - a.priority || b.order - a.order);
   const activeCollectionOwner = getShortcutCollectionState().activeOwnerId;
   const hasActiveCollection = Boolean(
@@ -248,6 +257,60 @@ function applicableRegistrations(
     : ordered;
 }
 
+// Standalone app verification and legacy hosts may not install a provider.
+// They must still arbitrate shortcuts together, not by effect/listener order.
+const FALLBACK_REGISTRIES_SYMBOL = Symbol.for('notis.sdk.fallback_shortcut_registries');
+interface FallbackShortcutRegistry {
+  registrations: Map<number, ShortcutRegistration>;
+  nextId: number;
+  dispatch: (event: KeyboardEvent) => void;
+}
+type FallbackShortcutGlobal = typeof globalThis & {
+  [FALLBACK_REGISTRIES_SYMBOL]?: WeakMap<Document, FallbackShortcutRegistry>;
+};
+
+function registerFallbackShortcut(input: Omit<ShortcutRegistration, 'id' | 'order'>): () => void {
+  const scope = globalThis as FallbackShortcutGlobal;
+  const registries = scope[FALLBACK_REGISTRIES_SYMBOL] ??= new WeakMap();
+  const ownerDocument = document;
+  let registry = registries.get(ownerDocument);
+  if (!registry) {
+    const registrations = new Map<number, ShortcutRegistration>();
+    registry = {
+      registrations,
+      nextId: 1,
+      dispatch: (event) => {
+        if (event.defaultPrevented) return;
+        const editable = isEditableShortcutEvent(event);
+        const token = chordToken(eventChord(event));
+        for (const registration of applicableRegistrations(registrations.values())) {
+          for (const shortcut of registration.getShortcuts()) {
+            if (shortcut.enabled === false || (editable && !shortcut.allowInEditable) || (event.repeat && !shortcut.allowRepeat)) continue;
+            const match = parseShortcut(shortcut).some(
+              (candidate) => candidate.sequence.length === 1 && chordToken(candidate.sequence[0]!) === token,
+            );
+            if (match) {
+              consumeShortcut(event, shortcut);
+              return;
+            }
+          }
+        }
+      },
+    };
+    registries.set(ownerDocument, registry);
+    ownerDocument.addEventListener('keydown', registry.dispatch, true);
+  }
+  const id = registry.nextId++;
+  registry.registrations.set(id, { ...input, id, order: id });
+  return () => {
+    registry.registrations.delete(id);
+    if (registry.registrations.size === 0) {
+      ownerDocument.removeEventListener('keydown', registry.dispatch, true);
+      registries.delete(ownerDocument);
+    }
+  };
+}
+
 function shortcutToken(raw: string): string | null {
   const definition: ShortcutDefinition = { id: '', keys: raw, onTrigger: () => undefined };
   const parsed = parseShortcut(definition)[0];
@@ -575,7 +638,10 @@ export function useShortcuts(
     priority = 0,
     sequenceTimeoutMs = 1500,
     collectionOwnerId,
+    isAvailable,
   } = options;
+  const availableRef = useRef(isAvailable);
+  availableRef.current = isAvailable;
 
   useEffect(() => {
     if (!registry || !enabled) return;
@@ -585,30 +651,24 @@ export function useShortcuts(
       priority: SHORTCUT_SCOPE_PRIORITY[scope] + priority,
       sequenceTimeoutMs,
       collectionOwnerId,
-      getShortcuts: () => shortcutsRef.current,
+      isAvailable: () => availableRef.current?.() !== false,
+      getShortcuts: () => availableRef.current?.() === false ? [] : shortcutsRef.current,
     });
   }, [collectionOwnerId, enabled, priority, registry, scope, sequenceTimeoutMs]);
 
   // Compatibility fallback for SDK components rendered outside a provider.
   useEffect(() => {
     if (registry || !enabled) return;
-    const handleKeyDown = (event: KeyboardEvent) => {
-      if (isEditableShortcutEvent(event)) return;
-      const token = chordToken(eventChord(event));
-      for (const shortcut of shortcutsRef.current) {
-        if (shortcut.enabled === false || event.repeat && !shortcut.allowRepeat) continue;
-        const match = parseShortcut(shortcut).find(
-          (candidate) => candidate.sequence.length === 1 && chordToken(candidate.sequence[0]!) === token,
-        );
-        if (match) {
-          consumeShortcut(event, shortcut);
-          return;
-        }
-      }
-    };
-    document.addEventListener('keydown', handleKeyDown, true);
-    return () => document.removeEventListener('keydown', handleKeyDown, true);
-  }, [enabled, registry]);
+    return registerFallbackShortcut({
+      enabled,
+      scope,
+      priority: SHORTCUT_SCOPE_PRIORITY[scope] + priority,
+      sequenceTimeoutMs,
+      collectionOwnerId,
+      isAvailable: () => availableRef.current?.() !== false,
+      getShortcuts: () => shortcutsRef.current,
+    });
+  }, [collectionOwnerId, enabled, priority, registry, scope, sequenceTimeoutMs]);
 }
 
 export function shortcutDisplay(raw: string): string {

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

@@ -0,0 +1,13 @@
+/** Visibility across light and Shadow DOM, without relying on layout (virtual rows may have no rect). */
+export function isInteractionElementVisible(element: HTMLElement | null): boolean {
+  if (!element?.isConnected) return false;
+  let current: Element | null = element;
+  while (current) {
+    if (current.hasAttribute('hidden') || current.hasAttribute('inert') || current.getAttribute('aria-hidden') === 'true') return false;
+    const style = current.ownerDocument.defaultView?.getComputedStyle(current);
+    if (style?.display === 'none' || style?.visibility === 'hidden') return false;
+    const root: Node = current.getRootNode();
+    current = current.parentElement ?? ('host' in root ? (root as ShadowRoot).host : null);
+  }
+  return true;
+}

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

@@ -40,3 +40,6 @@ export type { MultiSelectDragOverlayProps } from './components/MultiSelectDragOv
 export type { MultiSelectCheckboxProps as SelectionCheckboxProps } from './components/MultiSelectCheckbox';
 export type { MultiSelectDragOverlayProps as SelectionMarqueeProps } from './components/MultiSelectDragOverlay';
 export type { ShortcutHint, ShortcutHintsProps } from './components/ShortcutHints';
+
+export { useLongPressSelection } from './hooks/useLongPressSelection';
+export { isInteractionElementVisible } from './interactions/visibility';

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

@@ -68,6 +68,8 @@ export function createQueryClient(options: {
   maxEntries?: number;
   now?: () => number;
   schedule?: ReturnType<typeof createPrefetchQueue>;
+  /** Bounds idempotent reads only; never retries the underlying callback. */
+  readTimeoutMs?: number;
 } = {}): NotisQueryClient {
   const entries = new Map<string, Entry>();
   const now = options.now ?? Date.now;
@@ -117,14 +119,20 @@ export function createQueryClient(options: {
       const generation = ++value.generation;
       const requestEpoch = epoch;
       const canCommit = () => epoch === requestEpoch && value.generation === generation && entries.get(key) === value;
-      const request = Promise.resolve().then(read).then((data) => {
+      let timeout: ReturnType<typeof setTimeout>;
+      const deadline = new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => reject(new Error('This read took too long. Please retry.')), options.readTimeoutMs ?? 30_000);
+        // Node-based verification must not stay alive for a retired browser read.
+        if (typeof timeout === 'object' && 'unref' in timeout) timeout.unref();
+      });
+      const request = Promise.race([Promise.resolve().then(read), deadline]).then((data) => {
         if (canCommit()) publish(value, { ...value.snapshot, data, hasData: true, isFetching: false, error: null, updatedAt: now() });
         return data;
       }, (reason) => {
         const error = reason instanceof Error ? reason : new Error(String(reason));
         if (canCommit()) publish(value, { ...value.snapshot, isFetching: false, error });
         throw error;
-      }).finally(() => { if (value.pending === request) value.pending = undefined; prune(); });
+      }).finally(() => { clearTimeout(timeout); if (value.pending === request) value.pending = undefined; prune(); });
       value.pending = request;
       publish(value, { ...value.snapshot, isFetching: true, error: null });
       return request;