@pilotiq/pilotiq 0.24.1 → 0.24.2

package/src/react/CollabExtensionFactoryRegistry.ts

@@ -1,55 +0,0 @@
-/**
- * Module-level registry slot for the Tiptap extension factory that turns
- * a collab room into editor-attachable extensions (`Collaboration` +
- * `CollaborationCursor`).
- *
- * Wiring posture (mirrors `PendingSuggestionOverlayRegistry`):
- *   - `@pilotiq-pro/collab`'s plugin calls `registerCollabExtensions(...)`
- *     once at boot from inside `register(panel)`. The factory closes over
- *     the `@tiptap/extension-collaboration` + `-cursor` imports, so pilotiq
- *     core (and `@pilotiq/tiptap`) never carry those as peer deps.
- *   - `@pilotiq/tiptap`'s `TiptapEditor` calls `getCollabExtensions()` at
- *     mount; if non-null AND a `useCollabRoom()` value is present, it calls
- *     the factory and spreads the returned array into the editor's
- *     `extensions` slot. If either is missing, plain Tiptap + History runs.
- *
- * `unknown[]` return type is deliberate — pilotiq core has zero `@tiptap/*`
- * imports and treats the returned values as opaque editor-extension refs.
- * The Tiptap host trusts them and spreads them in.
- */
-export interface CollabExtensionFactoryArgs {
-  /** `Y.Doc` for the surrounding record. Opaque to pilotiq core. */
-  ydoc:      unknown
-  /** `WebsocketProvider` for the same room. Opaque to pilotiq core. */
-  provider:  unknown
-  /**
-   * Field name — becomes the `Y.XmlFragment` selector
-   * (`Collaboration.configure({ field: fieldName })`) so multiple
-   * collab editors on the same record write to distinct fragments
-   * inside one shared ydoc.
-   */
-  fieldName: string
-  /** Presence info forwarded to `CollaborationCursor`. Sparse. */
-  user?: {
-    name?:  string
-    color?: string
-  }
-}
-
-export type CollabExtensionFactory = (args: CollabExtensionFactoryArgs) => unknown[]
-
-let _factory: CollabExtensionFactory | null = null
-
-/**
- * Register the factory that builds collab extensions for one field +
- * room. Called once at boot by `@pilotiq-pro/collab`'s plugin. No-op when
- * no plugin registers — Tiptap renderers fall back to plain editing.
- */
-export function registerCollabExtensions(factory: CollabExtensionFactory): void {
-  _factory = factory
-}
-
-/** Returns the registered factory, or `null`. */
-export function getCollabExtensions(): CollabExtensionFactory | null {
-  return _factory
-}

package/src/react/CollabRoomContext.ts

