@notis_ai/cli 0.2.17 → 0.2.19

package/dist/sdk/src/tailwind.ts

@@ -0,0 +1,66 @@
+/** Build-only SDK content discovery. Author configuration and PostCSS plugins stay intact. */
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export function notisTailwindContent() {
+  let root = process.cwd();
+  let temporary: string | undefined;
+  const wrappers = new Map<string, string>();
+  const cleanup = () => {
+    if (temporary) rmSync(temporary, { recursive: true, force: true });
+    temporary = undefined;
+    wrappers.clear();
+  };
+  return {
+    name: 'notis-sdk-tailwind-content',
+    enforce: 'pre' as const,
+    configResolved(config: { root: string }) { root = config.root; },
+    transform(source: string, id: string) {
+      const stylesheet = id.split('?')[0];
+      if (!stylesheet.endsWith('.css')) return null;
+      // Tailwind 4 discovers dependency sources through CSS, not config.content.
+      // Keep the author's imports, configuration and PostCSS pipeline untouched.
+      if (/@import\s+(?:url\(\s*)?(['"])tailwindcss(?:\/[^'"]*)?\1/.test(source)) {
+        const sdkSource = dirname(fileURLToPath(import.meta.url));
+        const relativeSource = './' + relative(dirname(stylesheet), sdkSource).replaceAll('\\', '/');
+        const directive = `@source ${JSON.stringify(relativeSource)};`;
+        return source.includes(directive) ? null : { code: `${source}\n${directive}\n`, map: null };
+      }
+      if (!/@tailwind\s/.test(source)) return null;
+      const explicit = source.match(/@config\s+(['"])(.*?)\1\s*;/);
+      const config = explicit
+        ? resolve(dirname(id.split('?')[0]), explicit[2])
+        : ['ts', 'js', 'cjs', 'mjs'].map(ext => join(root, `tailwind.config.${ext}`)).find(existsSync);
+      if (!config) return null;
+      let wrapper = wrappers.get(config);
+      if (!wrapper) {
+        temporary ||= mkdtempSync(join(tmpdir(), 'notis-tailwind-'));
+        wrapper = join(temporary, `config-${wrappers.size}.ts`);
+        const sdkGlob = join(dirname(fileURLToPath(import.meta.url)), '**/*.{ts,tsx}').replaceAll('\\', '/');
+        writeFileSync(wrapper, `import config from ${JSON.stringify(config)};
+import { resolve } from 'node:path';
+const content = config.content || [];
+const files = Array.isArray(content) ? content : (content.files || []);
+const base = ${JSON.stringify(root)};
+const relativeBase = ${JSON.stringify(dirname(config))};
+export default { ...config, content: {
+  ...(Array.isArray(content) ? {} : content),
+  relative: false,
+  files: [...files.map(file => typeof file !== 'string' ? file :
+    (file.startsWith('!') ? '!' : '') + resolve(content.relative ? relativeBase : base, file.replace(/^!/, ''))),
+    ${JSON.stringify(sdkGlob)}],
+} };
+`);
+        wrappers.set(config, wrapper);
+      }
+      const directive = `@config ${JSON.stringify('./' + relative(dirname(id.split('?')[0]), wrapper).replaceAll('\\', '/'))};`;
+      // Imports must remain before @config. Vite resolves them before PostCSS.
+      const code = explicit ? source.replace(explicit[0], directive) : `${source}\n${directive}\n`;
+      return { code, map: null };
+    },
+    closeBundle: cleanup,
+    closeWatcher: cleanup,
+  };
+}

package/dist/sdk/src/ui/charts/RenderChartData.tsx

@@ -0,0 +1,25 @@
+'use client';
+
+import * as React from 'react';
+import type { ReactNode } from 'react';
+
+export interface RenderChartDataProps {
+  title: string;
+  columns: readonly string[];
+  rows: readonly (readonly (string | number | boolean | null)[])[];
+  /** The visible chart. `Chart` and `ChartTable` already render their own data table. */
+  children?: ReactNode;
+}
+
+/**
+ * A chart's data, available to view Markdown without adding a second visible table (toolkit spec 2.11; moved from
+ * `src/components/RenderChartData.tsx`). Keep labels and values identical to the chart. The renderer recognizes this
+ * semantic table inside Shadow DOM; snapshots never infer numbers from SVG geometry. `Chart` renders its numbers
+ * through it.
+ */
+export function RenderChartData({ title, columns, rows, children }: RenderChartDataProps) {
+  return <>{children}<table hidden data-notis-render="chart-data" aria-label={title}>
+    <thead><tr>{columns.map((column, index) => <th key={index}>{column}</th>)}</tr></thead>
+    <tbody>{rows.map((row, index) => <tr key={index}>{columns.map((_, column) => <td key={column}>{row[column] == null ? '' : String(row[column])}</td>)}</tr>)}</tbody>
+  </table></>;
+}

package/dist/sdk/src/ui/engine/core.ts

@@ -0,0 +1,392 @@
+/**
+ * The one keyboard listener (toolkit spec 2.1). Document capture phase; React handlers no longer own keys.
+ * No React here: the React pieces (`KeyboardEngine`, hooks) drive one shared core.
+ */
+
+import { DEFAULT_KEYMAP, isModifierOnlyKey, matchChord, type Chord, type Locale, type Platform } from '../../words';
+import {
+  blocksShortcuts,
+  eventTarget,
+  fieldOwnsEscape,
+  foreignFloatingLayers,
+  hasOpenModal,
+  isActivatable,
+  keysOff,
+  ownsArrows,
+} from './dom';
+import { ROOT_OWNER, ShortcutRegistry, safeWhen, type RegisteredShortcut } from './registry';
+import type { EngineSettings, ShortcutDef } from './types';
+
+/** Escape chain order, highest first: menus and dialogs, help sheet, selection clear, detail panel, route back. */
+export const ESCAPE_PRIORITY = Object.freeze({
+  route: 0,
+  detail: 100,
+  selection: 200,
+  help: 300,
+  overlay: 400,
+});
+
+export const SEQUENCE_TIMEOUT_MS = 1500;
+
+interface EscapeLayerRecord { id: string; priority: number; onEscape: (event?: KeyboardEvent) => boolean; seq: number }
+interface EscapeBlockerRecord { priority: number; seq: number; isActive?: () => boolean }
+interface PendingSequence { candidates: Array<{ entry: RegisteredShortcut; chords: Chord[] }>; step: number; at: number }
+
+export function detectPlatform(): Platform {
+  if (typeof navigator === 'undefined') return 'other';
+  const nav = navigator as Navigator & { userAgentData?: { platform?: string } };
+  const name = nav.userAgentData?.platform || nav.platform || nav.userAgent || '';
+  return /mac|iphone|ipad|ipod/i.test(name) ? 'mac' : 'other';
+}
+
+export function detectLocale(): Locale {
+  if (typeof document === 'undefined') return 'en';
+  // The page language set by the host on <html>.
+  const lang = document.querySelector('html')?.getAttribute('lang') ?? '';
+  return /^fr\b/i.test(lang) ? 'fr' : 'en';
+}
+
+function defaultStrict(): boolean {
+  const env = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env;
+  return env?.NODE_ENV !== 'production';
+}
+
+function consume(event: KeyboardEvent, immediate = false): void {
+  event.preventDefault();
+  if (immediate) event.stopImmediatePropagation();
+  else event.stopPropagation();
+}
+
+function isUnmodifiedEscape(event: KeyboardEvent): boolean {
+  return event.key === 'Escape' && !event.metaKey && !event.ctrlKey && !event.altKey && !event.shiftKey;
+}
+
+export class KeyboardEngineCore {
+  readonly registry: ShortcutRegistry;
+  settings: EngineSettings;
+  /** Mounted `<KeyboardEngine>` count. With none, settings hooks fall back to the document (lang). */
+  mounted = 0;
+  /** Clock, replaceable in tests. */
+  now: () => number = () => Date.now();
+
+  private layers: EscapeLayerRecord[] = [];
+  private blockers: EscapeBlockerRecord[] = [];
+  private seq = 0;
+  private held = new Set<string>();
+  private pending: PendingSequence | null = null;
+  private attached = new Map<Document, { refs: number; detach: () => void }>();
+  private helpOpen = false;
+  private helpUnregister: (() => void) | null = null;
+  private forcedRepeat = new WeakSet<KeyboardEvent>();
+
+  constructor(settings: Partial<EngineSettings> = {}) {
+    this.settings = {
+      host: settings.host ?? 'portal',
+      locale: settings.locale ?? detectLocale(),
+      platform: settings.platform ?? detectPlatform(),
+      strict: settings.strict ?? defaultStrict(),
+      onClash: settings.onClash,
+    };
+    this.registry = new ShortcutRegistry({ strict: this.settings.strict, onClash: this.settings.onClash });
+  }
+
+  /** Updates settings. Returns true when one changed; listeners hear it unless `silent` (during a React render). */
+  configure(settings: Partial<EngineSettings>, options: { silent?: boolean } = {}): boolean {
+    const next = { ...this.settings };
+    for (const [key, value] of Object.entries(settings)) {
+      if (value !== undefined) (next as Record<string, unknown>)[key] = value;
+    }
+    const changed = (Object.keys(next) as Array<keyof EngineSettings>).some((key) => next[key] !== this.settings[key]);
+    this.settings = next;
+    this.registry.options = { strict: next.strict, onClash: next.onClash };
+    if (changed && !options.silent) this.registry.notify();
+    return changed;
+  }
+
+  subscribe(listener: () => void): () => void {
+    return this.registry.subscribe(listener);
+  }
+
+  getVersion(): number {
+    return this.registry.getVersion();
+  }
+
+  // ---- listeners ----
+
+  /** Starts listening on a document. Ref counted; the last detach removes the listeners. */
+  attach(doc: Document): () => void {
+    const existing = this.attached.get(doc);
+    if (existing) {
+      existing.refs += 1;
+    } else {
+      const onKeyDown = (event: Event) => this.handleKeyDown(event as KeyboardEvent);
+      const onKeyUp = (event: Event) => this.handleKeyUp(event as KeyboardEvent);
+      const onReset = () => this.resetHeld();
+      const onVisibility = () => { if (doc.visibilityState === 'hidden') this.resetHeld(); };
+      doc.addEventListener('keydown', onKeyDown, true);
+      doc.addEventListener('keyup', onKeyUp, true);
+      doc.addEventListener('visibilitychange', onVisibility);
+      doc.defaultView?.addEventListener('blur', onReset);
+      this.attached.set(doc, {
+        refs: 1,
+        detach: () => {
+          doc.removeEventListener('keydown', onKeyDown, true);
+          doc.removeEventListener('keyup', onKeyUp, true);
+          doc.removeEventListener('visibilitychange', onVisibility);
+          doc.defaultView?.removeEventListener('blur', onReset);
+        },
+      });
+    }
+    this.ensureHelpShortcut();
+    let detached = false;
+    return () => {
+      if (detached) return;
+      detached = true;
+      const record = this.attached.get(doc);
+      if (!record) return;
+      record.refs -= 1;
+      if (record.refs <= 0) {
+        record.detach();
+        this.attached.delete(doc);
+      }
+    };
+  }
+
+  isAttached(doc: Document): boolean {
+    return this.attached.has(doc);
+  }
+
+  /** The first document the engine listens on (the host page), or null before KeyboardEngine mounts. */
+  attachedDocument(): Document | null {
+    for (const doc of this.attached.keys()) return doc;
+    return null;
+  }
+
+  private resetHeld(): void {
+    this.held.clear();
+    this.pending = null;
+  }
+
+  // ---- registration ----
+
+  register(def: ShortcutDef, owner?: string): (() => void) | null {
+    return this.registry.register(def, owner ?? def.owner ?? ROOT_OWNER);
+  }
+
+  defineOwner: ShortcutRegistry['defineOwner'] = (id, options) => this.registry.defineOwner(id, options);
+
+  setOwnerAvailable(id: string, available: boolean): void {
+    this.registry.setOwnerAvailable(id, available);
+  }
+
+  isOwnerAvailable(id: string): boolean {
+    return this.registry.isOwnerAvailable(id);
+  }
+
+  // ---- escape chain ----
+
+  addEscapeLayer(id: string, onEscape: (event?: KeyboardEvent) => boolean,
+    priority: number = ESCAPE_PRIORITY.overlay): () => void {
+    const layer: EscapeLayerRecord = { id, onEscape, priority, seq: ++this.seq };
+    this.layers.push(layer);
+    return () => {
+      const index = this.layers.indexOf(layer);
+      if (index !== -1) this.layers.splice(index, 1);
+    };
+  }
+
+  addEscapeBlocker(priority: number = ESCAPE_PRIORITY.detail + 50, isActive?: () => boolean): () => void {
+    const blocker: EscapeBlockerRecord = { priority, seq: ++this.seq, isActive };
+    this.blockers.push(blocker);
+    return () => {
+      const index = this.blockers.indexOf(blocker);
+      if (index !== -1) this.blockers.splice(index, 1);
+    };
+  }
+
+  escapeLayerIds(): string[] {
+    return this.sortedLayers().map((layer) => layer.id);
+  }
+
+  private sortedLayers(): EscapeLayerRecord[] {
+    return [...this.layers].sort((a, b) => b.priority - a.priority || b.seq - a.seq);
+  }
+
+  /**
+   * Runs the chain. True when a layer handled it. Called without an event by a Close button that means "Escape";
+   * from a key press each layer gets the keydown.
+   */
+  runEscapeChain(event?: KeyboardEvent): boolean {
+    const blockers = this.blockers.filter(blocker => !blocker.isActive || blocker.isActive());
+    const top = blockers.reduce((max, blocker) => Math.max(max, blocker.priority), -Infinity);
+    for (const layer of this.sortedLayers()) {
+      if (layer.priority < top) return true;
+      let handled = false;
+      try { handled = layer.onEscape(event) === true; } catch (error) { reportError(error); handled = true; }
+      if (handled) return true;
+    }
+    return blockers.length > 0;
+  }
+
+  // ---- help sheet ----
+
+  isHelpOpen(): boolean {
+    return this.helpOpen;
+  }
+
+  openHelp(): void {
+    if (this.helpOpen) return;
+    this.helpOpen = true;
+    this.registry.notify();
+  }
+
+  closeHelp(): void {
+    if (!this.helpOpen) return;
+    this.helpOpen = false;
+    this.registry.notify();
+  }
+
+  toggleHelp(): void {
+    if (this.helpOpen) this.closeHelp(); else this.openHelp();
+  }
+
+  private ensureHelpShortcut(): void {
+    if (this.helpUnregister) return;
+    const entry = DEFAULT_KEYMAP['host.help'];
+    this.helpUnregister = this.registry.register({
+      id: entry.id,
+      keys: [...entry.keys],
+      scope: 'app',
+      label: entry.label,
+      group: 'notis',
+      run: () => { this.toggleHelp(); },
+    }, ROOT_OWNER);
+  }
+
+  // ---- dispatch ----
+
+  /** True for a key repeat, including a press of a key that is still held (some hosts drop `event.repeat`). */
+  isRepeat(event: KeyboardEvent): boolean {
+    return event.repeat || this.forcedRepeat.has(event);
+  }
+
+  handleKeyUp(event: KeyboardEvent): void {
+    if (event.key === 'Meta') {
+      // A Mac sends no keyup for keys released while Cmd was down.
+      this.held.clear();
+      return;
+    }
+    this.held.delete(event.code || event.key);
+  }
+
+  handleKeyDown(event: KeyboardEvent): void {
+    if (event.isComposing || event.keyCode === 229) return;
+    const key = event.key;
+    if (!key || key === 'Dead' || key === 'Process' || isModifierOnlyKey(key)) return;
+    const physical = event.code || key;
+    const repeat = event.repeat || this.held.has(physical);
+    if (!event.metaKey) this.held.add(physical);
+    if (repeat && !event.repeat) {
+      this.forcedRepeat.add(event);
+      try { Object.defineProperty(event, 'repeat', { value: true, configurable: true }); } catch { /* read-only host */ }
+    }
+
+    const target = eventTarget(event);
+    const doc = target?.ownerDocument ?? (typeof document !== 'undefined' ? document : null);
+    if (!doc || keysOff(target)) return;
+
+    if (isUnmodifiedEscape(event) && this.handleEscape(event, target, doc, repeat)) return;
+    if (event.defaultPrevented) return;
+
+    const lower = key.toLowerCase();
+    // A button takes its own plain Enter and Space; Cmd+Enter (save) still reaches the shortcuts.
+    const plain = !event.metaKey && !event.ctrlKey && !event.altKey;
+    if (plain && (lower === 'enter' || lower === ' ') && isActivatable(target)) { this.pending = null; return; }
+    if (lower.startsWith('arrow') && ownsArrows(target)) return;
+
+    let modal: boolean | null = null;
+    const isModal = () => (modal ??= hasOpenModal(doc, event));
+    const { platform } = this.settings;
+
+    const eligible = (entry: RegisteredShortcut): boolean => {
+      const { def } = entry;
+      if (repeat && !def.repeat) return false;
+      if (isModal() && def.scope !== 'modal') return false;
+      if (blocksShortcuts(target, { inFields: !!def.allowInFields, modal: def.scope === 'modal' })) return false;
+      if (def.when && !safeWhen(def.when)) return false;
+      return true;
+    };
+
+    // A sequence in progress ('g' then 'i').
+    const pending = this.pending;
+    this.pending = null;
+    if (pending && !repeat && this.now() - pending.at <= SEQUENCE_TIMEOUT_MS) {
+      const next = pending.candidates.filter(({ entry, chords }) =>
+        matchChord(event, chords[pending.step]!, platform) && this.registry.all().includes(entry) && eligible(entry));
+      if (next.length) {
+        const done = next.filter(({ chords }) => chords.length === pending.step + 1);
+        for (const { entry } of done) {
+          if (this.run(entry, event)) { consume(event); return; }
+        }
+        const longer = next.filter(({ chords }) => chords.length > pending.step + 1);
+        if (longer.length) {
+          this.pending = { candidates: longer, step: pending.step + 1, at: this.now() };
+          consume(event);
+          return;
+        }
+      }
+    }
+
+    const active = this.registry.active();
+    for (const entry of active) {
+      if (!entry.chords.some((chords) => chords.length === 1 && matchChord(event, chords[0]!, platform))) continue;
+      if (!eligible(entry)) continue;
+      if (this.run(entry, event)) { consume(event); return; }
+    }
+
+    if (repeat) return;
+    const starts: PendingSequence['candidates'] = [];
+    for (const entry of active) {
+      for (const chords of entry.chords) {
+        if (chords.length > 1 && matchChord(event, chords[0]!, platform) && eligible(entry)) starts.push({ entry, chords });
+      }
+    }
+    if (starts.length) {
+      this.pending = { candidates: starts, step: 1, at: this.now() };
+      consume(event);
+    }
+  }
+
+  private run(entry: RegisteredShortcut, event: KeyboardEvent): boolean {
+    try {
+      return entry.def.run(event) !== false;
+    } catch (error) {
+      reportError(error);
+      return true;
+    }
+  }
+
+  /** True when Escape is fully handled here (nothing else should see it as a shortcut). */
+  private handleEscape(event: KeyboardEvent, target: Element | null, doc: Document, repeat: boolean): boolean {
+    this.pending = null;
+    // A field owns Escape, handled or not; inside a toolkit Popover or Menu, Escape in a field closes the layer.
+    if (fieldOwnsEscape(target)) return true;
+    const foreign = foreignFloatingLayers(doc, event);
+    if (repeat) {
+      // A held Escape must not peel off one layer after another.
+      if (foreign.length || this.layers.length) consume(event, true);
+      return true;
+    }
+    if (event.defaultPrevented) return true;
+    // Radix and native dialogs close themselves.
+    if (foreign.length) return true;
+    if (!this.layers.length && !this.blockers.length) return false;
+    const handled = this.runEscapeChain(event);
+    if (handled) consume(event);
+    return handled;
+  }
+}
+
+function reportError(error: unknown): void {
+  if (typeof console !== 'undefined') console.error('[notis keys] A shortcut failed.', error);
+}

package/dist/sdk/src/ui/engine/dom.ts

@@ -0,0 +1,183 @@
+/**
+ * DOM rules of the keyboard engine: typing targets, modal isolation and floating layers, across open shadow roots
+ * (Spaces render in a Shadow DOM inside the Portal).
+ */
+
+/** Inputs that take no text: keys pass through them. */
+const NON_TEXT_INPUTS = new Set(['button', 'checkbox', 'color', 'file', 'hidden', 'image', 'radio', 'reset', 'submit']);
+
+function isElement(value: unknown): value is Element {
+  return !!value && typeof (value as Element).matches === 'function';
+}
+
+/** The real target, inside shadow roots. */
+export function eventTarget(event: Event): Element | null {
+  const path = typeof event.composedPath === 'function' ? event.composedPath() : [];
+  const first = path.find(isElement);
+  if (first) return first;
+  return isElement(event.target) ? event.target : null;
+}
+
+/** `closest` that crosses shadow boundaries. */
+export function closestComposed(element: Element | null, selector: string): Element | null {
+  let current: Element | null = element;
+  while (current) {
+    const found = current.closest(selector);
+    if (found) return found;
+    const root = current.getRootNode();
+    current = 'host' in root ? (root as ShadowRoot).host : null;
+  }
+  return null;
+}
+
+/** `contains` across shadow boundaries: `element` is `container` or sits inside it, maybe in a nested shadow root. */
+export function containsComposed(container: Element | null, element: Element | null): boolean {
+  let current: Element | null = element;
+  while (current && container) {
+    if (container.contains(current)) return true;
+    const root = current.getRootNode();
+    current = 'host' in root ? (root as ShadowRoot).host : null;
+  }
+  return false;
+}
+
+/** A text field owns its keys (and its Escape). */
+export function isTextEntry(element: Element | null): boolean {
+  if (!element) return false;
+  const tag = element.tagName;
+  if (tag === 'TEXTAREA' || tag === 'SELECT') return true;
+  if (tag === 'INPUT') return !NON_TEXT_INPUTS.has(((element as HTMLInputElement).type || 'text').toLowerCase());
+  if ((element as HTMLElement).isContentEditable) return true;
+  return closestComposed(element,
+    '[contenteditable=""], [contenteditable="true"], [contenteditable="plaintext-only"], [role="textbox"], [role="combobox"], [role="searchbox"]') !== null;
+}
+
+/**
+ * A text field owns its Escape, except inside a toolkit floating layer (Popover, Menu mark `data-notis-floating`):
+ * there Escape closes the layer, unless the field has its own open list (`aria-expanded="true"`).
+ */
+export function fieldOwnsEscape(element: Element | null): boolean {
+  if (!element || !isTextEntry(element)) return false;
+  if (!closestComposed(element, '[data-notis-floating]')) return true;
+  return element.getAttribute('aria-expanded') === 'true';
+}
+
+/** Inside an open menu or listbox: its own keys move through it. */
+export function isInsideOpenMenu(element: Element | null): boolean {
+  if (!element) return false;
+  const menu = closestComposed(element, '[role="menu"], [role="listbox"], [role="menubar"]');
+  // A listbox the engine itself drives (ListReader, useListKeys) keeps J/K/E alive while a row has focus.
+  if (!menu || menu.hasAttribute('data-notis-engine-list')) return false;
+  const state = menu.getAttribute('data-state');
+  return state !== 'closed';
+}
+
+/** Typing rule (toolkit spec 2.1). Buttons and links do not block. */
+export function blocksShortcuts(element: Element | null, options: { inFields: boolean; modal: boolean }): boolean {
+  if (options.inFields) return false;
+  if (isTextEntry(element)) return true;
+  if (!options.modal && isInsideOpenMenu(element)) return true;
+  return false;
+}
+
+/** Enter and Space on a control press the control, not a shortcut. */
+export function isActivatable(element: Element | null): boolean {
+  return closestComposed(element,
+    'button, a[href], [role="button"], [role="switch"], [role="checkbox"], [role="menuitem"], [role="menuitemcheckbox"], [role="menuitemradio"], summary, input[type="checkbox"], input[type="radio"]') !== null;
+}
+
+/** Arrows inside these move the control itself. */
+export function ownsArrows(element: Element | null): boolean {
+  return closestComposed(element,
+    'input[type="range"], [role="slider"], [role="tablist"], [role="radiogroup"], [role="spinbutton"], [role="separator"][tabindex], [role="tree"], [role="grid"]') !== null;
+}
+
+/** Elements opt out of every engine key with `data-notis-keys="off"`. */
+export function keysOff(element: Element | null): boolean {
+  return closestComposed(element, '[data-notis-keys="off"]') !== null;
+}
+
+/** Visible without layout: no hidden, inert, aria-hidden, display none or visibility hidden up the composed tree. */
+export function isVisibleComposed(element: Element | 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;
+}
+
+/** The document and every open shadow root inside it, recursively. */
+export function collectRoots(doc: Document): Array<Document | ShadowRoot> {
+  const roots: Array<Document | ShadowRoot> = [doc];
+  const visit = (root: Document | ShadowRoot) => {
+    const walker = doc.createTreeWalker(root, 1 /* NodeFilter.SHOW_ELEMENT */);
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+      const shadow = (node as Element).shadowRoot;
+      if (shadow) { roots.push(shadow); visit(shadow); }
+    }
+  };
+  visit(doc);
+  return roots;
+}
+
+function queryAllComposed(doc: Document, selector: string, event?: Event): Element[] {
+  const found = new Set<Element>();
+  for (const root of collectRoots(doc)) for (const el of root.querySelectorAll(selector)) found.add(el);
+  if (event && typeof event.composedPath === 'function') {
+    for (const target of event.composedPath()) if (isElement(target) && target.matches(selector)) found.add(target);
+  }
+  return [...found];
+}
+
+/** Open dialogs and menus that isolate keys to the modal scope. `data-notis-nonmodal` opts a popover out. */
+const MODAL_LAYER = [
+  '[role="dialog"][aria-modal="true"]',
+  '[role="dialog"][data-state="open"]',
+  '[role="alertdialog"]:not([data-state="closed"])',
+  'dialog.notis-dialog[open]',
+  'dialog[open][aria-modal="true"]',
+  '[role="menu"][data-state="open"]',
+  '[role="listbox"][data-state="open"]',
+].join(', ');
+
+export function openModalLayers(doc: Document, event?: Event): Element[] {
+  return queryAllComposed(doc, MODAL_LAYER, event)
+    .filter((el) => !el.closest('[data-notis-nonmodal]') && isVisibleComposed(el));
+}
+
+export function hasOpenModal(doc: Document, event?: Event): boolean {
+  return openModalLayers(doc, event).length > 0;
+}
+
+/** The open modal layer `element` sits in (a dialog, menu or listbox), across shadow roots; null on the page. */
+export function modalLayerOf(element: Element | null): Element | null {
+  let current: Element | null = element;
+  while (current) {
+    const layer = closestComposed(current, MODAL_LAYER);
+    if (!layer) return null;
+    if (!layer.closest('[data-notis-nonmodal]')) return layer;
+    // A non-modal popover leaves keys alone: look above it.
+    const root = layer.getRootNode();
+    current = layer.parentElement ?? ('host' in root ? (root as ShadowRoot).host : null);
+  }
+  return null;
+}
+
+/**
+ * Floating layers that handle Escape themselves (Radix, native dialogs). Toolkit layers mark `data-notis-escape-owned`.
+ * An open Radix Select list counts too: it hides the dialog under it from assistive tech, so without it the dialog
+ * would look closed and Escape would also close the reader.
+ */
+const FLOATING_LAYER = 'dialog[open], [role="dialog"]:not([data-state="closed"]), '
+  + '[role="alertdialog"]:not([data-state="closed"]), [role="menu"]:not([data-state="closed"]), '
+  + '[role="listbox"][data-state="open"]';
+
+export function foreignFloatingLayers(doc: Document, event?: Event): Element[] {
+  return queryAllComposed(doc, FLOATING_LAYER, event)
+    .filter((el) => !el.closest('[data-notis-escape-owned]') && isVisibleComposed(el));
+}