@pilotiq/pilotiq 0.24.1 → 0.24.2

package/src/react/NotificationBell.tsx

@@ -1,426 +0,0 @@
-'use client'
-
-import React from 'react'
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuTrigger,
-} from './ui/dropdown-menu.js'
-import { useNavigate } from './navigate.js'
-import { useIconFor } from './icon-context.js'
-import { cn } from './utils.js'
-import type { DatabaseNotificationsMeta } from '../pageData.js'
-import type { DatabaseNotificationMeta } from '../notifications/database.js'
-import type { NavigationBadgeColor } from '../Resource.js'
-import type { NotificationMeta as NotificationMetaImport } from '../notifications/Notification.js'
-import { NotificationActionStrip } from './NotificationActionStrip.js'
-import { useToast } from './Toaster.js'
-
-const BADGE_COLOR: Record<NavigationBadgeColor, string> = {
-  default:     'bg-muted text-muted-foreground',
-  primary:     'bg-primary text-primary-foreground',
-  success:     'bg-emerald-500 text-white',
-  warning:     'bg-amber-500   text-white',
-  destructive: 'bg-red-500     text-white',
-  info:        'bg-sky-500     text-white',
-}
-
-const TYPE_DOT: Record<NonNullable<DatabaseNotificationMeta['type']>, string> = {
-  info:    'bg-sky-500',
-  success: 'bg-emerald-500',
-  warning: 'bg-amber-500',
-  error:   'bg-red-500',
-}
-
-/**
- * Bell-icon dropdown for `Pilotiq.databaseNotifications()`. Renders
- * nothing when `meta` is absent — `panelInfo()` only ships the meta
- * when the panel opted in AND a user resolved.
- *
- * Lifecycle:
- *   - First mount: fetch the current list via `meta.listUrl`.
- *   - Polling: when `meta.polling > 0`, refetch every N seconds.
- *     Pauses while `document.visibilityState !== 'visible'` so a
- *     backgrounded tab doesn't keep tickling the server.
- *   - Mark-read: optimistic — flips `readAt` immediately, refetches
- *     after the POST so the unread count rebases against the server.
- *   - Click-through: when a row carries a `url`, the click marks-read
- *     + SPA-navigates in the same step.
- */
-export function NotificationBell({ meta }: { meta?: DatabaseNotificationsMeta }) {
-  if (!meta) return null
-  const navigate = useNavigate()
-
-  const [open, setOpen] = React.useState(false)
-  const [data, setData] = React.useState<{
-    notifications: DatabaseNotificationMeta[]
-    unreadCount:   number
-  } | null>(null)
-  const [loading, setLoading] = React.useState(false)
-
-  // ── Fetch helpers ─────────────────────────────────────
-  // Latest-wins seq tracking — same pattern as the global-search
-  // palette / live-form state. A slow first request can't clobber a
-  // fresh second one.
-  const seqRef     = React.useRef(0)
-  const latestRef  = React.useRef(0)
-  const refetch = React.useCallback(async () => {
-    const seq = ++seqRef.current
-    setLoading(true)
-    try {
-      const r = await fetch(meta.listUrl, {
-        headers: { Accept: 'application/json' },
-        credentials: 'same-origin',
-      })
-      if (!r.ok) return
-      const json = await r.json() as {
-        notifications?: DatabaseNotificationMeta[]
-        unreadCount?:   number
-      }
-      if (seq < latestRef.current) return
-      latestRef.current = seq
-      setData({
-        notifications: json.notifications ?? [],
-        unreadCount:   json.unreadCount   ?? 0,
-      })
-    } catch { /* network-flake; the next poll retries */ }
-    finally {
-      if (seq >= latestRef.current) setLoading(false)
-    }
-  }, [meta.listUrl])
-
-  // ── First mount + polling ────────────────────────────
-  React.useEffect(() => {
-    void refetch()
-  }, [refetch])
-
-  React.useEffect(() => {
-    if (meta.polling === null || meta.polling === 0) return
-    const ms = meta.polling * 1000
-    const tick = () => {
-      if (typeof document !== 'undefined' && document.visibilityState !== 'visible') return
-      void refetch()
-    }
-    const id = window.setInterval(tick, ms)
-    return () => window.clearInterval(id)
-  }, [meta.polling, refetch])
-
-  // ── Phase 2 broadcast subscription ───────────────────
-  // When `meta.broadcast` is present, connect to the panel's WebSocket
-  // and listen for `notification.created` on the user's private channel.
-  // Triggers the same `refetch()` already wired for polling — broadcast
-  // is "low-latency refetch hint", not a payload-pushing transport.
-  //
-  // RudderSocket loads via dynamic import so the bell doesn't bundle
-  // broadcast for apps that don't enable it. Failures (package missing,
-  // wsUrl unreachable, auth rejected) silently fall back to polling.
-  React.useEffect(() => {
-    if (!meta.broadcast) return
-    if (typeof window === 'undefined') return
-    let cancelled = false
-    let socket:   { disconnect(): void } | null = null
-
-    const wsUrl = meta.broadcast.wsUrl || sameOriginWsUrl()
-    const channelName = meta.broadcast.channel
-    const eventName   = meta.broadcast.event
-
-    void (async () => {
-      try {
-        const RudderSocket = await loadRudderSocket()
-        if (!RudderSocket || cancelled) return
-        const s = new RudderSocket(wsUrl)
-        socket = s
-        // Strip the `private-` prefix — `RudderSocket.private(name)`
-        // re-adds it. We pass an empty token because the auth callback
-        // we registered server-side reads the upgrade request's cookies,
-        // not a per-message bearer token.
-        const bareName = channelName.replace(/^private-/, '')
-        s.private(bareName, '').on(eventName, () => {
-          if (cancelled) return
-          void refetch()
-        })
-      } catch { /* package not vendored / connect failed — polling covers it */ }
-    })()
-
-    return () => {
-      cancelled = true
-      socket?.disconnect()
-    }
-  }, [meta.broadcast?.wsUrl, meta.broadcast?.channel, meta.broadcast?.event, refetch])
-
-  // ── Mutations ────────────────────────────────────────
-  const markRead = React.useCallback(async (id: string) => {
-    // Optimistic flip — the bell stays responsive even on slow networks.
-    setData(prev => prev && {
-      notifications: prev.notifications.map(n =>
-        n.id === id ? { ...n, readAt: n.readAt ?? new Date().toISOString() } : n,
-      ),
-      unreadCount: Math.max(0, prev.unreadCount - 1),
-    })
-    try {
-      await fetch(meta.readUrl.replace(':id', encodeURIComponent(id)), {
-        method:  'POST',
-        headers: { Accept: 'application/json' },
-        credentials: 'same-origin',
-      })
-    } catch { /* swallow — next poll resyncs */ }
-    void refetch()
-  }, [meta.readUrl, refetch])
-
-  const markAllRead = React.useCallback(async () => {
-    setData(prev => prev && {
-      notifications: prev.notifications.map(n =>
-        n.readAt ? n : { ...n, readAt: new Date().toISOString() }),
-      unreadCount: 0,
-    })
-    try {
-      await fetch(meta.readAllUrl, {
-        method:  'POST',
-        headers: { Accept: 'application/json' },
-        credentials: 'same-origin',
-      })
-    } catch { /* swallow */ }
-    void refetch()
-  }, [meta.readAllUrl, refetch])
-
-  const unreadCount = data?.unreadCount ?? 0
-  const items       = data?.notifications ?? []
-  const toast       = useToast()
-
-  return (
-    <DropdownMenu open={open} onOpenChange={setOpen}>
-      <DropdownMenuTrigger
-        className="relative inline-flex items-center justify-center size-9 rounded-md hover:bg-accent hover:text-accent-foreground transition-colors focus:outline-none"
-        aria-label={meta.trigger?.label ?? 'Notifications'}
-      >
-        <BellIcon icon={meta.trigger?.icon} />
-        {unreadCount > 0 && (
-          <span
-            className={cn(
-              'absolute -top-0.5 -end-0.5 inline-flex min-w-[1rem] h-4 items-center justify-center rounded-full px-1 text-[10px] font-semibold leading-none',
-              BADGE_COLOR[meta.badgeColor],
-            )}
-            aria-label={`${unreadCount} unread`}
-          >
-            {unreadCount > 99 ? '99+' : unreadCount}
-          </span>
-        )}
-      </DropdownMenuTrigger>
-
-      <DropdownMenuContent align="end" className="w-80 p-0">
-        <header className="flex items-center justify-between px-3 py-2 border-b">
-          <span className="text-sm font-medium">Notifications</span>
-          {unreadCount > 0 && (
-            <button
-              type="button"
-              className="text-xs text-muted-foreground hover:text-foreground transition-colors"
-              onClick={() => { void markAllRead() }}
-            >
-              Mark all as read
-            </button>
-          )}
-        </header>
-
-        <div className="max-h-96 overflow-y-auto">
-          {items.length === 0
-            ? <EmptyState loading={loading} />
-            : items.map(n => (
-                <NotificationRow
-                  key={n.id}
-                  notification={n}
-                  actionUrlTemplate={meta.actionUrl}
-                  onMarkRead={markRead}
-                  onNavigate={(href) => { setOpen(false); navigate(href) }}
-                  onNotify={(notifs) => notifs.forEach(t => toast.notify(t))}
-                  onAfterClick={() => setOpen(false)}
-                />
-              ))
-          }
-        </div>
-      </DropdownMenuContent>
-    </DropdownMenu>
-  )
-}
-
-function NotificationRow({
-  notification: n,
-  actionUrlTemplate,
-  onMarkRead,
-  onNavigate,
-  onNotify,
-  onAfterClick,
-}: {
-  notification:       DatabaseNotificationMeta
-  actionUrlTemplate?: string
-  onMarkRead:         (id: string) => void
-  onNavigate:         (url: string) => void
-  onNotify:           (notifs: NotificationMetaImport[]) => void
-  onAfterClick:       () => void
-}) {
-  const RowIcon = useIconFor(n.icon)
-  const unread  = !n.readAt
-
-  const onClick = (e: React.MouseEvent) => {
-    // Modified clicks (cmd/ctrl/middle) preserve native semantics.
-    if (e.defaultPrevented || e.metaKey || e.ctrlKey || e.shiftKey) return
-    e.preventDefault()
-    if (unread) onMarkRead(n.id)
-    if (n.url) onNavigate(n.url)
-  }
-
-  // Body wrapper is `<a>` when the row has a click-through url, plain
-  // `<button>` otherwise. Form-mode + handler-mode action buttons in
-  // the strip can't validly nest inside an `<a>`/`<button>`, so the
-  // strip lives as a sibling under a shared chrome `<div>`.
-  const Tag: 'a' | 'button' = n.url ? 'a' : 'button'
-  const tagProps: React.AnchorHTMLAttributes<HTMLAnchorElement> & React.ButtonHTMLAttributes<HTMLButtonElement> = {
-    onClick,
-    className: 'w-full text-start flex items-start gap-2 focus:outline-none',
-  }
-  if (Tag === 'a') {
-    tagProps.href = n.url!
-  } else {
-    tagProps.type = 'button'
-  }
-
-  return (
-    <div
-      className={cn(
-        'px-3 py-2 hover:bg-accent transition-colors border-b last:border-b-0',
-        unread && 'bg-primary/5',
-      )}
-    >
-      <Tag {...(tagProps as React.HTMLAttributes<HTMLElement>)}>
-        <span
-          className={cn(
-            'mt-1.5 inline-block size-2 rounded-full shrink-0',
-            n.type ? TYPE_DOT[n.type] : 'bg-muted-foreground/40',
-          )}
-          aria-hidden="true"
-        />
-        <span className="flex-1 min-w-0">
-          <span className="flex items-center gap-1.5">
-            {RowIcon && <RowIcon className="size-3.5 text-muted-foreground" aria-hidden="true" />}
-            <span className={cn('text-sm leading-tight', unread ? 'font-medium' : '')}>
-              {n.title || 'Notification'}
-            </span>
-          </span>
-          {n.body && (
-            <span className="block text-xs text-muted-foreground mt-0.5 line-clamp-2">
-              {n.body}
-            </span>
-          )}
-          <span className="block text-[11px] text-muted-foreground/70 mt-1">
-            {formatRelative(n.createdAt)}
-          </span>
-        </span>
-      </Tag>
-      {n.actions && n.actions.length > 0 && (
-        <div className="ms-4">
-          <NotificationActionStrip
-            actions={n.actions}
-            {...(actionUrlTemplate !== undefined ? { actionUrlTemplate } : {})}
-            notificationId={n.id}
-            onMarkAsRead={onMarkRead}
-            onNotify={onNotify}
-            onAfterClick={onAfterClick}
-          />
-        </div>
-      )}
-    </div>
-  )
-}
-
-function EmptyState({ loading }: { loading: boolean }) {
-  return (
-    <div className="px-3 py-8 text-center text-sm text-muted-foreground">
-      {loading ? 'Loading…' : 'No notifications'}
-    </div>
-  )
-}
-
-function BellIcon({ icon }: { icon: string | undefined }) {
-  // Honor `meta.trigger.icon` when set (string registry name); fall
-  // through to the bundled bell glyph otherwise. The registry-resolved
-  // hook returns `null` when no entry is registered, so a misspelt name
-  // still shows the default bell — better than a silent blank.
-  const Icon = useIconFor(icon)
-  if (Icon) return <Icon className="size-5" aria-hidden="true" />
-  return (
-    <svg
-      xmlns="http://www.w3.org/2000/svg"
-      width="20" height="20" viewBox="0 0 24 24" fill="none"
-      stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"
-      aria-hidden="true"
-    >
-      <path d="M6 8a6 6 0 0 1 12 0c0 7 3 9 3 9H3s3-2 3-9" />
-      <path d="M10.3 21a1.94 1.94 0 0 0 3.4 0" />
-    </svg>
-  )
-}
-
-/** Soft-load `RudderSocket` from whichever path the consuming app
- *  vendored it to. `@rudderjs/broadcast` ships the client as
- *  `client/RudderSocket.ts`, intended for vendor:publish copy into the
- *  app's `src/`. We try a stack of common locations in order, returning
- *  the first that resolves; falls through to `null` when nothing's
- *  reachable so the bell silently continues with polling.
- *
- *  Apps that vendor the file under a custom path can register their
- *  own loader by setting `window.__pilotiqRudderSocket` to the class
- *  constructor before the bell mounts. */
-type RudderSocketCtor = new (url: string) => {
-  private(name: string, token: string): {
-    on(event: string, handler: (data: unknown) => void): unknown
-  }
-  disconnect(): void
-}
-
-async function loadRudderSocket(): Promise<RudderSocketCtor | null> {
-  // Allow apps to register a custom-path RudderSocket without us
-  // having to guess at the import path.
-  const w = typeof window !== 'undefined'
-    ? (window as unknown as { __pilotiqRudderSocket?: RudderSocketCtor })
-    : null
-  if (w?.__pilotiqRudderSocket) return w.__pilotiqRudderSocket
-
-  // Apps that vendor:publish the broadcast client typically end up
-  // with `src/RudderSocket.ts` (or `.js`); try common shapes via the
-  // app's import-map / module resolution. The dynamic import is
-  // wrapped in a try/catch so missing modules don't surface.
-  const candidates = [
-    '@rudderjs/broadcast/client/RudderSocket.js',
-    '@rudderjs/broadcast/client/RudderSocket',
-  ]
-  for (const id of candidates) {
-    try {
-      const mod = await import(/* @vite-ignore */ id) as { RudderSocket?: RudderSocketCtor }
-      if (mod.RudderSocket) return mod.RudderSocket
-    } catch { /* try next */ }
-  }
-  return null
-}
-
-/** Same-origin `ws://…/ws` (or `wss://` on https). Used when
- *  `meta.broadcast.wsUrl` is empty — the default for apps that boot
- *  `BroadcastingProvider` with no custom path. */
-function sameOriginWsUrl(): string {
-  if (typeof window === 'undefined') return ''
-  const proto = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
-  return `${proto}//${window.location.host}/ws`
-}
-
-function formatRelative(ts: number): string {
-  const now = Date.now()
-  const diff = Math.max(0, now - ts)
-  const sec  = Math.floor(diff / 1000)
-  if (sec < 45)         return 'Just now'
-  if (sec < 90)         return '1 minute ago'
-  const min = Math.floor(sec / 60)
-  if (min < 60)         return `${min} minutes ago`
-  const hr  = Math.floor(min / 60)
-  if (hr  < 24)         return `${hr} hour${hr === 1 ? '' : 's'} ago`
-  const day = Math.floor(hr / 24)
-  if (day < 7)          return `${day} day${day === 1 ? '' : 's'} ago`
-  return new Date(ts).toLocaleDateString()
-}