@@ -1,98 +0,0 @@
-import { createContext, useContext } from 'react'
-
-/**
- * Per-record realtime-collab room — a Y.Doc plus its WebsocketProvider,
- * shared across every collaborative field in the same form. Mirrors the
- * Tiptap "Collaborative Fields" pattern: one ydoc per record, each editor
- * scopes itself to its own `Y.XmlFragment` via the field's `name`.
- *
- * Pilotiq core does NOT instantiate the room — implementation lives in
- * `@pilotiq-pro/collab`, which mounts the context with real Yjs values
- * via `<RecordCollabRoom>`. Core just owns the shape so any field
- * renderer (Tiptap, in-house, third-party) can subscribe through one
- * open-core seam without taking a hard peer dep on Yjs.
- *
- * `ydoc` and `provider` are typed `unknown` deliberately — the consumer
- * (typically `@pilotiq/tiptap`) hands them straight to a registered
- * `CollabExtensionFactory` and never touches them directly, so pilotiq
- * core stays Yjs-free.
- */
-export interface CollabRoom {
-  /** `Y.Doc` instance. Opaque to pilotiq core. */
-  ydoc:      unknown
-  /** `WebsocketProvider` instance. Opaque to pilotiq core. */
-  provider:  unknown
-  /**
-   * Resolves on the provider's first sync. Present when the room is
-   * wired through `@rudderjs/sync/react`'s `useCollabRoom` (which is
-   * what `@pilotiq-pro/collab@>=0.2`'s `<RecordCollabRoom>` does);
-   * absent for legacy / hand-rolled providers. Threaded into the
-   * framework's `useCollabSeed` / `useCollabSeedText` (from
-   * `@rudderjs/sync/react`) so adapters can gate seed callbacks on
-   * first sync without calling `onProviderSynced` directly.
-   */
-  synced?:   Promise<void>
-  /** IndexedDB persistence handle, when the room wraps `y-indexeddb`. Opaque. */
-  persistence?: unknown
-  /** Presence info for cursors / avatars. Forwarded to the extension factory. */
-  user?: {
-    name?:  string
-    color?: string
-  }
-}
-
-/**
- * `null` default — fields read the context, and a null result means
- * "no collab room mounted, fall back to local-only editing." This is
- * the 99% case (collab plugin not installed).
- */
-export const CollabRoomContext = createContext<CollabRoom | null>(null)
-
-/** Read the active collab room for the surrounding record, or `null`. */
-export function useCollabRoom(): CollabRoom | null {
-  return useContext(CollabRoomContext)
-}
-
-/**
- * Minimal structural shape every collab provider exposes for the
- * "initial room state has streamed in" signal. Kept structural so callers
- * (`@pilotiq/tiptap`, `@pilotiq/codemirror`, future adapters) can pass
- * `provider as unknown as SyncedProviderLike` without taking a hard peer
- * dep on yjs / y-websocket / y-webrtc.
- */
-export interface SyncedProviderLike {
-  synced?: boolean
-  once?(event: 'synced', fn: () => void): void
-  off?(event:  'synced', fn: () => void): void
-}
-
-const NOOP_CLEANUP = (): void => {}
-
-/**
- * Run `fn` once the collab provider's initial room state has streamed in.
- * If the provider is already synced, `fn` fires synchronously; otherwise
- * it's registered via `provider.once('synced', fn)`. The returned cleanup
- * unregisters the once handler safely (idempotent + try/catch) so callers
- * can wire it directly into a React effect's cleanup return.
- *
- * Useful for the brand-new-record seed pattern: editors mounting against
- * a freshly-created record want to push the SSR-rendered default into
- * the empty `Y.Text` / `Y.XmlFragment` exactly once after sync, before
- * the user types. Race caveat: two peers simultaneously mounting against
- * a brand-new record can both see `length === 0` and both seed —
- * accepted today across every adapter's seed path.
- */
-export function onProviderSynced(
-  provider: SyncedProviderLike | null | undefined,
-  fn:       () => void,
-): () => void {
-  if (!provider) return NOOP_CLEANUP
-  if (provider.synced) {
-    fn()
-    return NOOP_CLEANUP
-  }
-  provider.once?.('synced', fn)
-  return () => {
-    try { provider.off?.('synced', fn) } catch { /* ignore */ }
-  }
-}

package/src/react/CollabTextRendererRegistry.ts