package/src/react/PendingSuggestionApplierRegistry.test.ts

@@ -1,97 +0,0 @@
-import { describe, it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  registerPendingSuggestionApplier,
-  getPendingSuggestionApplier,
-  _clearAppliersForTests,
-} from './PendingSuggestionApplierRegistry.js'
-
-describe('PendingSuggestionApplierRegistry', () => {
-  beforeEach(() => { _clearAppliersForTests() })
-
-  it('returns the scoped applier when both formId and fieldName match', () => {
-    const apply = (): void => {}
-    registerPendingSuggestionApplier('form-1', 'bio', apply)
-    assert.equal(getPendingSuggestionApplier('form-1', 'bio'), apply)
-  })
-
-  it('routes scoped lookups to the matching scoped entry across multi-form pages', () => {
-    // Two editors in two forms register under the same field name but
-    // different formIds — the routing has to disambiguate.
-    const applyA = (): void => {}
-    const applyB = (): void => {}
-    registerPendingSuggestionApplier('form-A', 'summary', applyA)
-    registerPendingSuggestionApplier('form-B', 'summary', applyB)
-    assert.equal(getPendingSuggestionApplier('form-A', 'summary'), applyA)
-    assert.equal(getPendingSuggestionApplier('form-B', 'summary'), applyB)
-  })
-
-  it('falls through to the wildcard slot when no scoped match exists', () => {
-    const wild = (): void => {}
-    registerPendingSuggestionApplier(undefined, 'bio', wild)
-    // formId provided but the registry only has a wildcard entry —
-    // the lookup should still resolve so historic single-form pages keep
-    // working even when consumers thread a formId.
-    assert.equal(getPendingSuggestionApplier('form-1', 'bio'), wild)
-  })
-
-  it('global producer + scoped consumer: undefined-formId lookup finds the scoped entry', () => {
-    // Regression guard for the multi-form fix: after threading `formId`
-    // through the Tiptap adapter hooks, every editor registers scoped
-    // by its surrounding `FormRenderer`'s id. A global producer (no
-    // `formId` stamped on the suggestion) calls
-    // `getPendingSuggestionApplier(undefined, fieldName)` — without the
-    // fallback, the wildcard slot is empty and the suggestion silently
-    // never applies. The fallback returns any matching scoped entry.
-    const scopedApply = (): void => {}
-    registerPendingSuggestionApplier('form-edit', 'bio', scopedApply)
-    assert.equal(getPendingSuggestionApplier(undefined, 'bio'), scopedApply)
-  })
-
-  it('global lookup prefers the explicit wildcard slot over scoped fallback', () => {
-    const wild = (): void => {}
-    const scoped = (): void => {}
-    registerPendingSuggestionApplier('form-edit', 'bio', scoped)
-    registerPendingSuggestionApplier(undefined,    'bio', wild)
-    // Wildcard wins — it was the intent of the original API ("formId
-    // defaults to '*'") and a deliberately-registered wildcard applier
-    // is presumed authoritative.
-    assert.equal(getPendingSuggestionApplier(undefined, 'bio'), wild)
-  })
-
-  it('scoped lookup prefers exact match over wildcard slot', () => {
-    const wild = (): void => {}
-    const scoped = (): void => {}
-    registerPendingSuggestionApplier(undefined,   'bio', wild)
-    registerPendingSuggestionApplier('form-edit', 'bio', scoped)
-    assert.equal(getPendingSuggestionApplier('form-edit', 'bio'), scoped)
-  })
-
-  it('returns undefined when no entry matches the fieldName at all', () => {
-    registerPendingSuggestionApplier('form-A', 'bio', () => {})
-    assert.equal(getPendingSuggestionApplier('form-A', 'subtitle'), undefined)
-    assert.equal(getPendingSuggestionApplier(undefined, 'subtitle'), undefined)
-  })
-
-  it('unregister cleanup drops the entry', () => {
-    const apply = (): void => {}
-    const unregister = registerPendingSuggestionApplier('form-1', 'bio', apply)
-    assert.equal(getPendingSuggestionApplier('form-1', 'bio'), apply)
-    unregister()
-    assert.equal(getPendingSuggestionApplier('form-1', 'bio'), undefined)
-  })
-
-  it('re-registering replaces the previous entry and its unregister no-ops', () => {
-    const first  = (): void => {}
-    const second = (): void => {}
-    const off1 = registerPendingSuggestionApplier('form-1', 'bio', first)
-    registerPendingSuggestionApplier('form-1', 'bio', second) // wins
-    assert.equal(getPendingSuggestionApplier('form-1', 'bio'), second)
-    // First's unregister must NOT delete the second's entry — the
-    // registry tracks identity to defend against unmount-after-remount
-    // racing the cleanup of the just-replaced entry.
-    off1()
-    assert.equal(getPendingSuggestionApplier('form-1', 'bio'), second)
-  })
-})