@@ -1,102 +0,0 @@
-import type { ComponentType } from 'react'
-
-/**
- * Module-level registry slot for the collab-aware plain-text editor renderer.
- *
- * Wiring posture (mirrors `CollabExtensionFactoryRegistry` /
- * `FormCollabBindingRegistry`):
- *   - `@pilotiq/tiptap`'s `registerTiptap(...)` calls `registerCollabTextRenderer(...)`
- *     once at boot. The registered component closes over `@tiptap/*` imports so
- *     pilotiq core stays free of any tiptap peer dep — same posture as the
- *     existing rich-text renderer registry.
- *   - `TextLikeInput` checks for the registered component when a `<RecordCollabRoom>`
- *     is mounted up-tree AND the field hasn't opted out via `.collab(false)` AND
- *     the field has no `.mask()`. If present, the legacy `BoundTextInput`
- *     (Y.Text + `computeDelta` + heuristic `preserveCursor`) is bypassed in
- *     favour of a y-prosemirror-backed Tiptap editor that anchors selections to
- *     `Yjs.RelativePosition` — the architectural fix for the cursor-jump and
- *     two-peer concurrent-insert races documented in
- *     `docs/plans/text-fields-tiptap-backed-collab.md`.
- *
- * Wire props are deliberately framework-agnostic — the renderer doesn't take a
- * `binding` since it consumes the room's `ydoc` directly via the existing
- * `useCollabRoom()` + `getCollabExtensions()` plumbing on its own side. Core
- * keeps the seam narrow: handler callbacks + DOM chrome only.
- */
-export interface CollabTextRendererProps {
-  /**
-   * Field name — drives the FormData hidden input AND the routing key
-   * for AI suggestion delivery (chip widget, applier registry). For
-   * Repeater / Builder row leaves this is the dotted positional path
-   * (`items.0.title`).
-   */
-  name: string
-  /**
-   * Collab-stable identifier for the `Y.XmlFragment` selector. When
-   * present, the renderer binds its collab fragment under this key
-   * instead of `name`. Row leaves pass a row-id-anchored composite
-   * (`items.<rowId>.title`) so the fragment survives reorders even
-   * as the dotted positional `name` shifts. Top-level fields omit
-   * it — `name` is stable on its own.
-   *
-   * AI suggestion routing continues to use `name` regardless. Tool
-   * calls reference fields by their positional FormData name, not
-   * the collab-stable composite.
-   */
-  fragmentKey?: string
-  /** `true` for textarea-like (multiple paragraphs); `false` for input-like. */
-  multiline: boolean
-  /**
-   * Server-rendered default value. The renderer is expected to seed the
-   * `Y.XmlFragment` from this on first connect when the room has no
-   * persisted state for this field (i.e. brand-new record).
-   */
-  defaultValue: string
-  /** Optional placeholder hint. */
-  placeholder?: string
-  /** Disabled / read-only state. */
-  disabled?: boolean
-  /** Fired on every editor `update` with the editor's current plain text. */
-  onChange: (text: string) => void
-  /** Fired on editor blur — host wires this to live-onBlur trigger semantics. */
-  onBlur: () => void
-  /**
-   * Single-line submit — fired when `multiline: false` AND the user presses
-   * Enter. The renderer is expected to blur the editor after invoking this.
-   * Multiline mode ignores it (Enter inserts a paragraph instead).
-   */
-  onSubmit?: () => void
-  /**
-   * Tailwind className applied to the editor's contenteditable wrapper so the
-   * rendered editor matches the native `<input>` / `<textarea>` chrome it
-   * replaces. The host owns the styling — the adapter just forwards.
-   */
-  className?: string
-  /**
-   * Additional DOM attributes for the editor's contenteditable wrapper —
-   * typically `id`, `aria-*`, `autocomplete`, etc.
-   */
-  editorAttributes?: Record<string, string>
-}
-
-export type CollabTextRenderer = ComponentType<CollabTextRendererProps>
-
-let _renderer: CollabTextRenderer | null = null
-
-/**
- * Register the collab plain-text editor component. Called once at boot by
- * `@pilotiq/tiptap`'s `registerTiptap()` (or directly by an app that imports
- * the renderer). Calling with `null` clears the registry — useful for tests.
- *
- * No-op behaviour when no renderer is registered: `TextLikeInput` falls back
- * to the legacy `BoundTextInput` path (or the plain controlled / uncontrolled
- * input when no collab room is mounted).
- */
-export function registerCollabTextRenderer(component: CollabTextRenderer | null): void {
-  _renderer = component
-}
-
-/** Returns the registered component, or `null` when no adapter is installed. */
-export function getCollabTextRenderer(): CollabTextRenderer | null {
-  return _renderer
-}

package/src/react/CommandPalette.tsx