package/src/react/PendingSuggestionApplierRegistry.ts

@@ -1,98 +0,0 @@
-import type { PendingSuggestion } from './PendingSuggestionsContext.js'
-
-/**
- * A function that applies a `PendingSuggestion` to its target field —
- * registered by the field renderer (or editor adapter) on mount, looked
- * up by aggregate consumers (e.g. a chat-sidebar pending-pill's
- * "Approve all" button) that live outside the form's React tree.
- *
- * The applier is responsible for the apply *only*. Dismissing the
- * suggestion from the queue is the caller's job — the apply path is
- * decoupled from the queue-side bookkeeping so a future Phase that
- * mirrors approvals to a server can do both via different code paths.
- */
-export type PendingSuggestionApplier = (suggestion: PendingSuggestion) => void
-
-interface RegistryEntry {
-  formId:    string | undefined
-  fieldName: string
-  apply:     PendingSuggestionApplier
-}
-
-const _entries = new Map<string, RegistryEntry>()
-
-/**
- * Compose the registry key. `formId` defaults to `'*'` (global form
- * scope) so renderers in non-multi-form pages don't have to thread an
- * id. Form-scoped registrations always win over the wildcard when both
- * exist for the same field name.
- */
-function keyFor(formId: string | undefined, fieldName: string): string {
-  return `${formId ?? '*'}::${fieldName}`
-}
-
-/**
- * Register an applier for `(formId, fieldName)`. Returns an unregister
- * function for `useEffect` cleanup. Re-registering with the same key
- * replaces the previous entry — the most recently mounted renderer
- * wins (typical in multi-instance form scenarios where an old form
- * unmounts after a new one mounts during navigation).
- */
-export function registerPendingSuggestionApplier(
-  formId:    string | undefined,
-  fieldName: string,
-  apply:     PendingSuggestionApplier,
-): () => void {
-  const key = keyFor(formId, fieldName)
-  const entry: RegistryEntry = { formId, fieldName, apply }
-  _entries.set(key, entry)
-  return () => {
-    // Only delete if this entry is still the one we registered — a
-    // re-register from another instance may have replaced us.
-    if (_entries.get(key) === entry) _entries.delete(key)
-  }
-}
-
-/**
- * Look up an applier for `(formId, fieldName)`. Tries the form-scoped
- * key first; falls back to the wildcard form ('*') so a producer that
- * pushed a suggestion without `formId` still resolves an applier from
- * a single-form page.
- *
- * Global-producer fallback: when the lookup `formId` is `undefined` AND
- * no wildcard entry is registered, return any single scoped entry
- * matching `fieldName`. This mirrors the consumer-side filter in
- * `usePendingSuggestionsForField` which lets undefined formId on either
- * side pass-through. Editors today register scoped by their surrounding
- * `FormRenderer`'s id (`useFormId()`), so the wildcard slot is almost
- * always empty — without this fallback, a producer that pushes without
- * a formId on a single-form page would silently fail to resolve any
- * applier. We pick the first scoped match (Map insertion order); when
- * the page genuinely has multiple forms with the same field name,
- * producers SHOULD stamp `formId` to disambiguate.
- */
-export function getPendingSuggestionApplier(
-  formId:    string | undefined,
-  fieldName: string,
-): PendingSuggestionApplier | undefined {
-  if (formId !== undefined) {
-    const scoped = _entries.get(keyFor(formId, fieldName))
-    if (scoped) return scoped.apply
-  }
-  const wild = _entries.get(keyFor(undefined, fieldName))
-  if (wild) return wild.apply
-  if (formId === undefined) {
-    for (const entry of _entries.values()) {
-      if (entry.fieldName === fieldName) return entry.apply
-    }
-  }
-  return undefined
-}
-
-/**
- * Test seam — clear the registry between tests. Not part of the public
- * API.
- */
-export function _clearAppliersForTests(): void {
-  _entries.clear()
-}

package/src/react/PendingSuggestionOverlayRegistry.ts

@@ -1,54 +0,0 @@
-import type { ComponentType } from 'react'
-import type { PendingSuggestion } from './PendingSuggestionsContext.js'
-import type { ElementMeta } from '../schema/Element.js'
-
-/**
- * Props the per-field overlay component receives from `FieldShell` when
- * one or more pending suggestions target the field.
- *
- * The overlay is responsible for both rendering AND applying the
- * suggestion. On Approve, call `onApprove()` (which dismisses the
- * suggestion from the queue) AFTER mutating the form's field value to
- * `suggestion.suggestedValue` — the queue is just a notification surface,
- * applying is the renderer's job.
- *
- * The Tiptap `RichTextField` renderer skips this slot entirely — it
- * mirrors suggestions into the editor's inline AiSuggestion extension
- * instead. Other field types (Text / Textarea / Select / Number / …)
- * render the registered overlay below their input.
- */
-export interface PendingSuggestionOverlayProps {
-  /** First suggestion targeting this field. Aggregate UIs handle stacks. */
-  suggestion: PendingSuggestion
-  /** Drop from queue (callable after applying). */
-  onApprove:  () => void
-  /** Drop from queue without applying. */
-  onReject:   () => void
-  /** Field type string (`text` / `select` / `toggle` / `slider` / `color` /
-   *  …) so per-fieldType overlay renderers can branch. Sparse — older
-   *  hosts may omit. Phase C of ai-review-mode. */
-  fieldType?: string
-  /** Resolved field meta — gives the overlay access to per-field config
-   *  (`options` for Select, `min/max` for Slider, etc.) needed to render
-   *  human-friendly comparisons rather than raw values. Sparse — older
-   *  hosts may omit. */
-  el?:        ElementMeta
-}
-
-let _component: ComponentType<PendingSuggestionOverlayProps> | null = null
-
-/**
- * Register a component to render below any `FieldShell` whose field has at
- * least one matching pending suggestion in the
- * `<PendingSuggestionsContext>` queue. Called once at boot by a plugin
- * (e.g. `@pilotiq-pro/ai`). No-op when no plugin registers — `FieldShell`
- * skips the overlay slot.
- */
-export function registerPendingSuggestionOverlay(C: ComponentType<PendingSuggestionOverlayProps>): void {
-  _component = C
-}
-
-/** Returns the registered overlay component, or `null`. */
-export function getPendingSuggestionOverlay(): ComponentType<PendingSuggestionOverlayProps> | null {
-  return _component
-}