@@ -1,375 +0,0 @@
-import * as React from 'react'
-import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react'
-import { SearchIcon, CornerDownLeftIcon, ArrowUpDownIcon } from 'lucide-react'
-
-import { Dialog, DialogContent } from './ui/dialog.js'
-import { useNavigate } from './navigate.js'
-import { useIconFor } from './icon-context.js'
-import { RenderHookSlot } from './RenderHookSlot.js'
-import type { GlobalSearchResult } from '../search.js'
-import type { NavItem } from '../pageData.js'
-import type { SerializedIcon } from '../icons/types.js'
-import type { RenderHookMap } from '../RenderHook.js'
-
-/**
- * Context exposing the palette's open setter. AppShell hosts the
- * provider; trigger pills (sidebar + topbar headers) call
- * `useCommandPaletteOpener()` to open the palette from anywhere in the
- * tree without prop-drilling.
- */
-const CommandPaletteContext = createContext<((open: boolean) => void) | null>(null)
-
-export function CommandPaletteProvider({
-  children,
-  setOpen,
-}: {
-  children: React.ReactNode
-  setOpen:  (open: boolean) => void
-}): React.ReactElement {
-  return (
-    <CommandPaletteContext.Provider value={setOpen}>
-      {children}
-    </CommandPaletteContext.Provider>
-  )
-}
-
-export function useCommandPaletteOpener(): (() => void) | null {
-  const setOpen = useContext(CommandPaletteContext)
-  return setOpen ? () => setOpen(true) : null
-}
-
-/**
- * Plan #12 — Cmd+K palette. Hand-rolled on the existing Dialog primitive
- * (no `cmdk` dep yet). Listens for Cmd/Ctrl+K globally; renders an input
- * + grouped result list; debounced fetch with in-flight cancellation
- * (same pattern as Plan #5 FormStateContext).
- *
- * Empty input shows the panel navigation entries — Cmd+K becomes a fast
- * resource picker. Typing replaces the list with search results grouped
- * by resource.
- */
-
-const DEBOUNCE_MS = 150
-const MIN_QUERY_LENGTH = 2
-
-interface SearchResponse {
-  ok:           boolean
-  results:      GlobalSearchResult[]
-  renderHooks?: RenderHookMap
-  error?:       string
-}
-
-export interface CommandPaletteProps {
-  basePath:    string
-  navigation?: NavItem[]
-  /** Controlled open state. AppShell hosts; the palette + the trigger
-   *  pill share via context. */
-  open:           boolean
-  onOpenChange:   (open: boolean) => void
-  /** Test seam — defaults to `globalThis.fetch`. */
-  fetchImpl?:  typeof fetch
-  /** Test seam — defaults to `useNavigate()`. */
-  navigateOverride?: (url: string) => void
-}
-
-interface PaletteEntry {
-  /** `'result'` rows are search hits; `'nav'` rows are nav-entry shortcuts. */
-  kind:     'result' | 'nav'
-  /** Group header label (resource label for results, group name for nav). */
-  group:    string
-  title:    string
-  subtitle?: string
-  url:      string
-  icon?:    SerializedIcon
-  /** Stable key for keyboard nav. */
-  key:      string
-}
-
-export function CommandPalette({
-  basePath,
-  navigation,
-  open,
-  onOpenChange,
-  fetchImpl,
-  navigateOverride,
-}: CommandPaletteProps): React.ReactElement {
-  const navigate = useNavigate()
-  const go = navigateOverride ?? navigate
-
-  const setOpen = onOpenChange
-  const [query, setQuery] = useState('')
-  const [results, setResults] = useState<GlobalSearchResult[]>([])
-  const [renderHooks, setRenderHooks] = useState<RenderHookMap | undefined>(undefined)
-  const [active, setActive] = useState(0)
-  const [loading, setLoading] = useState(false)
-
-  // ─── Cmd+K global listener ───────────────────────────
-  useEffect(() => {
-    function onKey(e: KeyboardEvent) {
-      const isCmdK = (e.metaKey || e.ctrlKey) && (e.key === 'k' || e.key === 'K')
-      if (!isCmdK) return
-      e.preventDefault()
-      setOpen(!open)
-    }
-    document.addEventListener('keydown', onKey)
-    return () => document.removeEventListener('keydown', onKey)
-  }, [open, setOpen])
-
-  // Reset query + active row whenever the palette closes.
-  useEffect(() => {
-    if (!open) {
-      setQuery('')
-      setResults([])
-      setRenderHooks(undefined)
-      setActive(0)
-    }
-  }, [open])
-
-  // ─── Fetch with debounce + in-flight seq ─────────────
-  // Mirrors Plan #5 FormStateContext: refs (not state) for the seq
-  // counters so React StrictMode dev double-invokes don't produce
-  // stale closures.
-  const requestSeqRef = useRef(0)
-  const latestSeenRef = useRef(0)
-  const debounceRef   = useRef<ReturnType<typeof setTimeout> | null>(null)
-
-  const runFetch = useCallback(async (q: string) => {
-    if (q.trim().length < MIN_QUERY_LENGTH) {
-      setResults([])
-      setRenderHooks(undefined)
-      setLoading(false)
-      return
-    }
-    const seq  = ++requestSeqRef.current
-    const doFetch = fetchImpl ?? fetch
-    setLoading(true)
-    try {
-      const url = `${basePath}/_search?q=${encodeURIComponent(q)}`
-      const res = await doFetch(url, {
-        method:  'GET',
-        headers: { 'Accept': 'application/json' },
-      })
-      if (seq < latestSeenRef.current) return
-      latestSeenRef.current = seq
-      if (!res.ok) {
-        setResults([])
-        setRenderHooks(undefined)
-        return
-      }
-      const data = await res.json().catch(() => null) as SearchResponse | null
-      if (!data?.ok) {
-        setResults([])
-        setRenderHooks(undefined)
-        return
-      }
-      setResults(data.results ?? [])
-      setRenderHooks(data.renderHooks)
-      setActive(0)
-    } catch {
-      setResults([])
-      setRenderHooks(undefined)
-    } finally {
-      // Only flip loading off when this is the latest in-flight.
-      if (seq === requestSeqRef.current) setLoading(false)
-    }
-  }, [basePath, fetchImpl])
-
-  // Debounce on query change.
-  useEffect(() => {
-    if (debounceRef.current) clearTimeout(debounceRef.current)
-    if (!open) return
-    debounceRef.current = setTimeout(() => {
-      void runFetch(query)
-    }, DEBOUNCE_MS)
-    return () => {
-      if (debounceRef.current) clearTimeout(debounceRef.current)
-    }
-  }, [query, open, runFetch])
-
-  // ─── Compose the entry list shown in the palette ─────
-  const entries = useMemo<PaletteEntry[]>(() => {
-    if (query.trim().length >= MIN_QUERY_LENGTH) {
-      return results.map((r, i) => {
-        const entry: PaletteEntry = {
-          kind:  'result',
-          group: r.resourceLabel,
-          title: r.title,
-          url:   r.url,
-          key:   `${r.resource}:${r.id}:${i}`,
-        }
-        if (r.subtitle !== undefined) entry.subtitle = r.subtitle
-        if (r.icon     !== undefined) entry.icon     = r.icon
-        return entry
-      })
-    }
-    // Empty-input state: flatten navigation tree.
-    return flattenNavigation(navigation ?? [])
-  }, [query, results, navigation])
-
-  // ─── Keyboard navigation ─────────────────────────────
-  const onKeyDown = useCallback((e: React.KeyboardEvent<HTMLInputElement>) => {
-    if (e.key === 'ArrowDown') {
-      e.preventDefault()
-      setActive((i) => Math.min(i + 1, Math.max(0, entries.length - 1)))
-    } else if (e.key === 'ArrowUp') {
-      e.preventDefault()
-      setActive((i) => Math.max(i - 1, 0))
-    } else if (e.key === 'Enter') {
-      e.preventDefault()
-      const entry = entries[active]
-      if (entry) {
-        setOpen(false)
-        // Defer the navigate so the close transition fires first.
-        Promise.resolve().then(() => go(entry.url))
-      }
-    } else if (e.key === 'Escape') {
-      setOpen(false)
-    }
-  }, [entries, active, go])
-
-  // Hooks render only when the user is actively searching (>= MIN_QUERY_LENGTH);
-  // empty-input nav state stays clean — chrome / nav slots cover that elsewhere.
-  const showHooks = query.trim().length >= MIN_QUERY_LENGTH
-
-  // ─── Group entries for rendering ─────────────────────
-  const grouped = useMemo(() => {
-    const map = new Map<string, PaletteEntry[]>()
-    for (const e of entries) {
-      const arr = map.get(e.group) ?? []
-      arr.push(e)
-      map.set(e.group, arr)
-    }
-    return [...map.entries()]
-  }, [entries])
-
-  return (
-    <Dialog open={open} onOpenChange={setOpen}>
-      <DialogContent className="max-w-xl p-0 gap-0 overflow-hidden">
-        <div className="flex items-center gap-2 border-b border-border px-4 py-3">
-          <SearchIcon className="size-4 text-muted-foreground" aria-hidden="true" />
-          <input
-            type="text"
-            autoFocus
-            placeholder="Search resources, records, or pages…"
-            value={query}
-            onChange={(e) => setQuery(e.target.value)}
-            onKeyDown={onKeyDown}
-            className="flex-1 bg-transparent text-sm outline-none placeholder:text-muted-foreground"
-            aria-label="Search"
-          />
-          {loading && <span className="text-xs text-muted-foreground">…</span>}
-          <kbd className="text-[10px] font-mono text-muted-foreground border border-border rounded px-1 py-0.5">esc</kbd>
-        </div>
-
-        <div className="max-h-96 overflow-y-auto py-1">
-          {showHooks && renderHooks?.['panels::global-search.results.before'] && (
-            <div className="px-4 py-2">
-              <RenderHookSlot name="panels::global-search.results.before" hooks={renderHooks} />
-            </div>
-          )}
-          {entries.length === 0 && (
-            <p className="px-4 py-6 text-center text-sm text-muted-foreground">
-              {query.trim().length < MIN_QUERY_LENGTH
-                ? 'Type to search…'
-                : loading
-                  ? 'Searching…'
-                  : 'No results.'}
-            </p>
-          )}
-          {grouped.map(([group, rows]) => (
-            <div key={group}>
-              <div className="px-4 pt-3 pb-1 text-[10px] font-semibold uppercase tracking-wide text-muted-foreground">
-                {group}
-              </div>
-              <ul role="listbox">
-                {rows.map((entry) => {
-                  const flatIdx = entries.indexOf(entry)
-                  const isActive = flatIdx === active
-                  return (
-                    <li key={entry.key}>
-                      <button
-                        type="button"
-                        role="option"
-                        aria-selected={isActive}
-                        onMouseEnter={() => setActive(flatIdx)}
-                        onClick={() => {
-                          setOpen(false)
-                          Promise.resolve().then(() => go(entry.url))
-                        }}
-                        className={[
-                          'flex w-full items-center gap-3 px-4 py-2 text-left text-sm transition',
-                          isActive ? 'bg-accent text-accent-foreground' : 'hover:bg-muted',
-                        ].join(' ')}
-                      >
-                        <PaletteIcon icon={entry.icon} />
-                        <div className="min-w-0 flex-1">
-                          <div className="truncate font-medium">{entry.title}</div>
-                          {entry.subtitle && (
-                            <div className="truncate text-xs text-muted-foreground">{entry.subtitle}</div>
-                          )}
-                        </div>
-                        {isActive && (
-                          <CornerDownLeftIcon className="size-3 text-muted-foreground" aria-hidden="true" />
-                        )}
-                      </button>
-                    </li>
-                  )
-                })}
-              </ul>
-            </div>
-          ))}
-          {showHooks && renderHooks?.['panels::global-search.results.after'] && (
-            <div className="px-4 py-2">
-              <RenderHookSlot name="panels::global-search.results.after" hooks={renderHooks} />
-            </div>
-          )}
-        </div>
-
-        <div className="flex items-center justify-between border-t border-border px-4 py-2 text-[10px] text-muted-foreground">
-          <span className="flex items-center gap-1">
-            <ArrowUpDownIcon className="size-3" aria-hidden="true" />
-            navigate
-          </span>
-          <span className="flex items-center gap-1">
-            <CornerDownLeftIcon className="size-3" aria-hidden="true" />
-            open
-          </span>
-        </div>
-      </DialogContent>
-    </Dialog>
-  )
-}
-
-function PaletteIcon({ icon }: { icon: SerializedIcon | undefined }) {
-  const Icon = useIconFor(icon)
-  if (!Icon) {
-    return <span className="size-4 rounded bg-muted" aria-hidden="true" />
-  }
-  return <Icon className="size-4 text-muted-foreground" aria-hidden="true" />
-}
-
-/**
- * Flatten the navigation tree (nested children) into a single PaletteEntry
- * list. Used for the empty-input quick-nav state. Group label is the
- * NavItem's `group` (or `'Navigation'` when unset).
- */
-function flattenNavigation(items: NavItem[]): PaletteEntry[] {
-  const out: PaletteEntry[] = []
-  const walk = (nodes: NavItem[], inheritedGroup?: string) => {
-    for (const n of nodes) {
-      const group = n.group ?? inheritedGroup ?? 'Navigation'
-      const entry: PaletteEntry = {
-        kind:  'nav',
-        group,
-        title: n.label,
-        url:   n.url,
-        key:   `nav:${n.name}:${n.url}`,
-      }
-      if (n.icon !== undefined) entry.icon = n.icon
-      out.push(entry)
-      if (n.children && n.children.length > 0) walk(n.children, group)
-    }
-  }
-  walk(items)
-  return out
-}

package/src/react/CurrentUserContext.tsx

@@ -1,50 +0,0 @@
-import { createContext, useContext, type ReactNode } from 'react'
-
-/**
- * Resolved identity of the user driving the current page. Mirrors the
- * `UserMenuMeta.user` shape that `panelInfo()` ships to the renderer —
- * whichever fields the `Pilotiq.user(req => …)` resolver populated.
- *
- * `null` is the no-user state: either the panel never wired a resolver,
- * or the resolver returned `null` for this request. Consumers should
- * gracefully fall back (no avatar, no presence label, etc.) rather than
- * treating absence as an error.
- */
-export interface CurrentUser {
-  name?:   string
-  email?:  string
-  avatar?: string
-}
-
-const CurrentUserContext = createContext<CurrentUser | null>(null)
-
-/**
- * Mounted by `AppShell` around the layout-provider chain so plugins
- * (collab user presence, audit-trail attribution, analytics
- * client-side opt-outs, …) can read the active user via
- * `useCurrentUser()` without prop-drilling through `panel`.
- *
- * Value source is `viewProps.panel.userMenu?.user` — the same shape the
- * top-right dropdown renders. The provider sits OUTSIDE
- * `layoutProviderRegistry` so plugin-registered layout providers can
- * subscribe.
- */
-export function CurrentUserProvider({
-  value,
-  children,
-}: {
-  value: CurrentUser | null
-  children: ReactNode
-}): ReactNode {
-  return <CurrentUserContext.Provider value={value}>{children}</CurrentUserContext.Provider>
-}
-
-/**
- * Read the active user inside any descendant of `<AppShell>`. Returns
- * `null` outside an `AppShell` mount (defensive — keeps storybook /
- * isolated-render tests from throwing) and when no user resolved for
- * the request.
- */
-export function useCurrentUser(): CurrentUser | null {
-  return useContext(CurrentUserContext)
-}