@burdenoff/microfe-vibecontrols 2026.1008.2 → 2026.1010.2

package/dist/hooks/useActiveAgentProfile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useActiveAgentProfile.js","names":[],"sources":["../../src/hooks/useActiveAgentProfile.ts"],"sourcesContent":["/**\n * useActiveAgentProfile — Phase 5B (multi-profile-per-daemon).\n *\n * Lists `AgentProfile` rows for an agent and tracks the currently-active\n * profile name in the VibeControls Zustand store (`activeProfilePerAgent`).\n *\n * Active-selection rules:\n *   1. If the user has explicitly selected a profile for this agent, use it.\n *   2. Otherwise, fall back to the profile flagged `isDefault`.\n *   3. Otherwise, fall back to the first profile in the list.\n *   4. Otherwise, fall back to the literal string \"default\" so callers can\n *      build canonical paths even before any AgentProfile rows exist\n *      (server-side compatibility shim).\n *\n * NOTE: The Apollo `gql` document is inlined here (not generated) so this\n * hook compiles cleanly even before the Phase 5A svc work has published\n * the AgentProfile schema to Hive. Once published, the inline document\n * can be replaced with the generated `useVibecontrolsAgentProfilesQuery`\n * hook without touching callsites.\n */\n\nimport { useEffect, useMemo } from 'react';\nimport { gql } from '@apollo/client';\nimport { useQuery } from '@apollo/client/react';\nimport { useVibeControlsStore } from '@/store/vibeControlsStore';\n\nexport interface AgentProfile {\n  id: string;\n  agentId: string;\n  name: string;\n  isDefault: boolean;\n  port: number | null;\n  status: string | null;\n  tunnelUrl: string | null;\n  createdAt: string;\n  updatedAt: string;\n}\n\ninterface VibecontrolsAgentProfilesData {\n  vibecontrolsAgentProfiles: AgentProfile[];\n}\n\ninterface VibecontrolsAgentProfilesVars {\n  agentId: string;\n}\n\nconst VIBECONTROLS_AGENT_PROFILES_QUERY = gql`\n  query VibecontrolsAgentProfiles($agentId: ID!) {\n    vibecontrolsAgentProfiles(agentId: $agentId) {\n      id\n      agentId\n      name\n      isDefault\n      port\n      status\n      tunnelUrl\n      createdAt\n      updatedAt\n    }\n  }\n`;\n\nexport interface UseActiveAgentProfileResult {\n  /** All profiles for the agent (empty until svc Phase 5A is live). */\n  profiles: AgentProfile[];\n  /** The currently-selected profile name for this agent. */\n  active: string;\n  /** Persist a new active profile for this agent into the store. */\n  setActive: (profile: string) => void;\n  loading: boolean;\n  error: Error | null;\n  /**\n   * Re-fetch the profile list. Resolves when the round-trip settles and\n   * never rejects (failures are swallowed), so it is safe to call\n   * fire-and-forget.\n   */\n  refetch: () => Promise<void>;\n}\n\n/**\n * A profile is \"ready\" when its CLI is actually started/running. `healthy`\n * is included because the rest of the UI (e.g. the profile status dot)\n * treats it as a running state; excluding it here would mark a `healthy`\n * profile unusable and make it unselectable via `isUsableProfile`.\n */\nfunction isReadyStatus(status: string | null): boolean {\n  const v = (status ?? '').toLowerCase();\n  return v === 'ready' || v === 'running' || v === 'active' || v === 'healthy';\n}\n\n/**\n * A profile is a valid *active* target only when it's usable — i.e. the\n * daemon can actually serve profile-scoped requests for it. A never-started\n * `awaiting-config` profile is NOT usable; sitting on it confuses the user\n * and breaks profile-scoped features (Open Editor, Logs, …) with 404s.\n *\n * `default`/`isDefault` are NOT exempt from the readiness check: the boot\n * profile is not always running (its persisted status can be\n * `awaiting-config`), so treating it as usable regardless of status let the\n * stored-selection path preserve an unready `default` and target a\n * non-running profile. We only trust `default`/`isDefault` unconditionally\n * when the svc reports *no* status at all (Phase 5A compat shim: status\n * null/empty), so the UI still works before statuses are populated.\n */\nexport function isUsableProfile(p: AgentProfile): boolean {\n  if (isReadyStatus(p.status)) return true;\n  const hasKnownStatus = (p.status ?? '').trim().length > 0;\n  return !hasKnownStatus && (p.isDefault || p.name === 'default');\n}\n\nexport function useActiveAgentProfile(\n  agentId: string | null | undefined\n): UseActiveAgentProfileResult {\n  const setActiveProfile = useVibeControlsStore((s) => s.setActiveProfile);\n  const storedActive = useVibeControlsStore((s) =>\n    agentId ? (s.activeProfilePerAgent[agentId] ?? null) : null\n  );\n\n  const { data, loading, error, refetch } = useQuery<\n    VibecontrolsAgentProfilesData,\n    VibecontrolsAgentProfilesVars\n  >(VIBECONTROLS_AGENT_PROFILES_QUERY, {\n    variables: { agentId: agentId ?? '' },\n    skip: !agentId,\n    fetchPolicy: 'cache-and-network',\n    // The svc Phase 5A schema may not be published yet; swallow schema\n    // errors so consumers still render with the canonical \"default\"\n    // fallback instead of the whole tree blowing up.\n    errorPolicy: 'ignore',\n  });\n\n  const profiles = useMemo<AgentProfile[]>(() => data?.vibecontrolsAgentProfiles ?? [], [data]);\n\n  const defaultProfile = useMemo<AgentProfile | null>(() => {\n    if (profiles.length === 0) return null;\n    // Resolution order prefers a *usable* profile, because the boot profile\n    // named \"default\" is NOT always running (it can be `awaiting-config`),\n    // and selecting an unready profile breaks profile-scoped features with a\n    // misleading 404. Prefer, in order: the explicitly-default profile if\n    // ready, the boot \"default\" profile if ready, then any ready/running\n    // profile. Only when nothing is ready do we fall back to the configured\n    // default / boot default / first profile as a last resort (something\n    // must be returned so callers can still build a canonical path).\n    return (\n      profiles.find((p) => p.isDefault && isReadyStatus(p.status)) ??\n      profiles.find((p) => p.name === 'default' && isReadyStatus(p.status)) ??\n      profiles.find((p) => isReadyStatus(p.status)) ??\n      profiles.find((p) => p.isDefault) ??\n      profiles.find((p) => p.name === 'default') ??\n      profiles[0] ??\n      null\n    );\n  }, [profiles]);\n\n  const active: string = useMemo(() => {\n    // While the profile list is still unknown (loading / none), honor the\n    // stored choice rather than flicker to \"default\".\n    if (profiles.length === 0) return storedActive ?? 'default';\n    // Honor the stored selection only while it still points to a usable\n    // profile. If it was deleted or is a never-started profile, fall back to\n    // the resolved default so the UI never sits on a dead/awaiting-config\n    // profile (which previously broke Open Editor with a misleading 404).\n    if (storedActive) {\n      const sp = profiles.find((p) => p.name === storedActive);\n      if (sp && isUsableProfile(sp)) return storedActive;\n    }\n    return defaultProfile?.name ?? 'default';\n  }, [profiles, storedActive, defaultProfile]);\n\n  // Self-heal the persisted selection: when it's absent, deleted, or points\n  // to an unusable (never-started) profile, replace it with the resolved\n  // active so the store — and the \"Active\" badge — reflect a real, usable\n  // profile, and downstream store-first readers match this hook.\n  useEffect(() => {\n    if (!agentId || profiles.length === 0) return;\n    if (storedActive !== active) {\n      setActiveProfile(agentId, active);\n    }\n  }, [agentId, profiles.length, storedActive, active, setActiveProfile]);\n\n  const setActive = (profile: string): void => {\n    if (!agentId) return;\n    setActiveProfile(agentId, profile);\n  };\n\n  return {\n    profiles,\n    active,\n    setActive,\n    loading,\n    error: (error as Error | undefined) ?? null,\n    // Non-throwing by contract: refetch failures are swallowed here so no\n    // caller — including fire-and-forget callsites like the Profiles \"Refresh\"\n    // button — can produce an unhandled promise rejection. The list simply\n    // stays stale until the next successful fetch.\n    refetch: async () => {\n      try {\n        await refetch();\n      } catch {\n        /* swallowed — see above */\n      }\n    },\n  };\n}\n"],"mappings":";;;;;AA8CA,IAAM,IAAoC,CAAG;;;;;;;;;;;;;;;AAuC7C,SAAS,EAAc,GAAgC;CACrD,IAAM,KAAK,KAAU,IAAI,aAAa;AACtC,QAAO,MAAM,WAAW,MAAM,aAAa,MAAM,YAAY,MAAM;;AAiBrE,SAAgB,EAAgB,GAA0B;AAGxD,QAFI,EAAc,EAAE,OAAO,GAAS,KAE7B,GADiB,EAAE,UAAU,IAAI,MAAM,CAAC,SAAS,OAC7B,EAAE,aAAa,EAAE,SAAS;;AAGvD,SAAgB,EACd,GAC6B;CAC7B,IAAM,IAAmB,GAAsB,MAAM,EAAE,iBAAiB,EAClE,IAAe,GAAsB,MACzC,IAAW,EAAE,sBAAsB,MAAY,OAAQ,KACxD,EAEK,EAAE,SAAM,YAAS,UAAO,eAAY,EAGxC,GAAmC;EACnC,WAAW,EAAE,SAAS,KAAW,IAAI;EACrC,MAAM,CAAC;EACP,aAAa;EAIb,aAAa;EACd,CAAC,EAEI,IAAW,QAA8B,GAAM,6BAA6B,EAAE,EAAE,CAAC,EAAK,CAAC,EAEvF,IAAiB,QACjB,EAAS,WAAW,IAAU,OAUhC,EAAS,MAAM,MAAM,EAAE,aAAa,EAAc,EAAE,OAAO,CAAC,IAC5D,EAAS,MAAM,MAAM,EAAE,SAAS,aAAa,EAAc,EAAE,OAAO,CAAC,IACrE,EAAS,MAAM,MAAM,EAAc,EAAE,OAAO,CAAC,IAC7C,EAAS,MAAM,MAAM,EAAE,UAAU,IACjC,EAAS,MAAM,MAAM,EAAE,SAAS,UAAU,IAC1C,EAAS,MACT,MAED,CAAC,EAAS,CAAC,EAER,IAAiB,QAAc;AAGnC,MAAI,EAAS,WAAW,EAAG,QAAO,KAAgB;AAKlD,MAAI,GAAc;GAChB,IAAM,IAAK,EAAS,MAAM,MAAM,EAAE,SAAS,EAAa;AACxD,OAAI,KAAM,EAAgB,EAAG,CAAE,QAAO;;AAExC,SAAO,GAAgB,QAAQ;IAC9B;EAAC;EAAU;EAAc;EAAe,CAAC;AAkB5C,QAZA,QAAgB;AACV,GAAC,KAAW,EAAS,WAAW,KAChC,MAAiB,KACnB,EAAiB,GAAS,EAAO;IAElC;EAAC;EAAS,EAAS;EAAQ;EAAc;EAAQ;EAAiB,CAAC,EAO/D;EACL;EACA;EACA,YARiB,MAA0B;AACtC,QACL,EAAiB,GAAS,EAAQ;;EAOlC;EACA,OAAQ,KAA+B;EAKvC,SAAS,YAAY;AACnB,OAAI;AACF,UAAM,GAAS;WACT;;EAIX"}

package/dist/hooks/useAgentConnectivity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAgentConnectivity.js","names":[],"sources":["../../src/hooks/useAgentConnectivity.ts"],"sourcesContent":["/**\n * useAgentConnectivity — single source of truth for \"is this agent reachable\".\n *\n * Reads from the workspace-wide `vibecontrolsAgentHealthProbes` GraphQL query\n * (the same probe the Targets & Agents page polls). The backend hits\n * /health/ready (deep check: ttyd + tunnel + session + db + lifecycle)\n * and reports a per-agent {healthy, errorMessage} payload.\n *\n * Why this hook exists:\n *  - Multiple AI surfaces (AIPage, AgentManagerPage, AISessionDetailPage)\n *    need to render a friendly \"agent not connected\" card before the\n *    install-button surfaces (PluginGate, PluginHarnessPicker) try to\n *    fetch plugin lists from the agent.\n *  - Earlier this hook did its own raw-fetch probe via /health/ready\n *    through the gateway. That created a race between mounts where the\n *    initial render saw `agentId=''` (cache hydration mid-flight),\n *    flipped status to \"unreachable\", and then never recovered for the\n *    user even after the agent id became known. Worse, the per-mount\n *    probe meant a sidenav navigate-back would re-run the fetch from\n *    scratch and briefly show \"Agent not connected\" before settling.\n *  - Routing through the cached GraphQL query eliminates both races:\n *    Apollo's cache-and-network policy returns the last-known result\n *    instantly on remount, and the 30s pollInterval keeps it fresh.\n */\n\nimport { useCallback, useMemo } from 'react';\nimport {\n  useVibecontrolsAgentHealthProbesQuery,\n  useVibecontrolsAgentHealthProbeStreamSubscription,\n} from '@/generated/wspace-operations';\n\nexport type AgentConnectivityStatus = 'unknown' | 'probing' | 'reachable' | 'unreachable';\n\nexport interface UseAgentConnectivityResult {\n  status: AgentConnectivityStatus;\n  /** True when at least one probe has settled (reachable or unreachable). */\n  hasProbed: boolean;\n  /** True while an in-flight probe is running. */\n  probing: boolean;\n  /** True iff the most recent probe says the agent is reachable. */\n  reachable: boolean;\n  /** Sanitized, user-friendly hint for unreachable case. Never raw fetch text. */\n  hint: string | null;\n  /** Re-runs the probe. Resolves once the new probe settles. */\n  retry: () => Promise<void>;\n}\n\nconst UNREACHABLE_PATTERNS: readonly string[] = [\n  'typo in the url',\n  'unable to connect',\n  'failedtoopensocket',\n  'failed to open socket',\n  'econnrefused',\n  'enotfound',\n  'getaddrinfo',\n  'fetch failed',\n  'agent unreachable',\n  'http 503',\n  'agent returned 503',\n  'connection refused',\n  'connection reset',\n  'tunnel is unreachable',\n  'cloudflare tunnel error',\n];\n\nexport function isUnreachableError(message: string | null | undefined): boolean {\n  if (!message) return false;\n  const m = message.toLowerCase();\n  return UNREACHABLE_PATTERNS.some((p) => m.includes(p));\n}\n\n/**\n * Translate a raw error message into a short, user-safe hint key.\n * The full technical detail goes to console.error elsewhere — return\n * value here is for direct UI rendering.\n */\nexport function sanitizeConnectivityHint(raw: string | null | undefined): string | null {\n  if (!raw) return null;\n  if (isUnreachableError(raw)) return 'agent_unreachable';\n  if (raw.toLowerCase().includes('agent not yet configured')) return 'agent_awaiting_config';\n  if (raw.toLowerCase().includes('initializing')) return 'agent_initializing';\n  return 'agent_unreachable';\n}\n\nexport function useAgentConnectivity(agentId: string | null): UseAgentConnectivityResult {\n  // 1) Initial query: gives us cached/first-paint data instantly so the\n  //    UI has something to render before the subscription delivers its\n  //    first event. cache-and-network so a sidenav navigate-back returns\n  //    the cached probe instantly while a fresh fetch refreshes.\n  // 2) Subscription: replaces the prior 30s pollInterval. Backend pushes\n  //    the full health-probe array on every change + a 30s heartbeat,\n  //    so the FE sees status flips in <1s instead of ≤30s.\n  const { data: queryData, loading } = useVibecontrolsAgentHealthProbesQuery({\n    fetchPolicy: 'cache-and-network',\n    nextFetchPolicy: 'cache-first',\n    notifyOnNetworkStatusChange: true,\n    skip: !agentId,\n  });\n  const { data: streamData } = useVibecontrolsAgentHealthProbeStreamSubscription({\n    skip: !agentId,\n  });\n\n  const probe = useMemo(() => {\n    if (!agentId) return null;\n    // Prefer the streamed snapshot when available — it's strictly newer\n    // than the initial query result.\n    const probes =\n      streamData?.vibecontrolsAgentHealthProbeStream ??\n      queryData?.vibecontrolsAgentHealthProbes ??\n      [];\n    return probes.find((p: { agentId: string }) => p.agentId === agentId) ?? null;\n  }, [streamData, queryData, agentId]);\n\n  const status: AgentConnectivityStatus = useMemo(() => {\n    if (!agentId) return 'unreachable';\n    // Until the probe query has any data for this agent, show 'probing' —\n    // do NOT optimistically claim 'reachable' or 'unreachable' before\n    // we've heard from the backend.\n    if (!probe) {\n      return loading ? 'probing' : 'unknown';\n    }\n    return probe.healthy ? 'reachable' : 'unreachable';\n  }, [agentId, probe, loading]);\n\n  const hint = useMemo(() => {\n    if (!agentId) return 'agent_unreachable';\n    if (!probe || probe.healthy) return null;\n    return sanitizeConnectivityHint(probe.errorMessage);\n  }, [agentId, probe]);\n\n  // The pollInterval refreshes every 30s; expose a manual refetch via a\n  // no-op since direct callers historically expected `retry()` to settle\n  // before resolving. Apollo's notifyOnNetworkStatusChange will trigger\n  // a re-render once the next poll arrives.\n  const retry = useCallback(async (): Promise<void> => {\n    /* polling handles refresh; manual retry is a soft no-op */\n  }, []);\n\n  return {\n    status,\n    hasProbed: status === 'reachable' || status === 'unreachable',\n    probing: status === 'probing',\n    reachable: status === 'reachable',\n    hint,\n    retry,\n  };\n}\n"],"mappings":";;;AA+CA,IAAM,IAA0C;CAC9C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;AAED,SAAgB,EAAmB,GAA6C;AAC9E,KAAI,CAAC,EAAS,QAAO;CACrB,IAAM,IAAI,EAAQ,aAAa;AAC/B,QAAO,EAAqB,MAAM,MAAM,EAAE,SAAS,EAAE,CAAC;;AAQxD,SAAgB,EAAyB,GAA+C;AAKtF,QAJK,IACD,EAAmB,EAAI,GAAS,sBAChC,EAAI,aAAa,CAAC,SAAS,2BAA2B,GAAS,0BAC/D,EAAI,aAAa,CAAC,SAAS,eAAe,GAAS,uBAChD,sBAJU;;AAOnB,SAAgB,EAAqB,GAAoD;CAQvF,IAAM,EAAE,MAAM,GAAW,eAAY,EAAsC;EACzE,aAAa;EACb,iBAAiB;EACjB,6BAA6B;EAC7B,MAAM,CAAC;EACR,CAAC,EACI,EAAE,MAAM,MAAe,EAAkD,EAC7E,MAAM,CAAC,GACR,CAAC,EAEI,IAAQ,QACP,KAIH,GAAY,sCACZ,GAAW,iCACX,EAAE,EACU,MAAM,MAA2B,EAAE,YAAY,EAAQ,IAAI,OAPpD,MAQpB;EAAC;EAAY;EAAW;EAAQ,CAAC,EAE9B,IAAkC,QACjC,IAIA,IAGE,EAAM,UAAU,cAAc,gBAF5B,IAAU,YAAY,YALV,eAQpB;EAAC;EAAS;EAAO;EAAQ,CAAC,EAEvB,IAAO,QACN,IACD,CAAC,KAAS,EAAM,UAAgB,OAC7B,EAAyB,EAAM,aAAa,GAF9B,qBAGpB,CAAC,GAAS,EAAM,CAAC,EAMd,IAAQ,EAAY,YAA2B,IAElD,EAAE,CAAC;AAEN,QAAO;EACL;EACA,WAAW,MAAW,eAAe,MAAW;EAChD,SAAS,MAAW;EACpB,WAAW,MAAW;EACtB;EACA;EACD"}

package/dist/hooks/useAgentEvents.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAgentEvents.js","names":[],"sources":["../../src/hooks/useAgentEvents.ts"],"sourcesContent":["/**\n * useAgentEvents Hook\n *\n * Apollo subscription wrapper around `recentAiToolEventsStream` — the\n * backend publishes via Redis-Streams-backed pubsub (be-sdk), so each\n * agent's events fan out to every replica's subscribers and the gateway\n * delivers them to this hook over SSE. Replaces the prior 3s setInterval\n * `RecentAiToolEvents` query that fired multiple times per second across\n * every mounted page (BOFF-2649).\n *\n * The hook keeps the same public surface as the polling version\n * (`status`/`error`/`notifications`/`reconnect`/`disconnect`/...) so\n * `AgentEventsProvider` and the toast UI don't change.\n */\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react';\n\nimport { useRecentAiToolEventsStreamSubscription } from '@/generated/wspace-operations';\n\nexport type AgentEventType =\n  | 'connected'\n  | 'session:created'\n  | 'session:updated'\n  | 'session:terminated'\n  | 'session:output'\n  | 'tunnel:started'\n  | 'tunnel:stopped'\n  | 'tunnel:error'\n  | 'notification:new'\n  | 'notification:read'\n  | 'file:changed'\n  | 'task:started'\n  | 'task:completed'\n  | 'task:failed'\n  | 'plugin:installed'\n  | 'plugin:removed'\n  | 'plugin:reloaded'\n  | 'agent:heartbeat'\n  | 'log:entry'\n  | 'pong';\n\nexport interface AiToolNotification {\n  id: string;\n  source: string;\n  eventType: string;\n  title: string;\n  message: string;\n  timestamp: string;\n  properties?: Record<string, unknown>;\n}\n\nexport interface AgentEvent<T = unknown> {\n  type: AgentEventType;\n  payload: T;\n  timestamp: string;\n}\n\nexport type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';\n\nexport interface UseAgentEventsOptions {\n  agentId: string | null;\n  enabled?: boolean;\n  /** Cap on most-recent events the server replays on subscribe. */\n  limit?: number;\n  /**\n   * Retained for API compatibility with the polling implementation but\n   * no longer drives a timer — Apollo's link-level retry handles\n   * transport reconnect. Kept on the type so existing consumers\n   * compile unchanged.\n   */\n  reconnectDelay?: number;\n  maxReconnectAttempts?: number;\n  onNotification?: (notification: AiToolNotification) => void;\n  onEvent?: (event: AgentEvent) => void;\n  onStatusChange?: (status: ConnectionStatus) => void;\n}\n\nexport interface UseAgentEventsReturn {\n  status: ConnectionStatus;\n  error: string | null;\n  notifications: AiToolNotification[];\n  reconnect: () => void;\n  disconnect: () => void;\n  clearNotifications: () => void;\n  dismissNotification: (id: string) => void;\n}\n\nconst MAX_NOTIFICATIONS = 50;\nconst DEFAULT_LIMIT = 20;\n\ninterface RecentAiToolEvent {\n  id: string;\n  source: string;\n  eventType: string;\n  payload?: Record<string, unknown> | null;\n  createdAt: string;\n}\n\nfunction toNotification(event: RecentAiToolEvent): AiToolNotification {\n  const payload = event.payload ?? {};\n  return {\n    id: event.id,\n    source: event.source,\n    eventType: event.eventType,\n    title: typeof payload.title === 'string' ? payload.title : `${event.source} event`,\n    message:\n      typeof payload.message === 'string'\n        ? payload.message\n        : typeof payload.summary === 'string'\n          ? payload.summary\n          : event.eventType,\n    timestamp: event.createdAt,\n    properties: payload,\n  };\n}\n\nexport function useAgentEvents(options: UseAgentEventsOptions): UseAgentEventsReturn {\n  const {\n    agentId,\n    enabled = true,\n    limit = DEFAULT_LIMIT,\n    onNotification,\n    onEvent,\n    onStatusChange,\n  } = options;\n\n  const [notifications, setNotifications] = useState<AiToolNotification[]>([]);\n  const [intentionallyDisconnected, setIntentionallyDisconnected] = useState(false);\n  // Bumped by `reconnect()` to force Apollo to tear down the existing\n  // subscription and start a fresh one — `skip` toggling alone would\n  // race with in-flight messages on the same Apollo observable.\n  const [subscriptionEpoch, setSubscriptionEpoch] = useState(0);\n\n  const seenEventIdsRef = useRef<Set<string>>(new Set());\n  const lastStatusRef = useRef<ConnectionStatus | null>(null);\n  // Latched callbacks so the subscription doesn't tear down every time\n  // a parent re-renders with a new closure identity for `onEvent` etc.\n  const onNotificationRef = useRef(onNotification);\n  const onEventRef = useRef(onEvent);\n  const onStatusChangeRef = useRef(onStatusChange);\n  useEffect(() => {\n    onNotificationRef.current = onNotification;\n  }, [onNotification]);\n  useEffect(() => {\n    onEventRef.current = onEvent;\n  }, [onEvent]);\n  useEffect(() => {\n    onStatusChangeRef.current = onStatusChange;\n  }, [onStatusChange]);\n\n  const shouldSubscribe = enabled && !!agentId && !intentionallyDisconnected;\n\n  const { data, error, loading } = useRecentAiToolEventsStreamSubscription({\n    variables: { agentId: agentId ?? '', limit },\n    skip: !shouldSubscribe,\n    // `subscriptionEpoch` participates so a bump of the epoch swaps the\n    // observable identity (the generated hook doesn't expose a manual\n    // restart, but a variables-shape change triggers Apollo's internal\n    // resubscribe path).\n    context: { _epoch: subscriptionEpoch },\n  });\n\n  // Translate Apollo state into the polling-era status enum so the\n  // toast UI keeps rendering the same status pill copy.\n  const status: ConnectionStatus = useMemo(() => {\n    if (!shouldSubscribe) return 'disconnected';\n    if (error) return 'error';\n    if (loading || !data) return 'connecting';\n    return 'connected';\n  }, [shouldSubscribe, error, loading, data]);\n\n  useEffect(() => {\n    if (lastStatusRef.current === status) return;\n    lastStatusRef.current = status;\n    onStatusChangeRef.current?.(status);\n  }, [status]);\n\n  // Reset the seen-event memo whenever we switch agents — leaving it\n  // populated would mean the first batch from the new agent gets\n  // silently de-duped against the previous agent's IDs.\n  useEffect(() => {\n    seenEventIdsRef.current = new Set();\n    setNotifications([]);\n  }, [agentId]);\n\n  // Fold each subscription frame into the notification list. The\n  // server emits the full most-recent-N array, so we use the seen-ID\n  // set to skip notifications already surfaced to the user (and so\n  // `onNotification` fires once per real event, not on every heartbeat).\n  useEffect(() => {\n    if (!shouldSubscribe) return;\n    const events = data?.recentAiToolEventsStream;\n    if (!events || events.length === 0) return;\n\n    const incoming: AiToolNotification[] = [];\n    // Walk oldest-first so the in-memory order matches arrival order.\n    for (const event of [...events].reverse()) {\n      if (seenEventIdsRef.current.has(event.id)) continue;\n      seenEventIdsRef.current.add(event.id);\n      const notification = toNotification(event);\n      incoming.push(notification);\n      onNotificationRef.current?.(notification);\n      onEventRef.current?.({\n        type: 'notification:new',\n        payload: notification,\n        timestamp: event.createdAt,\n      });\n    }\n\n    if (incoming.length > 0) {\n      setNotifications((prev) => [...incoming.reverse(), ...prev].slice(0, MAX_NOTIFICATIONS));\n    }\n  }, [data, shouldSubscribe]);\n\n  const clearNotifications = useCallback(() => {\n    setNotifications([]);\n  }, []);\n\n  const dismissNotification = useCallback((id: string) => {\n    setNotifications((prev) => prev.filter((notification) => notification.id !== id));\n  }, []);\n\n  const disconnect = useCallback(() => {\n    setIntentionallyDisconnected(true);\n  }, []);\n\n  const reconnect = useCallback(() => {\n    seenEventIdsRef.current = new Set();\n    setIntentionallyDisconnected(false);\n    setSubscriptionEpoch((n) => n + 1);\n  }, []);\n\n  return {\n    status,\n    error: error ? error.message : null,\n    notifications,\n    reconnect,\n    disconnect,\n    clearNotifications,\n    dismissNotification,\n  };\n}\n"],"mappings":"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"}

package/dist/hooks/useAgentManagerKeyboard.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAgentManagerKeyboard.js","names":[],"sources":["../../src/hooks/useAgentManagerKeyboard.ts"],"sourcesContent":["/**\n * Keyboard shortcuts for the Agent Manager.\n *\n * Registers global key handlers for common operations:\n * - Ctrl+Shift+N: new session\n * - Ctrl+K: open session search\n * - Ctrl+F: open in-session search (only when not focused on textarea/input)\n * - Escape: cancel streaming\n */\n\nimport { useEffect, useCallback } from 'react';\nimport { useAgentManagerStore } from '@/store/agentManagerStore';\n\ninterface UseAgentManagerKeyboardParams {\n  onCancelStream?: () => void;\n  onOpenSearch?: () => void;\n  onOpenInSessionSearch?: () => void;\n}\n\nexport function useAgentManagerKeyboard({\n  onCancelStream,\n  onOpenSearch,\n  onOpenInSessionSearch,\n}: UseAgentManagerKeyboardParams = {}): void {\n  const openSession = useAgentManagerStore((s) => s.openSession);\n  const tabs = useAgentManagerStore((s) => s.tabs);\n  const setActiveTab = useAgentManagerStore((s) => s.setActiveTab);\n\n  const handleKeyDown = useCallback(\n    (e: KeyboardEvent) => {\n      const isCtrlOrMeta = e.ctrlKey || e.metaKey;\n\n      // Alt+1-9: switch to tab by index\n      if (e.altKey && e.key >= '1' && e.key <= '9') {\n        e.preventDefault();\n        const index = parseInt(e.key, 10) - 1;\n        if (index < tabs.length) {\n          setActiveTab(tabs[index].sessionId);\n        }\n        return;\n      }\n\n      // Alt+ArrowLeft / Alt+ArrowRight: cycle through tabs\n      if (e.altKey && (e.key === 'ArrowLeft' || e.key === 'ArrowRight')) {\n        e.preventDefault();\n        if (tabs.length === 0) return;\n        const activeSessionId = useAgentManagerStore.getState().activeTabSessionId;\n        const currentIndex = tabs.findIndex((t) => t.sessionId === activeSessionId);\n        let nextIndex: number;\n        if (e.key === 'ArrowLeft') {\n          nextIndex = currentIndex <= 0 ? tabs.length - 1 : currentIndex - 1;\n        } else {\n          nextIndex = currentIndex >= tabs.length - 1 ? 0 : currentIndex + 1;\n        }\n        setActiveTab(tabs[nextIndex].sessionId);\n        return;\n      }\n\n      // Ctrl+Shift+N: new session\n      if (isCtrlOrMeta && e.shiftKey && e.key === 'N') {\n        e.preventDefault();\n        const sessionId = `session-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;\n        openSession(sessionId);\n        return;\n      }\n\n      // Ctrl+K: open session search\n      if (isCtrlOrMeta && e.key === 'k') {\n        e.preventDefault();\n        onOpenSearch?.();\n        return;\n      }\n\n      // Ctrl+F: open in-session search (only when not focused on textarea/input)\n      if (isCtrlOrMeta && e.key === 'f') {\n        const tag = (document.activeElement as HTMLElement)?.tagName?.toLowerCase();\n        if (tag === 'textarea' || tag === 'input') return;\n        e.preventDefault();\n        onOpenInSessionSearch?.();\n        return;\n      }\n\n      // Escape: cancel streaming\n      if (e.key === 'Escape') {\n        onCancelStream?.();\n      }\n    },\n    [openSession, tabs, setActiveTab, onCancelStream, onOpenSearch, onOpenInSessionSearch]\n  );\n\n  useEffect(() => {\n    window.addEventListener('keydown', handleKeyDown);\n    return () => {\n      window.removeEventListener('keydown', handleKeyDown);\n    };\n  }, [handleKeyDown]);\n}\n"],"mappings":";;;AAmBA,SAAgB,EAAwB,EACtC,mBACA,iBACA,6BACiC,EAAE,EAAQ;CAC3C,IAAM,IAAc,GAAsB,MAAM,EAAE,YAAY,EACxD,IAAO,GAAsB,MAAM,EAAE,KAAK,EAC1C,IAAe,GAAsB,MAAM,EAAE,aAAa,EAE1D,IAAgB,GACnB,MAAqB;EACpB,IAAM,IAAe,EAAE,WAAW,EAAE;AAGpC,MAAI,EAAE,UAAU,EAAE,OAAO,OAAO,EAAE,OAAO,KAAK;AAC5C,KAAE,gBAAgB;GAClB,IAAM,IAAQ,SAAS,EAAE,KAAK,GAAG,GAAG;AACpC,GAAI,IAAQ,EAAK,UACf,EAAa,EAAK,GAAO,UAAU;AAErC;;AAIF,MAAI,EAAE,WAAW,EAAE,QAAQ,eAAe,EAAE,QAAQ,eAAe;AAEjE,OADA,EAAE,gBAAgB,EACd,EAAK,WAAW,EAAG;GACvB,IAAM,IAAkB,EAAqB,UAAU,CAAC,oBAClD,IAAe,EAAK,WAAW,MAAM,EAAE,cAAc,EAAgB,EACvE;AAMJ,GALA,AAGE,IAHE,EAAE,QAAQ,cACA,KAAgB,IAAI,EAAK,SAAS,IAAI,IAAe,IAErD,KAAgB,EAAK,SAAS,IAAI,IAAI,IAAe,GAEnE,EAAa,EAAK,GAAW,UAAU;AACvC;;AAIF,MAAI,KAAgB,EAAE,YAAY,EAAE,QAAQ,KAAK;AAG/C,GAFA,EAAE,gBAAgB,EAElB,EADkB,WAAW,KAAK,KAAK,CAAC,GAAG,KAAK,QAAQ,CAAC,SAAS,GAAG,CAAC,MAAM,GAAG,EAAE,GAC3D;AACtB;;AAIF,MAAI,KAAgB,EAAE,QAAQ,KAAK;AAEjC,GADA,EAAE,gBAAgB,EAClB,KAAgB;AAChB;;AAIF,MAAI,KAAgB,EAAE,QAAQ,KAAK;GACjC,IAAM,IAAO,SAAS,eAA+B,SAAS,aAAa;AAC3E,OAAI,MAAQ,cAAc,MAAQ,QAAS;AAE3C,GADA,EAAE,gBAAgB,EAClB,KAAyB;AACzB;;AAIF,EAAI,EAAE,QAAQ,YACZ,KAAkB;IAGtB;EAAC;EAAa;EAAM;EAAc;EAAgB;EAAc;EAAsB,CACvF;AAED,UACE,OAAO,iBAAiB,WAAW,EAAc,QACpC;AACX,SAAO,oBAAoB,WAAW,EAAc;KAErD,CAAC,EAAc,CAAC"}

package/dist/hooks/useAgentManagerStreaming.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAgentManagerStreaming.js","names":[],"sources":["../../src/hooks/useAgentManagerStreaming.ts"],"sourcesContent":["/**\n * Hook for streaming management in Agent Manager sessions.\n *\n * Manages the send/receive lifecycle: adds user message to store,\n * creates a placeholder assistant message, calls sendPromptToSession,\n * updates the placeholder with the response, and handles cancellation.\n */\n\nimport { useRef, useCallback } from 'react';\nimport { useAgentManagerStore } from '@/store/agentManagerStore';\nimport { sendPromptToSession, type AgentRef } from '@/services/aiApi';\nimport type { AgentManagerMessage } from '@/types/agentManager';\n\ninterface UseAgentManagerStreamingParams {\n  agent: AgentRef;\n  sessionId: string;\n}\n\ninterface UseAgentManagerStreamingReturn {\n  sendMessage: (prompt: string) => Promise<void>;\n  cancelStream: () => void;\n  isStreaming: boolean;\n}\n\nfunction generateId(): string {\n  return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;\n}\n\nexport function useAgentManagerStreaming({\n  agent,\n  sessionId,\n}: UseAgentManagerStreamingParams): UseAgentManagerStreamingReturn {\n  const abortRef = useRef<AbortController | null>(null);\n\n  const addMessage = useAgentManagerStore((s) => s.addMessage);\n  const updateMessage = useAgentManagerStore((s) => s.updateMessage);\n  const setSessionStatus = useAgentManagerStore((s) => s.setSessionStatus);\n  const sessionState = useAgentManagerStore((s) => s.sessionStates[sessionId]);\n\n  const isStreaming = sessionState?.status === 'streaming' || sessionState?.status === 'processing';\n\n  const sendMessage = useCallback(\n    async (prompt: string) => {\n      // Get current session state for SDK, model, and history limit\n      const currentState = useAgentManagerStore.getState().sessionStates[sessionId];\n      const currentSdk = currentState?.sdk;\n      const currentModel = currentState?.model;\n      const currentMode = currentState?.mode;\n      const currentPermissionMode = currentState?.permissionMode;\n      const historyLimit = currentState?.contextHistoryLimit ?? 20;\n\n      // Add user message with SDK info\n      const userMsg: AgentManagerMessage = {\n        id: generateId(),\n        role: 'user',\n        content: prompt,\n        timestamp: new Date().toISOString(),\n        sdk: currentSdk,\n      };\n      addMessage(sessionId, userMsg);\n\n      // Build conversation history from last N messages (excluding the one just added)\n      const messages = currentState?.messages ?? [];\n      const historyMessages = messages\n        .filter((m) => m.role === 'user' || m.role === 'assistant')\n        .slice(-historyLimit)\n        .map((m) => ({ role: m.role, content: m.content }));\n\n      // Map attached session contexts → the agent provider's context payload\n      // ({ id, type, content, metadata }). Files materialised on the server pass\n      // their path (+ inline text when small); prompts/contexts pass their body.\n      const contextItems = currentState?.contexts ?? [];\n      const contextsPayload = contextItems.map((c) => ({\n        id: c.sourceId ?? c.id,\n        type: c.kind,\n        content: c.content ?? (c.path ? `File available on the server at: ${c.path}` : ''),\n        metadata: c.path ? { path: c.path, label: c.label } : { label: c.label },\n      }));\n\n      // Add placeholder assistant message\n      const assistantMsgId = generateId();\n      const placeholderMsg: AgentManagerMessage = {\n        id: assistantMsgId,\n        role: 'assistant',\n        content: '',\n        timestamp: new Date().toISOString(),\n        sdk: currentSdk,\n      };\n      addMessage(sessionId, placeholderMsg);\n\n      // Set status to streaming\n      setSessionStatus(sessionId, 'streaming');\n\n      // Create abort controller\n      const controller = new AbortController();\n      abortRef.current = controller;\n\n      try {\n        const result = await sendPromptToSession(\n          agent,\n          sessionId,\n          prompt,\n          contextsPayload.length > 0 ? contextsPayload : undefined,\n          {\n            agentType: currentSdk,\n            model: currentModel,\n            mode: currentMode,\n            // Autonomy applies in CLI mode only; don't send it for SDK sessions\n            // so the \"ignored in SDK mode\" contract holds at the transport layer.\n            permissionMode: currentMode === 'cli' ? currentPermissionMode : undefined,\n            conversationHistory: historyMessages.length > 0 ? historyMessages : undefined,\n          }\n        );\n\n        // Check if aborted\n        if (controller.signal.aborted) return;\n\n        // Update the placeholder message with the response\n        updateMessage(sessionId, assistantMsgId, result.response);\n\n        // Patch the assistant message with tokens, model, and SDK used\n        {\n          const store = useAgentManagerStore.getState();\n          const session = store.sessionStates[sessionId];\n          if (session) {\n            const responseModel = (result as Record<string, unknown>).model as string | undefined;\n            const responseSdk = (\n              (result as Record<string, unknown>).metadata as Record<string, unknown>\n            )?.provider as string | undefined;\n            const updatedMessages = session.messages.map((m) =>\n              m.id === assistantMsgId\n                ? {\n                    ...m,\n                    content: result.response,\n                    tokens: result.tokens,\n                    model: responseModel || m.model,\n                    sdk: (responseSdk as AgentManagerMessage['sdk']) || currentSdk,\n                  }\n                : m\n            );\n            useAgentManagerStore.setState((prev) => ({\n              sessionStates: {\n                ...prev.sessionStates,\n                [sessionId]: { ...session, messages: updatedMessages },\n              },\n            }));\n          }\n        }\n\n        setSessionStatus(sessionId, 'idle');\n      } catch (error: unknown) {\n        if (controller.signal.aborted) return;\n\n        const errorMessage = error instanceof Error ? error.message : 'An error occurred';\n\n        // SDK auth not configured → surface a credentials prompt instead of\n        // a dead-end error message. The chat surface watches the store's\n        // sdkAuthPrompt field and opens AIProviderCredentialsCard inline.\n        if (\n          errorMessage.includes('Claude SDK auth is not configured') ||\n          errorMessage.includes('ANTHROPIC_API_KEY') ||\n          errorMessage.includes('ANTHROPIC_AUTH_TOKEN')\n        ) {\n          useAgentManagerStore.getState().setSdkAuthPrompt({\n            agentId: agent.id,\n            reason: errorMessage,\n          });\n          updateMessage(\n            sessionId,\n            assistantMsgId,\n            'Set your Anthropic API key or auth token to continue. A prompt has been opened below.'\n          );\n          setSessionStatus(sessionId, 'idle');\n        } else {\n          updateMessage(sessionId, assistantMsgId, `Error: ${errorMessage}`);\n          setSessionStatus(sessionId, 'error');\n\n          // Reset to idle after a brief period\n          setTimeout(() => {\n            setSessionStatus(sessionId, 'idle');\n          }, 3000);\n        }\n      } finally {\n        abortRef.current = null;\n      }\n    },\n    [agent, sessionId, addMessage, updateMessage, setSessionStatus]\n  );\n\n  const cancelStream = useCallback(() => {\n    if (abortRef.current) {\n      abortRef.current.abort();\n      abortRef.current = null;\n    }\n    setSessionStatus(sessionId, 'idle');\n  }, [sessionId, setSessionStatus]);\n\n  return { sendMessage, cancelStream, isStreaming };\n}\n"],"mappings":"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"}

package/dist/hooks/useAiCreditsQuota.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAiCreditsQuota.js","names":[],"sources":["../../src/hooks/useAiCreditsQuota.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport { useQuery, useQueryClient, type QueryClient } from '@tanstack/react-query';\nimport { useSafeGatewayClient, type ApolloClient } from '@burdenoff/fe-libs/shared/graphql';\nimport { getWorkspaceId } from '@burdenoff/fe-libs/shared/assistant/context';\nimport {\n  GetAiCreditsLedgerDocument,\n  type GetAiCreditsLedgerQuery,\n  type GetAiCreditsLedgerQueryVariables,\n} from '@/generated/wspace-operations';\nimport { AI_CREDITS_UPDATED_EVENT } from '@/utils/aiCredits';\nimport {\n  summarizeAiCreditsLedger,\n  type AiCreditsLedgerRow,\n  type AiCreditsQuota,\n} from '@/utils/aiCreditsLedger';\n\nexport type { AiCreditsQuota } from '@/utils/aiCreditsLedger';\n\n/** Prefix of every workspace's meter query; the charge event invalidates all of them. */\nexport const AI_CREDITS_QUERY_KEY = ['vibecontrols', 'ai-credits-quota'] as const;\n\n/** One read of the workspace ledger, as the Apollo result reports it. */\nexport interface AiCreditsLedgerResult {\n  data?: GetAiCreditsLedgerQuery | null;\n  error?: unknown;\n}\n\nexport type ReadAiCreditsLedger = (workspaceId: string) => Promise<AiCreditsLedgerResult>;\n\n/**\n * Reads the meter's `used / limit` from the ledger `reportAiTokenUsage` charges.\n *\n * Null — the meter hides — when there is no workspace, when the read errors\n * (FORBIDDEN, a gateway 500, a network failure), or when the workspace has no\n * active `vibecontrols.ai.credits` assignment. A failed read must never render\n * a number: \"0 used\" would read as \"nothing spent\" when the truth is \"unknown\".\n */\nexport async function readAiCreditsQuota(\n  workspaceId: string,\n  readLedger: ReadAiCreditsLedger\n): Promise<AiCreditsQuota | null> {\n  if (!workspaceId) return null;\n\n  let result: AiCreditsLedgerResult;\n  try {\n    result = await readLedger(workspaceId);\n  } catch {\n    return null;\n  }\n  if (result.error) return null;\n\n  const rows: readonly AiCreditsLedgerRow[] | undefined = result.data?.workspaceQuotaAssignments;\n  if (!rows) return null;\n\n  return summarizeAiCreditsLedger(rows);\n}\n\n/**\n * The ledger read over the wspace gateway client. `errorPolicy: 'all'` makes a\n * GraphQL error come back as `result.error` instead of a rejection, and\n * `readAiCreditsQuota` hides the meter on either.\n */\nexport function wspaceLedgerReader(client: ApolloClient): ReadAiCreditsLedger {\n  return (workspaceId) =>\n    client.query<GetAiCreditsLedgerQuery, GetAiCreditsLedgerQueryVariables>({\n      query: GetAiCreditsLedgerDocument,\n      variables: { workspaceId },\n      fetchPolicy: 'network-only',\n      errorPolicy: 'all',\n    });\n}\n\n/**\n * React Query options for the meter. The workspace is part of the key, so a\n * workspace switch never shows the previous workspace's balance; the query is\n * disabled until there is both a wspace client and a workspace.\n */\nexport function aiCreditsQueryOptions(client: ApolloClient | null, workspaceId: string) {\n  return {\n    queryKey: [...AI_CREDITS_QUERY_KEY, workspaceId] as const,\n    enabled: !!client && !!workspaceId,\n    staleTime: 30_000,\n    queryFn: (): Promise<AiCreditsQuota | null> =>\n      client ? readAiCreditsQuota(workspaceId, wspaceLedgerReader(client)) : Promise.resolve(null),\n  };\n}\n\n/**\n * Refetches every meter query whenever an assistant turn charges credits\n * (AI_CREDITS_UPDATED_EVENT). Returns the unsubscribe function.\n */\nexport function refetchOnAiCreditsUpdated(\n  target: EventTarget,\n  queryClient: QueryClient\n): () => void {\n  const handler = () => {\n    void queryClient.invalidateQueries({ queryKey: AI_CREDITS_QUERY_KEY });\n  };\n  target.addEventListener(AI_CREDITS_UPDATED_EVENT, handler);\n  return () => target.removeEventListener(AI_CREDITS_UPDATED_EVENT, handler);\n}\n\n/**\n * Live AI-credits usage for the active workspace.\n *\n * ★★ Reads wspace-activity `workspaceQuotaAssignments` — the rows\n * `reportAiTokenUsage` increments via `trackUsage` and the `checkAiCredits`\n * pre-flight enforces against. It used to read global-billing\n * `getQuotaUsageAndLimit`, which nothing on the charge path writes, and which\n * answered INTERNAL_SERVER_ERROR in prod, so the meter never showed (BOFF-7305).\n * Multiple active rows are summed the way the pre-flight sums them; see\n * `summarizeAiCreditsLedger`.\n *\n * The workspace is the one the assistant sends turns to (`getWorkspaceId`).\n */\nexport function useAiCreditsQuota(): { data: AiCreditsQuota | null; loading: boolean } {\n  const workspaceClient = useSafeGatewayClient('workspace');\n  const queryClient = useQueryClient();\n  const query = useQuery(aiCreditsQueryOptions(workspaceClient, getWorkspaceId()));\n\n  useEffect(() => refetchOnAiCreditsUpdated(window, queryClient), [queryClient]);\n\n  return { data: query.data ?? null, loading: query.isLoading };\n}\n"],"mappings":";;;;;;;;AAmBA,IAAa,IAAuB,CAAC,gBAAgB,mBAAmB;AAkBxE,eAAsB,EACpB,GACA,GACgC;AAChC,KAAI,CAAC,EAAa,QAAO;CAEzB,IAAI;AACJ,KAAI;AACF,MAAS,MAAM,EAAW,EAAY;SAChC;AACN,SAAO;;AAET,KAAI,EAAO,MAAO,QAAO;CAEzB,IAAM,IAAkD,EAAO,MAAM;AAGrE,QAFK,IAEE,EAAyB,EAAK,GAFnB;;AAUpB,SAAgB,EAAmB,GAA2C;AAC5E,SAAQ,MACN,EAAO,MAAiE;EACtE,OAAO;EACP,WAAW,EAAE,gBAAa;EAC1B,aAAa;EACb,aAAa;EACd,CAAC;;AAQN,SAAgB,EAAsB,GAA6B,GAAqB;AACtF,QAAO;EACL,UAAU,CAAC,GAAG,GAAsB,EAAY;EAChD,SAAS,CAAC,CAAC,KAAU,CAAC,CAAC;EACvB,WAAW;EACX,eACE,IAAS,EAAmB,GAAa,EAAmB,EAAO,CAAC,GAAG,QAAQ,QAAQ,KAAK;EAC/F;;AAOH,SAAgB,EACd,GACA,GACY;CACZ,IAAM,UAAgB;AACf,IAAY,kBAAkB,EAAE,UAAU,GAAsB,CAAC;;AAGxE,QADA,EAAO,iBAAiB,GAA0B,EAAQ,QAC7C,EAAO,oBAAoB,GAA0B,EAAQ;;AAgB5E,SAAgB,IAAuE;CACrF,IAAM,IAAkB,EAAqB,YAAY,EACnD,IAAc,GAAgB,EAC9B,IAAQ,EAAS,EAAsB,GAAiB,GAAgB,CAAC,CAAC;AAIhF,QAFA,QAAgB,EAA0B,QAAQ,EAAY,EAAE,CAAC,EAAY,CAAC,EAEvE;EAAE,MAAM,EAAM,QAAQ;EAAM,SAAS,EAAM;EAAW"}

package/dist/hooks/useCachedInitialData.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useCachedInitialData.js","names":[],"sources":["../../src/hooks/useCachedInitialData.ts"],"sourcesContent":["/**\n * useCachedInitialData\n *\n * Hook to read the prefetched initial data from Apollo cache.\n * This uses cache-only to avoid any network requests - data should already\n * be present from the useInitialDataLoader in VibeControlsProvider.\n *\n * This hook is the primary way components should access shared data\n * (agents, vibes, sessions, notes) instead of making independent queries.\n *\n * NOTE: `targets` was removed from the VibeControlsInitialData query because\n * the targets subgraph caused persistent 25s OPERATION_TIMEOUT errors at mount.\n * Pages needing targets should issue their own lazy query.\n */\n\nimport { useMemo, useCallback } from 'react';\nimport { useVibeControls } from '../providers/VibeControlsProvider';\nimport type { AgentVisibility } from '../utils/agentVisibility';\nimport {\n  useVibeControlsInitialDataQuery,\n  type VibeControlsInitialDataQuery,\n  type VibeControlsInitialDataQueryVariables,\n} from '../generated/wspace-operations';\n\n/**\n * Return type for cached initial data\n */\ninterface CachedInitialData {\n  /** The full cached query result */\n  data?: VibeControlsInitialDataQuery;\n  /** Whether the data is still loading (should be false if cached) */\n  loading: boolean;\n  /** Whether there was an error (cached data might still be available) */\n  error?: Error;\n  /** All agents from cache */\n  agents: Array<{\n    id: string;\n    name: string;\n    hostname: string;\n    platform: string;\n    architecture?: string;\n    isActive: boolean;\n    tunnelUrl?: string | null;\n    tunnelStatus?: string | null;\n    lastHeartbeat?: string | null;\n    version?: string;\n    createdAt?: string;\n    updatedAt?: string;\n    /** jsonb metadata; carries the canonical CLI `profile` field. */\n    metadata?: Record<string, unknown> | null;\n    /** Owner of the agent; null for a legacy ownerless (shared) agent. */\n    ownerUserId: string | null;\n    /** Who can see and use the agent — the authority for private/shared UI. */\n    visibility: AgentVisibility | null;\n  }>;\n  /** All vibes from cache. Multi-agent: vibes carry an `agents` list now. */\n  vibes: Array<{\n    id: string;\n    name: string;\n    description?: string;\n    path?: string;\n    status: string;\n    /**\n     * Agents currently attached to this vibe. Empty when none — agent-dependent\n     * features (sessions, tunnels, gitops, plugins) are disabled in the UI.\n     * Each entry carries `ownerUserId` so the picker can partition usable vs\n     * locked agents (personal agents only the owner can use).\n     */\n    agents: Array<{\n      id: string;\n      name: string;\n      isActive: boolean;\n      ownerUserId?: string | null;\n    }>;\n    type?: string;\n    tags?: string[];\n    gitBranch?: string | null;\n    createdAt?: string;\n    updatedAt?: string;\n  }>;\n  /** All sessions from cache */\n  sessions: Array<{\n    id: string;\n    name: string;\n    status: string;\n    agentId?: string | null;\n    vibeId?: string | null;\n    type?: string;\n    startedAt?: string | null;\n    metadata?: Record<string, unknown> | null;\n    createdAt?: string;\n    updatedAt?: string;\n  }>;\n  /** All targets from cache */\n  targets: Array<{\n    id: string;\n    workspaceId?: string;\n    name: string;\n    type?: string;\n    status: string;\n    host?: string | null;\n    port?: number | null;\n    username?: string | null;\n    connectionId?: string | null;\n    label?: string | null;\n    tags?: string[];\n    metadata?: Record<string, unknown> | null;\n    createdAt?: string;\n    updatedAt?: string;\n    agents?: Array<{\n      id: string;\n      name: string;\n      version?: string | null;\n      isActive: boolean;\n      tunnelUrl?: string | null;\n    }>;\n  }>;\n  /** All notes from cache */\n  notes: Array<{\n    id: string;\n    title: string;\n    isPinned: boolean;\n  }>;\n  /** Totals for stats */\n  totals: {\n    agents: number;\n    vibes: number;\n    sessions: number;\n    targets: number;\n    notes: number;\n  };\n  /** Refetch all initial data from network */\n  refetch: () => void;\n}\n\n/**\n * Hook to access cached initial data.\n * Returns data from Apollo cache with cache-only policy.\n * If data is not yet in cache, returns empty arrays.\n *\n * Usage:\n * ```tsx\n * function MyComponent() {\n *   const { agents, vibes, sessions, loading } = useCachedInitialData();\n *\n *   if (loading) return <Loading />;\n *\n *   return (\n *     <select>\n *       {agents.map(a => <option key={a.id}>{a.name}</option>)}\n *     </select>\n *   );\n * }\n * ```\n */\nexport function useCachedInitialData(): CachedInitialData {\n  const { workspaceId } = useVibeControls();\n\n  const {\n    data,\n    loading: queryLoading,\n    error,\n    refetch: apolloRefetch,\n  } = useVibeControlsInitialDataQuery({\n    variables: { workspaceId: workspaceId || '' } as VibeControlsInitialDataQueryVariables,\n    // cache-and-network: serve cached data immediately for fast paint, then\n    // re-issue the network request on every mount so cross-page mutations\n    // (e.g. createTarget on TargetsPage → user navigates to AgentsPage) show\n    // up without a manual reload. Previously cache-first held stale data\n    // until refetch() was explicitly invoked.\n    fetchPolicy: 'cache-and-network',\n    nextFetchPolicy: 'cache-first',\n    skip: !workspaceId,\n  });\n\n  const refetch = useCallback(() => {\n    void apolloRefetch();\n  }, [apolloRefetch]);\n\n  // If cache-only returns no data and isn't loading, it means the initial\n  // network fetch hasn't populated the cache yet — treat as loading to\n  // prevent counts flickering from 0 to actual values.\n  const loading = queryLoading || (!data && !error && !!workspaceId);\n\n  // Memoize the transformed data\n  const result = useMemo<CachedInitialData>(() => {\n    const rawAgents = data?.vibecontrolsAgents;\n    const agents = Array.isArray(rawAgents)\n      ? rawAgents.map((a: NonNullable<(typeof rawAgents)[number]>) => ({\n          id: a.id,\n          name: a.name,\n          hostname: a.hostname,\n          platform: a.platform,\n          isActive: a.isActive,\n          tunnelUrl: a.tunnelUrl,\n          tunnelStatus: a.tunnelStatus,\n          lastHeartbeat: a.lastHeartbeat,\n          version: a.version,\n          architecture: a.architecture,\n          createdAt: a.createdAt,\n          updatedAt: a.updatedAt,\n          metadata:\n            ((a as { metadata?: unknown }).metadata as Record<string, unknown> | null) ?? null,\n          ownerUserId: a.ownerUserId ?? null,\n          visibility: a.visibility ?? null,\n        }))\n      : [];\n\n    const rawVibes = data?.vibes?.items;\n    const vibes = Array.isArray(rawVibes)\n      ? rawVibes.map((v: NonNullable<(typeof rawVibes)[number]>) => ({\n          id: v.id,\n          name: v.name,\n          description: v.description,\n          path: v.path,\n          status: v.status,\n          // Multi-agent: zero, one, or many attached. ownerUserId carried\n          // through for the personal-vs-shared picker logic.\n          agents: Array.isArray(v.agents)\n            ? v.agents.map((a: NonNullable<(typeof v.agents)[number]>) => ({\n                id: a.id,\n                name: a.name,\n                isActive: a.isActive,\n                ownerUserId: a.ownerUserId ?? null,\n              }))\n            : [],\n          type: v.type,\n          tags: v.tags,\n          gitBranch: v.gitBranch,\n          createdAt: v.createdAt,\n          updatedAt: v.updatedAt,\n        }))\n      : [];\n\n    const rawSessions = data?.sessions?.items;\n    const sessions = Array.isArray(rawSessions)\n      ? rawSessions.map((s: NonNullable<(typeof rawSessions)[number]>) => ({\n          id: s.id,\n          name: s.name,\n          status: s.status,\n          agentId: s.agentId,\n          vibeId: s.vibeId,\n          type: s.type,\n          startedAt: s.startedAt,\n          metadata: (s.metadata as Record<string, unknown> | null) ?? null,\n          createdAt: s.createdAt,\n          updatedAt: s.updatedAt,\n        }))\n      : [];\n\n    // Targets were removed from VibeControlsInitialData to eliminate the 25s\n    // OPERATION_TIMEOUT on mount. Pages that need targets must issue their own query.\n    const targets: CachedInitialData['targets'] = [];\n\n    const rawNotes = data?.notes?.items;\n    const notes = Array.isArray(rawNotes)\n      ? rawNotes.map((n: NonNullable<(typeof rawNotes)[number]>) => ({\n          id: n.id,\n          title: n.title,\n          isPinned: n.isPinned,\n        }))\n      : [];\n\n    return {\n      data,\n      loading,\n      error: error as Error | undefined,\n      agents,\n      vibes,\n      sessions,\n      targets,\n      notes,\n      totals: {\n        agents: data?.vibecontrolsAgents?.length ?? 0,\n        vibes: data?.vibes?.total ?? 0,\n        sessions: data?.sessions?.total ?? 0,\n        targets: 0,\n        notes: data?.notes?.total ?? 0,\n      },\n      refetch,\n    };\n  }, [data, loading, error, refetch]);\n\n  return result;\n}\n\nexport default useCachedInitialData;\n"],"mappings":";;;;AA2JA,SAAgB,IAA0C;CACxD,IAAM,EAAE,mBAAgB,GAAiB,EAEnC,EACJ,SACA,SAAS,GACT,UACA,SAAS,MACP,EAAgC;EAClC,WAAW,EAAE,aAAa,KAAe,IAAI;EAM7C,aAAa;EACb,iBAAiB;EACjB,MAAM,CAAC;EACR,CAAC,EAEI,IAAU,QAAkB;AAC3B,KAAe;IACnB,CAAC,EAAc,CAAC,EAKb,IAAU,KAAiB,CAAC,KAAQ,CAAC,KAAS,CAAC,CAAC;AAqGtD,QAlGe,QAAiC;EAC9C,IAAM,IAAY,GAAM,oBAClB,IAAS,MAAM,QAAQ,EAAU,GACnC,EAAU,KAAK,OAAgD;GAC7D,IAAI,EAAE;GACN,MAAM,EAAE;GACR,UAAU,EAAE;GACZ,UAAU,EAAE;GACZ,UAAU,EAAE;GACZ,WAAW,EAAE;GACb,cAAc,EAAE;GAChB,eAAe,EAAE;GACjB,SAAS,EAAE;GACX,cAAc,EAAE;GAChB,WAAW,EAAE;GACb,WAAW,EAAE;GACb,UACI,EAA6B,YAA+C;GAChF,aAAa,EAAE,eAAe;GAC9B,YAAY,EAAE,cAAc;GAC7B,EAAE,GACH,EAAE,EAEA,IAAW,GAAM,OAAO,OACxB,IAAQ,MAAM,QAAQ,EAAS,GACjC,EAAS,KAAK,OAA+C;GAC3D,IAAI,EAAE;GACN,MAAM,EAAE;GACR,aAAa,EAAE;GACf,MAAM,EAAE;GACR,QAAQ,EAAE;GAGV,QAAQ,MAAM,QAAQ,EAAE,OAAO,GAC3B,EAAE,OAAO,KAAK,OAA+C;IAC3D,IAAI,EAAE;IACN,MAAM,EAAE;IACR,UAAU,EAAE;IACZ,aAAa,EAAE,eAAe;IAC/B,EAAE,GACH,EAAE;GACN,MAAM,EAAE;GACR,MAAM,EAAE;GACR,WAAW,EAAE;GACb,WAAW,EAAE;GACb,WAAW,EAAE;GACd,EAAE,GACH,EAAE,EAEA,IAAc,GAAM,UAAU,OAC9B,IAAW,MAAM,QAAQ,EAAY,GACvC,EAAY,KAAK,OAAkD;GACjE,IAAI,EAAE;GACN,MAAM,EAAE;GACR,QAAQ,EAAE;GACV,SAAS,EAAE;GACX,QAAQ,EAAE;GACV,MAAM,EAAE;GACR,WAAW,EAAE;GACb,UAAW,EAAE,YAA+C;GAC5D,WAAW,EAAE;GACb,WAAW,EAAE;GACd,EAAE,GACH,EAAE,EAIA,IAAwC,EAAE,EAE1C,IAAW,GAAM,OAAO;AAS9B,SAAO;GACL;GACA;GACO;GACP;GACA;GACA;GACA;GACA,OAhBY,MAAM,QAAQ,EAAS,GACjC,EAAS,KAAK,OAA+C;IAC3D,IAAI,EAAE;IACN,OAAO,EAAE;IACT,UAAU,EAAE;IACb,EAAE,GACH,EAAE;GAWJ,QAAQ;IACN,QAAQ,GAAM,oBAAoB,UAAU;IAC5C,OAAO,GAAM,OAAO,SAAS;IAC7B,UAAU,GAAM,UAAU,SAAS;IACnC,SAAS;IACT,OAAO,GAAM,OAAO,SAAS;IAC9B;GACD;GACD;IACA;EAAC;EAAM;EAAS;EAAO;EAAQ,CAAC"}

package/dist/hooks/useDraftEntityTags.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useDraftEntityTags.js","names":[],"sources":["../../src/hooks/useDraftEntityTags.ts"],"sourcesContent":["import { useState, useCallback } from 'react';\n\nimport { useTagEntity } from './useEntityTags';\n\nexport type VibecontrolsEntityType =\n  | 'VIBECONTROLS_NOTE'\n  | 'VIBECONTROLS_VIBE'\n  | 'VIBECONTROLS_SESSION'\n  | 'VIBECONTROLS_AGENT'\n  | 'VIBECONTROLS_TARGET'\n  | 'VIBECONTROLS_VIBEDECK'\n  | 'VIBECONTROLS_DOCSSITE'\n  | 'VIBECONTROLS_DOCSPAGE'\n  | 'VIBECONTROLS_TUNNEL'\n  | 'VIBECONTROLS_TUNNELDOMAIN'\n  | 'VIBECONTROLS_CATALOG'\n  | 'VIBECONTROLS_COMPONENT'\n  | 'VIBECONTROLS_TEMPLATE'\n  | 'VIBECONTROLS_WEBHOOK'\n  | 'VIBECONTROLS_SCORECARD'\n  | 'VIBECONTROLS_GITOPSPROVIDER'\n  | 'VIBECONTROLS_CONFIGURATION'\n  | 'VIBECONTROLS_AIPROMPT'\n  | 'VIBECONTROLS_UISESSION'\n  | 'VIBECONTROLS_ACTION';\n\nexport function useDraftEntityTags(entityType: VibecontrolsEntityType) {\n  const [draftTagIds, setDraftTagIds] = useState<string[]>([]);\n  const [tagEntity] = useTagEntity();\n\n  const flushTags = useCallback(\n    async (entityId: string): Promise<void> => {\n      if (!entityId || draftTagIds.length === 0) return;\n      try {\n        await Promise.allSettled(\n          draftTagIds.map((tagId) =>\n            tagEntity({ variables: { input: { entityType, entityId, tagId } } })\n          )\n        );\n      } finally {\n        setDraftTagIds([]);\n      }\n    },\n    [draftTagIds, entityType, tagEntity]\n  );\n\n  return { draftTagIds, setDraftTagIds, flushTags };\n}\n"],"mappings":";;;AA0BA,SAAgB,EAAmB,GAAoC;CACrE,IAAM,CAAC,GAAa,KAAkB,EAAmB,EAAE,CAAC,EACtD,CAAC,KAAa,GAAc;AAkBlC,QAAO;EAAE;EAAa;EAAgB,WAhBpB,EAChB,OAAO,MAAoC;AACrC,UAAC,KAAY,EAAY,WAAW,GACxC,KAAI;AACF,UAAM,QAAQ,WACZ,EAAY,KAAK,MACf,EAAU,EAAE,WAAW,EAAE,OAAO;KAAE;KAAY;KAAU;KAAO,EAAE,EAAE,CAAC,CACrE,CACF;aACO;AACR,MAAe,EAAE,CAAC;;KAGtB;GAAC;GAAa;GAAY;GAAU,CACrC;EAEgD"}

package/dist/hooks/useEntityTags.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useEntityTags.js","names":[],"sources":["../../src/hooks/useEntityTags.ts"],"sourcesContent":["import {\n  useEntityTagPickerGetEntityTagsQuery,\n  useEntityTagPickerAvailableTagsQuery,\n  useEntityTagPickerSearchTagsLazyQuery,\n  useEntityTagPickerTagEntityMutation,\n  useEntityTagPickerUntagEntityMutation,\n  useEntityTagPickerCreateTagMutation,\n  type EntityTagPickerGetEntityTagsQuery as GetEntityTagsData,\n  type EntityTagPickerAvailableTagsQuery as AvailableTagsData,\n  type EntityTagPickerSearchTagsQuery as SearchTagsData,\n  type EntityTagPickerTagEntityMutation as TagEntityData,\n  type EntityTagPickerUntagEntityMutation as UntagEntityData,\n} from '@/generated/wspace-operations';\n\nexport interface AvailableTag {\n  id: string;\n  key: string;\n  label: string;\n  color: string | null;\n}\n\nexport interface EntityTagInfo {\n  id: string;\n  key?: string | null;\n  label?: string | null;\n  color?: string | null;\n}\n\nexport interface EntityTagAssignment {\n  id: string;\n  tagId: string;\n  tagInfo?: EntityTagInfo | null;\n  tag?: { id: string } | null;\n  entityType: string;\n  entityId: string;\n  source: string;\n  assignedBy: string | null;\n  assignedAt: string | null;\n}\n\ninterface TagEntityVars {\n  input: { entityType: string; entityId: string; tagId: string };\n}\n\ninterface UntagEntityVars {\n  input: { entityType: string; entityId: string; tagId: string };\n}\n\nexport function useGetEntityTags(entityType: string, entityId: string) {\n  return useEntityTagPickerGetEntityTagsQuery({\n    variables: { input: { entityType, entityId } },\n    skip: !entityId,\n    fetchPolicy: 'cache-and-network',\n  });\n}\n\nexport function useAvailableTags(limit: number, options: { skip?: boolean } = {}) {\n  return useEntityTagPickerAvailableTagsQuery({\n    variables: { limit },\n    skip: options.skip ?? false,\n  });\n}\n\nexport function useSearchTags() {\n  return useEntityTagPickerSearchTagsLazyQuery();\n}\n\nexport function useTagEntity() {\n  return useEntityTagPickerTagEntityMutation();\n}\n\nexport function useUntagEntity() {\n  return useEntityTagPickerUntagEntityMutation();\n}\n\n/**\n * Create a new tag inline. `vocabularyId` is intentionally omitted — the\n * backend resolves/creates a default workspace VibeControls vocabulary, so\n * callers only need a label (and optional color).\n */\nexport function useCreateVibecontrolsTag() {\n  return useEntityTagPickerCreateTagMutation();\n}\n"],"mappings":";;AAgDA,SAAgB,EAAiB,GAAoB,GAAkB;AACrE,QAAO,EAAqC;EAC1C,WAAW,EAAE,OAAO;GAAE;GAAY;GAAU,EAAE;EAC9C,MAAM,CAAC;EACP,aAAa;EACd,CAAC;;AAGJ,SAAgB,EAAiB,GAAe,IAA8B,EAAE,EAAE;AAChF,QAAO,EAAqC;EAC1C,WAAW,EAAE,UAAO;EACpB,MAAM,EAAQ,QAAQ;EACvB,CAAC;;AAGJ,SAAgB,IAAgB;AAC9B,QAAO,GAAuC;;AAGhD,SAAgB,IAAe;AAC7B,QAAO,GAAqC;;AAG9C,SAAgB,IAAiB;AAC/B,QAAO,GAAuC;;AAQhD,SAAgB,IAA2B;AACzC,QAAO,GAAqC"}

package/dist/hooks/useGitops.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useGitops.js","names":[],"sources":["../../src/hooks/useGitops.ts"],"sourcesContent":["/**\n * React Query hooks over the GitOps agent REST API.\n *\n * F4 Wave C: hooks now route through the svc-side `agentGitopsProxy` /\n * `agentGitopsMutate` GraphQL fields via Apollo Client. The browser no\n * longer holds the agent API key — svc owns it.\n *\n * All cache keys include the agent identity (workspace + agentId + profile)\n * so two simultaneously-active vibes against different agents stay isolated.\n */\nimport { type ApolloClient } from '@apollo/client';\nimport { useApolloClient } from '@apollo/client/react';\nimport {\n  useMutation,\n  useQuery,\n  useQueryClient,\n  type UseMutationResult,\n  type UseQueryOptions,\n  type UseQueryResult,\n} from '@tanstack/react-query';\n\nimport { gitopsApi, GitopsApiError, type GitopsApiOpts } from '@/services/gitopsApi';\nimport type {\n  AuthInput,\n  AuthValidation,\n  Contributor,\n  HealthSnapshot,\n  IssueSummary,\n  NormalisedRepo,\n  PipelineAnalytics,\n  PipelineRun,\n  ProviderName,\n  ProviderSnapshot,\n  PullRequest,\n  PullRequestAnalytics,\n  RepoFqn,\n  RepoPage,\n  SecurityAlert,\n} from '@/components/gitops/types';\n\nexport interface UseGitopsContext {\n  /** Required: agent profile name (vibe metadata). */\n  profile: string;\n  /** Workspace id — cache scope. */\n  workspaceId: string;\n  /** Agent id — cache scope + svc proxy target. */\n  agentId: string;\n}\n\nfunction ensureOpts(ctx: UseGitopsContext, apolloClient: ApolloClient): GitopsApiOpts | null {\n  if (!ctx.agentId) return null;\n  return { agentId: ctx.agentId, profile: ctx.profile, apolloClient };\n}\n\nfunction key(ctx: UseGitopsContext, ...rest: unknown[]) {\n  return ['gitops', ctx.workspaceId, ctx.agentId, ctx.profile, ...rest];\n}\n\n// ── meta ───────────────────────────────────────────────────────────────\n\nexport function useGitopsProviders(\n  ctx: UseGitopsContext,\n  options?: Omit<UseQueryOptions<ProviderSnapshot[]>, 'queryKey' | 'queryFn'>\n): UseQueryResult<ProviderSnapshot[]> {\n  const apollo = useApolloClient();\n  return useQuery({\n    queryKey: key(ctx, 'providers'),\n    enabled: !!ensureOpts(ctx, apollo),\n    queryFn: async () => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts) return [];\n      const res = await gitopsApi.listProviders(opts);\n      return res.providers;\n    },\n    ...options,\n  });\n}\n\nexport function useGitopsActiveProvider(ctx: UseGitopsContext): UseQueryResult<{ name?: string }> {\n  const apollo = useApolloClient();\n  return useQuery({\n    queryKey: key(ctx, 'active'),\n    enabled: !!ensureOpts(ctx, apollo),\n    queryFn: async () => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts) return {};\n      return gitopsApi.getActive(opts);\n    },\n  });\n}\n\nexport function useGitopsSetActive(\n  ctx: UseGitopsContext\n): UseMutationResult<{ success: boolean }, GitopsApiError, ProviderName> {\n  const apollo = useApolloClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: async (provider: ProviderName) => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts) throw new GitopsApiError('INVALID', 0, 'no agent opts');\n      return gitopsApi.setActive(opts, provider);\n    },\n    onSuccess: () => {\n      void qc.invalidateQueries({ queryKey: key(ctx) });\n    },\n  });\n}\n\n// ── auth ───────────────────────────────────────────────────────────────\n\nexport function useGitopsAuth(\n  ctx: UseGitopsContext\n): UseMutationResult<AuthValidation, GitopsApiError, { provider: ProviderName; input: AuthInput }> {\n  const apollo = useApolloClient();\n  const qc = useQueryClient();\n  return useMutation({\n    mutationFn: async ({ provider, input }) => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts) throw new GitopsApiError('INVALID', 0, 'no agent opts');\n      return gitopsApi.saveAuth(opts, provider, input);\n    },\n    onSuccess: () => {\n      void qc.invalidateQueries({ queryKey: key(ctx) });\n    },\n  });\n}\n\nexport function useGitopsHealth(\n  ctx: UseGitopsContext,\n  provider: ProviderName | null\n): UseQueryResult<HealthSnapshot> {\n  const apollo = useApolloClient();\n  return useQuery({\n    queryKey: key(ctx, 'health', provider),\n    enabled: !!ensureOpts(ctx, apollo) && !!provider,\n    queryFn: async () => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts || !provider) throw new GitopsApiError('INVALID', 0, 'missing');\n      return gitopsApi.health(opts, provider);\n    },\n  });\n}\n\n// ── repos ──────────────────────────────────────────────────────────────\n\nexport function useGitopsRepos(\n  ctx: UseGitopsContext,\n  provider: ProviderName | null,\n  params: { org?: string; limit?: number } = {}\n): UseQueryResult<RepoPage> {\n  const apollo = useApolloClient();\n  return useQuery({\n    queryKey: key(ctx, 'repos', provider, params.org, params.limit),\n    enabled: !!ensureOpts(ctx, apollo) && !!provider,\n    queryFn: async () => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts || !provider) throw new GitopsApiError('INVALID', 0, 'missing');\n      return gitopsApi.listRepos(opts, provider, params);\n    },\n  });\n}\n\nexport function useGitopsRepo(\n  ctx: UseGitopsContext,\n  provider: ProviderName | null,\n  fqn: RepoFqn | null\n): UseQueryResult<NormalisedRepo> {\n  const apollo = useApolloClient();\n  return useQuery({\n    queryKey: key(ctx, 'repo', provider, fqn),\n    enabled: !!ensureOpts(ctx, apollo) && !!provider && !!fqn,\n    queryFn: async () => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts || !provider || !fqn) throw new GitopsApiError('INVALID', 0, 'missing');\n      return gitopsApi.getRepo(opts, provider, fqn);\n    },\n  });\n}\n\nexport function useGitopsLanguages(\n  ctx: UseGitopsContext,\n  provider: ProviderName | null,\n  fqn: RepoFqn | null\n): UseQueryResult<Record<string, number>> {\n  const apollo = useApolloClient();\n  return useQuery({\n    queryKey: key(ctx, 'langs', provider, fqn),\n    enabled: !!ensureOpts(ctx, apollo) && !!provider && !!fqn,\n    queryFn: async () => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts || !provider || !fqn) throw new GitopsApiError('INVALID', 0, 'missing');\n      return gitopsApi.listLanguages(opts, provider, fqn);\n    },\n  });\n}\n\nexport function useGitopsContributors(\n  ctx: UseGitopsContext,\n  provider: ProviderName | null,\n  fqn: RepoFqn | null,\n  limit = 20\n): UseQueryResult<Contributor[]> {\n  const apollo = useApolloClient();\n  return useQuery({\n    queryKey: key(ctx, 'contrib', provider, fqn, limit),\n    enabled: !!ensureOpts(ctx, apollo) && !!provider && !!fqn,\n    queryFn: async () => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts || !provider || !fqn) throw new GitopsApiError('INVALID', 0, 'missing');\n      return gitopsApi.listContributors(opts, provider, fqn, limit);\n    },\n  });\n}\n\n// ── PRs ────────────────────────────────────────────────────────────────\n\nexport function useGitopsPullRequests(\n  ctx: UseGitopsContext,\n  provider: ProviderName | null,\n  fqn: RepoFqn | null,\n  params: { state?: 'open' | 'closed' | 'all'; limit?: number } = {}\n): UseQueryResult<PullRequest[]> {\n  const apollo = useApolloClient();\n  return useQuery({\n    queryKey: key(ctx, 'prs', provider, fqn, params.state, params.limit),\n    enabled: !!ensureOpts(ctx, apollo) && !!provider && !!fqn,\n    queryFn: async () => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts || !provider || !fqn) throw new GitopsApiError('INVALID', 0, 'missing');\n      return gitopsApi.listPullRequests(opts, provider, fqn, params);\n    },\n  });\n}\n\nexport function useGitopsPrAnalytics(\n  ctx: UseGitopsContext,\n  provider: ProviderName | null,\n  fqn: RepoFqn | null\n): UseQueryResult<PullRequestAnalytics> {\n  const apollo = useApolloClient();\n  return useQuery({\n    queryKey: key(ctx, 'pr-analytics', provider, fqn),\n    enabled: !!ensureOpts(ctx, apollo) && !!provider && !!fqn,\n    queryFn: async () => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts || !provider || !fqn) throw new GitopsApiError('INVALID', 0, 'missing');\n      return gitopsApi.prAnalytics(opts, provider, fqn);\n    },\n  });\n}\n\n// ── issues ─────────────────────────────────────────────────────────────\n\nexport function useGitopsIssues(\n  ctx: UseGitopsContext,\n  provider: ProviderName | null,\n  fqn: RepoFqn | null,\n  params: { state?: 'open' | 'closed'; limit?: number } = {}\n): UseQueryResult<IssueSummary[]> {\n  const apollo = useApolloClient();\n  return useQuery({\n    queryKey: key(ctx, 'issues', provider, fqn, params.state, params.limit),\n    enabled: !!ensureOpts(ctx, apollo) && !!provider && !!fqn,\n    queryFn: async () => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts || !provider || !fqn) throw new GitopsApiError('INVALID', 0, 'missing');\n      return gitopsApi.listIssues(opts, provider, fqn, params);\n    },\n  });\n}\n\n// ── CI ─────────────────────────────────────────────────────────────────\n\nexport function useGitopsRuns(\n  ctx: UseGitopsContext,\n  provider: ProviderName | null,\n  fqn: RepoFqn | null,\n  params: { limit?: number; branch?: string } = {}\n): UseQueryResult<PipelineRun[]> {\n  const apollo = useApolloClient();\n  return useQuery({\n    queryKey: key(ctx, 'runs', provider, fqn, params.limit, params.branch),\n    enabled: !!ensureOpts(ctx, apollo) && !!provider && !!fqn,\n    queryFn: async () => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts || !provider || !fqn) throw new GitopsApiError('INVALID', 0, 'missing');\n      return gitopsApi.listRuns(opts, provider, fqn, params);\n    },\n  });\n}\n\nexport function useGitopsPipelineAnalytics(\n  ctx: UseGitopsContext,\n  provider: ProviderName | null,\n  fqn: RepoFqn | null\n): UseQueryResult<PipelineAnalytics> {\n  const apollo = useApolloClient();\n  return useQuery({\n    queryKey: key(ctx, 'pipeline-analytics', provider, fqn),\n    enabled: !!ensureOpts(ctx, apollo) && !!provider && !!fqn,\n    queryFn: async () => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts || !provider || !fqn) throw new GitopsApiError('INVALID', 0, 'missing');\n      return gitopsApi.pipelineAnalytics(opts, provider, fqn);\n    },\n  });\n}\n\n// ── security ───────────────────────────────────────────────────────────\n\nexport function useGitopsSecurityAlerts(\n  ctx: UseGitopsContext,\n  provider: ProviderName | null,\n  fqn: RepoFqn | null,\n  kind?: SecurityAlert['type']\n): UseQueryResult<SecurityAlert[]> {\n  const apollo = useApolloClient();\n  return useQuery({\n    queryKey: key(ctx, 'security', provider, fqn, kind),\n    enabled: !!ensureOpts(ctx, apollo) && !!provider && !!fqn,\n    queryFn: async () => {\n      const opts = ensureOpts(ctx, apollo);\n      if (!opts || !provider || !fqn) throw new GitopsApiError('INVALID', 0, 'missing');\n      return gitopsApi.listSecurityAlerts(opts, provider, fqn, kind);\n    },\n  });\n}\n"],"mappings":"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"}

package/dist/hooks/useInitialDataLoader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useInitialDataLoader.js","names":[],"sources":["../../src/hooks/useInitialDataLoader.ts"],"sourcesContent":["/**\n * useInitialDataLoader\n *\n * Hook that prefetches all commonly-used data in a single GraphQL query.\n * This runs once when the VibeControls microfrontend mounts and workspaceId is available.\n * The data is stored in Apollo's normalized cache, making it available to all\n * components via useQuery with cache-only fetch policy.\n *\n * This eliminates the need for multiple components to independently fetch\n * agents, vibes, sessions, targets, and notes - reducing GraphQL calls from\n * 10+ per page to just 1 on initial load.\n */\n\nimport { useCallback } from 'react';\nimport { useVibeControls } from '../providers/VibeControlsProvider';\nimport {\n  useVibeControlsInitialDataQuery,\n  type VibeControlsInitialDataQuery,\n  type VibeControlsInitialDataQueryVariables,\n} from '../generated/wspace-operations';\n\n/**\n * Options for useInitialDataLoader\n */\ninterface UseInitialDataLoaderOptions {\n  /** Workspace ID to use when the hook is called outside provider context */\n  workspaceId?: string | null;\n  /** Fetch policy for the initial query */\n  fetchPolicy?: 'cache-first' | 'network-only' | 'cache-only';\n}\n\n/**\n * Return type for useInitialDataLoader\n */\ninterface UseInitialDataLoaderResult {\n  /** Whether the initial data is still loading */\n  loading: boolean;\n  /** Any error that occurred during the initial fetch */\n  error?: Error;\n  /** Refetch function to manually refresh all initial data */\n  refetch: () => void;\n  /** The loaded data (raw from Apollo cache) */\n  data?: VibeControlsInitialDataQuery;\n}\n\n/**\n * Hook that prefetches all initial data for the VibeControls microfrontend.\n *\n * Usage:\n * ```tsx\n * function MyComponent() {\n *   const { loading, error, refetch } = useInitialDataLoader();\n *\n *   if (loading) return <Loading />;\n *   if (error) return <Error error={error} />;\n *\n *   // Data is available in Apollo cache for other components\n *   return <div>Loaded!</div>;\n * }\n * ```\n */\nexport function useInitialDataLoader(\n  options: UseInitialDataLoaderOptions = {}\n): UseInitialDataLoaderResult {\n  const { workspaceId: workspaceIdOverride, fetchPolicy = 'cache-first' } = options;\n  // Intentionally passes null when no override is provided — this hook runs inside\n  // VibeControlsProvider before useVibeControls() context is available, so it cannot\n  // fall back to context.workspaceId. The null causes skip:true on the query, which\n  // is the correct behavior until workspaceId is explicitly provided.\n  const workspaceId = workspaceIdOverride ?? null;\n\n  // Main query to fetch all initial data\n  const { loading, error, data, refetch } = useVibeControlsInitialDataQuery({\n    variables: { workspaceId: workspaceId || '' } as VibeControlsInitialDataQueryVariables,\n    fetchPolicy,\n    skip: !workspaceId,\n    notifyOnNetworkStatusChange: true,\n    errorPolicy: 'all',\n  });\n\n  const handleRefetch = useCallback(() => {\n    void refetch();\n  }, [refetch]);\n\n  return {\n    loading,\n    error: error as Error | undefined,\n    data,\n    refetch: handleRefetch,\n  };\n}\n\n/**\n * Simplified hook for components that just need to know if initial data is loaded.\n * Useful for components that will read from cache using useQuery with cache-only.\n */\nexport function useIsInitialDataLoaded(): boolean {\n  const { workspaceId } = useVibeControls();\n\n  const { loading } = useVibeControlsInitialDataQuery({\n    variables: { workspaceId: workspaceId || '' } as VibeControlsInitialDataQueryVariables,\n    fetchPolicy: 'cache-only',\n    skip: !workspaceId,\n  });\n\n  return !loading;\n}\n\nexport default useInitialDataLoader;\n"],"mappings":";;;;AA6DA,SAAgB,EACd,IAAuC,EAAE,EACb;CAC5B,IAAM,EAAE,aAAa,GAAqB,iBAAc,kBAAkB,GAKpE,IAAc,KAAuB,MAGrC,EAAE,YAAS,UAAO,SAAM,eAAY,EAAgC;EACxE,WAAW,EAAE,aAAa,KAAe,IAAI;EAC7C;EACA,MAAM,CAAC;EACP,6BAA6B;EAC7B,aAAa;EACd,CAAC;AAMF,QAAO;EACL;EACO;EACP;EACA,SARoB,QAAkB;AACjC,MAAS;KACb,CAAC,EAAQ,CAAC;EAOZ"}

package/dist/hooks/useOfferedAssistantMode.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useOfferedAssistantMode.js","names":[],"sources":["../../src/hooks/useOfferedAssistantMode.ts"],"sourcesContent":["/**\n * useOfferedAssistantMode\n *\n * Keeps the SHARED assistant store's mode on one VibeControls offers. A stored\n * mode that no longer exists (the retired `general`, from before Ask / Take\n * action / Build) is moved to Ask the moment it is seen: at mount, after a\n * profile rehydrates the store, and when an old conversation is reopened\n * (`setActiveConversation` copies that conversation's mode into the store).\n *\n * ★★ Why the product does this when fe-libs already resets unknown modes.\n * fe-libs' reset in `AssistantChatArea` runs only AFTER the `myRoles` check\n * settles, because the same effect also resets admin-only modes and must not\n * throw an admin out of Take action while the check is in flight. Until then\n * the store still holds `general`, and a send in that window starts a turn in\n * it. Get help makes the window real: it queues a prompt that the chat area\n * sends from its MOUNT effect, before any role response can arrive. This hook\n * closes the window for modes that do not exist, and leaves the admin question\n * to fe-libs.\n *\n * ★ A LAYOUT effect, deliberately. The shared panel is a child of the component\n * calling this, and React runs every layout effect before any passive effect,\n * so the store is corrected before the chat area's mount effect reads it. A\n * plain `useEffect` here runs AFTER the child's, which is the bug.\n * `useOfferedAssistantMode.test.tsx` pins that order.\n *\n * ★ It subscribes to the store rather than selecting from it, so the wrapper\n * does not re-render the whole panel on every mode change just to check it.\n */\nimport { useLayoutEffect } from 'react';\n/**\n * ★ The SHARED store, from the DEEP subpath. The panel VibeControls mounts reads\n * its mode from here, and it is the only assistant store there is. The barrel\n * would pull react-markdown in too.\n */\nimport { useAssistantStore } from '@burdenoff/fe-libs/shared/assistant/store';\nimport { resolveOfferedMode } from '@/config/assistantUsecases';\n\nfunction landOnOfferedMode(mode: string): void {\n  const offered = resolveOfferedMode(mode);\n  if (offered !== mode) useAssistantStore.getState().setMode(offered);\n}\n\nexport function useOfferedAssistantMode(): void {\n  useLayoutEffect(() => {\n    landOnOfferedMode(useAssistantStore.getState().mode);\n    return useAssistantStore.subscribe((state, previous) => {\n      if (state.mode !== previous.mode) landOnOfferedMode(state.mode);\n    });\n  }, []);\n}\n"],"mappings":";;;;AAqCA,SAAS,EAAkB,GAAoB;CAC7C,IAAM,IAAU,EAAmB,EAAK;AACxC,CAAI,MAAY,KAAM,EAAkB,UAAU,CAAC,QAAQ,EAAQ;;AAGrE,SAAgB,IAAgC;AAC9C,UACE,EAAkB,EAAkB,UAAU,CAAC,KAAK,EAC7C,EAAkB,WAAW,GAAO,MAAa;AACtD,EAAI,EAAM,SAAS,EAAS,QAAM,EAAkB,EAAM,KAAK;GAC/D,GACD,EAAE,CAAC"}

package/dist/hooks/useOpenAssistantHelp.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useOpenAssistantHelp.js","names":[],"sources":["../../src/hooks/useOpenAssistantHelp.ts"],"sourcesContent":["/**\n * useOpenAssistantHelp\n *\n * Returns a callback that opens the AI assistant panel (via the shell's\n * global `vc:toggle-ai-assistant` event) and queues a prompt that the chat\n * area will auto-send on next render. It deliberately leaves the MODE alone —\n * see the note in the callback.\n *\n * Used by the shared `GetHelpButton` that appears next to \"Add X\" buttons\n * in empty states so users can ask the assistant to explain concepts like\n * \"What is a Target?\" without any typing.\n */\nimport { useCallback } from 'react';\n/**\n * ★★ The SHARED store, the only assistant store there is.\n *\n * The panel this product mounts is fe-libs' `AIAssistantPanel`, and its chat\n * area consumes `pendingPrompt` from `fe-libs/shared/assistant/store`. This hook\n * used to queue into the pre-migration fork's own store, persisted and read by\n * nobody, so every Get Help button opened an empty panel. That store is deleted.\n *\n * ★ Imported from the DEEP subpath, not the barrel. The barrel star-exports the\n * panel components and pulls react-markdown in with them.\n */\nimport { useAssistantStore } from '@burdenoff/fe-libs/shared/assistant/store';\n\nexport function useOpenAssistantHelp() {\n  return useCallback((prompt: string) => {\n    // ★ Do NOT change the mode.\n    //\n    // This used to force `general`. That call went to the fork's store, so it\n    // never reached the shared panel; moved across with the queue it would take\n    // effect for the first time. The shared store PERSISTS `mode`, so one press\n    // of a Get Help button would silently move the user out of the mode they\n    // chose — Ask, Take action, Build — for every later turn too.\n    //\n    // Whatever mode the user is in already answers \"what is this page for\".\n    //\n    // Open FIRST, queue on the next macrotask. This is a contract, pinned by the\n    // test \"the prompt is not queued until after the open event\", not a race\n    // guard. The chat area picks the prompt up in either order: its\n    // `pendingPrompt` subscriber if it is mounted, its mount-time\n    // `consumePendingPrompt()` if it mounts later. `pendingPrompt` is not\n    // persisted, so rehydration cannot clear it.\n    //\n    // The ordering matters only for a shell that toggles and ignores `open`.\n    // Pressed with the panel open, that shell closes it; a prompt queued in the\n    // same tick would reach the still-mounted chat area and start a turn in a\n    // panel about to unmount. Queued a macrotask later, it waits in the store\n    // and is sent on the next open.\n    //\n    // `open: true` OPENS; it does not toggle. vibecontrols-app's overlay honours\n    // it from BOFF-7292, so pressed with the panel already open it stays open.\n    window.dispatchEvent(\n      new CustomEvent('vc:toggle-ai-assistant', {\n        detail: { open: true },\n      })\n    );\n    setTimeout(() => {\n      useAssistantStore.getState().submitPrompt(prompt);\n    }, 0);\n  }, []);\n}\n"],"mappings":";;;AA0BA,SAAgB,IAAuB;AACrC,QAAO,GAAa,MAAmB;AA+BrC,EALA,OAAO,cACL,IAAI,YAAY,0BAA0B,EACxC,QAAQ,EAAE,MAAM,IAAM,EACvB,CAAC,CACH,EACD,iBAAiB;AACf,KAAkB,UAAU,CAAC,aAAa,EAAO;KAChD,EAAE;IACJ,EAAE,CAAC"}

package/dist/hooks/usePluginAvailability.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"usePluginAvailability.js","names":[],"sources":["../../src/hooks/usePluginAvailability.ts"],"sourcesContent":["/**\n * usePluginAvailability — query + install helpers for vibecontrols-agent plugins.\n *\n * Wraps the existing backend-proxied GraphQL ops (AgentPlugins query +\n * InstallAgentPlugin mutation) and exposes a small state surface that\n * gating components can render against.\n *\n * Live updates: subscribes to `vibecontrolsAgentPluginStream` so the\n * installed map reflects out-of-band installs (CLI, other tabs,\n * agent-side changes) without per-tab polling. The initial AgentPlugins\n * query is still used for first paint so the gate can render before\n * the WebSocket completes its handshake.\n */\n\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react';\nimport { useApolloClient } from '@apollo/client/react';\nimport {\n  AgentPluginsDocument,\n  useInstallAgentPluginMutation,\n  useVibecontrolsAgentPluginStreamSubscription,\n  type AgentPluginsQuery,\n} from '@/generated/wspace-operations';\nimport { isQuotaExhaustedError, markQuotaHandledLocally } from '@/utils/quotaUtils';\n\n/**\n * Classifies transient \"the agent itself isn't ready\" errors so the UI can\n * render a dedicated waiting state instead of an install CTA. These errors\n * are not the user's to fix via an install click — they resolve on their\n * own (or require Agents-page intervention).\n */\nfunction classifyAgentStateError(message: string | null | undefined): boolean {\n  if (!message) return false;\n  const m = message.toLowerCase();\n  return (\n    m.includes('agent not yet configured') ||\n    m.includes('awaiting-config') ||\n    m.includes('initializing') ||\n    m.includes('agent unreachable') ||\n    m.includes('agent returned 503') ||\n    m.includes('http 503') ||\n    m.includes('plugin routes are unavailable') ||\n    m.includes('econnrefused') ||\n    m.includes('rate_limited') ||\n    m.includes('rate limited') ||\n    m.includes('operation timeout') ||\n    m.includes('operation_timeout') ||\n    // Bun's fetch surfaces these human-friendly strings when the agent\n    // socket isn't accepting connections. Without this branch, the raw\n    // text would leak into the install card as the error chip.\n    m.includes('typo in the url') ||\n    m.includes('unable to connect') ||\n    m.includes('failed to open socket') ||\n    m.includes('failedtoopensocket') ||\n    m.includes('fetch failed') ||\n    m.includes('enotfound') ||\n    m.includes('getaddrinfo')\n    // Note: \"operation was aborted\" is deliberately NOT classified as an\n    // agent-state error. Apollo aborts previous in-flight queries when\n    // the same lazy query is re-fired (common in React Strict Mode\n    // double-mount). Those aborts are transient and not about agent\n    // state; the follow-up fetch succeeds normally.\n  );\n}\n\n/**\n * Translate raw error strings (especially Bun fetch's human-friendly but\n * jargon-y errors) into a short, user-safe message. Used right before we\n * stash anything into the surfaced `error` field — guarantees we never\n * render \"Was there a typo in the url or port?\" or similar into the DOM.\n */\nfunction sanitizeAgentStateError(raw: string): string {\n  const m = raw.toLowerCase();\n  if (\n    m.includes('typo in the url') ||\n    m.includes('unable to connect') ||\n    m.includes('failed to open socket') ||\n    m.includes('failedtoopensocket') ||\n    m.includes('econnrefused') ||\n    m.includes('enotfound') ||\n    m.includes('getaddrinfo') ||\n    m.includes('fetch failed') ||\n    m.includes('agent unreachable')\n  ) {\n    return 'Agent unreachable. Make sure the vibecontrols-agent is running locally.';\n  }\n  if (m.includes('agent not yet configured') || m.includes('awaiting-config')) {\n    return 'Agent is waiting for configuration. Finish setup in the Agents page.';\n  }\n  if (m.includes('initializing')) {\n    return 'Agent is starting up. Try again in a moment.';\n  }\n  if (m.includes('http 503') || m.includes('agent returned 503')) {\n    return 'Agent service unavailable. It may be restarting.';\n  }\n  return raw.length > 200 ? `${raw.slice(0, 200)}…` : raw;\n}\n\nexport interface UsePluginAvailabilityResult {\n  loading: boolean;\n  /**\n   * True while the very first fetch is in flight (or before it has begun).\n   * Consumers should render a loading spinner instead of the install CTA in\n   * this state so users don't see a flash of \"plugin required / Install\"\n   * followed by a flash of the real content.\n   */\n  initialLoading: boolean;\n  installed: Record<string, boolean>;\n  missing: string[];\n  anyInstalled: boolean;\n  allInstalled: boolean;\n  installing: string | null;\n  install: (packageName: string) => Promise<boolean>;\n  error: string | null;\n  /** True when `error` points to the agent itself not being ready. */\n  errorIsAgentState: boolean;\n  quotaExhausted: boolean;\n  clearQuotaExhausted: () => void;\n  refetch: () => Promise<void>;\n}\n\nexport function usePluginAvailability(\n  packages: readonly string[],\n  agentId: string | null\n): UsePluginAvailabilityResult {\n  const apollo = useApolloClient();\n  const [installPluginMutation] = useInstallAgentPluginMutation();\n\n  // Read cached data synchronously so the first render already has the\n  // installed map populated when another consumer has primed the cache.\n  const cachedInstalledSet = useMemo(() => {\n    if (!agentId) return null;\n    try {\n      const cached = apollo.readQuery<AgentPluginsQuery>({\n        query: AgentPluginsDocument,\n        variables: { agentId },\n      });\n      const installedList = cached?.agentPlugins?.installed ?? null;\n      if (!installedList) return null;\n      return new Set(installedList.map((p: { packageName: string }) => p.packageName));\n    } catch {\n      return null;\n    }\n  }, [apollo, agentId]);\n\n  const [loading, setLoading] = useState(false);\n  const [hasFetchedOnce, setHasFetchedOnce] = useState(() => cachedInstalledSet !== null);\n  const [installedMap, setInstalledMap] = useState<Record<string, boolean>>(() => {\n    const next: Record<string, boolean> = {};\n    if (cachedInstalledSet) {\n      for (const pkg of packages) next[pkg] = cachedInstalledSet.has(pkg);\n    }\n    return next;\n  });\n  const [installing, setInstalling] = useState<string | null>(null);\n  const [error, setError] = useState<string | null>(null);\n  const [quotaExhausted, setQuotaExhausted] = useState(false);\n  const errorTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n  // Stable key so we re-run only when the *set* of requested packages changes.\n  const packagesKey = useMemo(() => packages.slice().sort().join('|'), [packages]);\n\n  // Re-seed local state whenever the agent changes so consumers never\n  // render the previous agent's installed map during the refetch window.\n  useEffect(() => {\n    let cached: Set<string> | null = null;\n    if (agentId) {\n      try {\n        const c = apollo.readQuery<AgentPluginsQuery>({\n          query: AgentPluginsDocument,\n          variables: { agentId },\n        });\n        const list = c?.agentPlugins?.installed ?? null;\n        if (list) cached = new Set(list.map((p: { packageName: string }) => p.packageName));\n      } catch {\n        cached = null;\n      }\n    }\n    const next: Record<string, boolean> = {};\n    if (cached) for (const pkg of packages) next[pkg] = cached.has(pkg);\n    setInstalledMap(next);\n    setHasFetchedOnce(cached !== null);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [agentId, packagesKey, apollo]);\n\n  const refetch = useCallback(async () => {\n    if (!agentId) {\n      setInstalledMap({});\n      return;\n    }\n    setLoading(true);\n    try {\n      // Use the Apollo client directly with `network-only` so out-of-band\n      // installs (CLI, other tabs, agent-side changes) are always picked\n      // up. `useAgentPluginsLazyQuery`'s lazy execute() doesn't accept\n      // per-call fetchPolicy in Apollo v4; `apollo.query()` does.\n      const { data } = await apollo.query<AgentPluginsQuery>({\n        query: AgentPluginsDocument,\n        variables: { agentId },\n        fetchPolicy: 'network-only',\n      });\n      const next: Record<string, boolean> = {};\n      const installedList = data?.agentPlugins?.installed ?? [];\n      const pluginError = data?.agentPlugins?.error ?? null;\n      const installedSet = new Set(\n        installedList.map((p: { packageName: string }) => p.packageName)\n      );\n      for (const pkg of packages) next[pkg] = installedSet.has(pkg);\n      if (pluginError) {\n        if (!classifyAgentStateError(pluginError)) {\n          setInstalledMap(next);\n        }\n        // Log the raw error for debugging, but only surface a sanitized\n        // version to the UI. Raw Bun fetch errors (\"Was there a typo in\n        // the url or port?\") would otherwise leak into the install card.\n        // eslint-disable-next-line no-console -- intentional: keep technical detail for debugging\n        console.error('[ai] agentPlugins returned error', pluginError);\n        setError(sanitizeAgentStateError(pluginError));\n        if (errorTimerRef.current) clearTimeout(errorTimerRef.current);\n        if (!classifyAgentStateError(pluginError)) {\n          errorTimerRef.current = setTimeout(() => setError(null), 5000);\n        }\n        return;\n      }\n      setInstalledMap(next);\n      // Clear any lingering error from a previously-aborted fetch so the\n      // gate doesn't keep showing \"Agent not ready\" after a successful\n      // subsequent request (e.g. React Strict Mode double-mount).\n      setError(null);\n      if (errorTimerRef.current) {\n        clearTimeout(errorTimerRef.current);\n        errorTimerRef.current = null;\n      }\n    } catch (err) {\n      const msg =\n        err instanceof Error ? err.message : 'Agent unreachable — unable to read plugin list';\n      const isAgentStateError = classifyAgentStateError(msg);\n      // Keep the last known installed state while the agent is restarting or\n      // finalizing. Otherwise a transient 503 flashes an install CTA for an\n      // already-installed plugin.\n      if (!isAgentStateError) {\n        setInstalledMap({});\n      }\n      // eslint-disable-next-line no-console -- intentional: keep technical detail for debugging\n      console.error('[ai] agentPlugins fetch failed', err);\n      setError(sanitizeAgentStateError(msg));\n      // State-related errors stay visible until resolved; transient\n      // network/GraphQL errors auto-dismiss so the UI stays tidy.\n      if (errorTimerRef.current) clearTimeout(errorTimerRef.current);\n      if (!isAgentStateError) {\n        errorTimerRef.current = setTimeout(() => setError(null), 5000);\n      }\n    } finally {\n      setLoading(false);\n      setHasFetchedOnce(true);\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [agentId, apollo, packagesKey]);\n\n  useEffect(() => {\n    void refetch();\n  }, [refetch]);\n\n  // Subscribe to the push stream. The svc emits the installed list\n  // whenever it diverges from its previous snapshot, so we only update\n  // local state on payloads — and we also write through to the Apollo\n  // cache so other consumers reading `agentPlugins` directly see fresh\n  // data without their own refetch.\n  useVibecontrolsAgentPluginStreamSubscription({\n    variables: { agentId: agentId ?? '' },\n    skip: !agentId,\n    onData: ({ data }) => {\n      const installedList = data.data?.vibecontrolsAgentPluginStream;\n      if (!installedList || !agentId) return;\n      const installedSet = new Set(\n        installedList.map((p: { packageName: string }) => p.packageName)\n      );\n      setInstalledMap((prev) => {\n        const next: Record<string, boolean> = { ...prev };\n        let changed = false;\n        for (const pkg of packages) {\n          const has = installedSet.has(pkg);\n          if (next[pkg] !== has) {\n            next[pkg] = has;\n            changed = true;\n          }\n        }\n        return changed ? next : prev;\n      });\n      setHasFetchedOnce(true);\n      // Mirror into Apollo cache so consumers that read AgentPluginsQuery\n      // directly (e.g. PluginHarnessPicker) see the same fresh list.\n      try {\n        const existing = apollo.readQuery<AgentPluginsQuery>({\n          query: AgentPluginsDocument,\n          variables: { agentId },\n        });\n        apollo.writeQuery<AgentPluginsQuery>({\n          query: AgentPluginsDocument,\n          variables: { agentId },\n          data: {\n            agentPlugins: {\n              __typename: 'AgentPluginListResult',\n              installed: installedList,\n              available: existing?.agentPlugins?.available ?? [],\n              error: null,\n            },\n          },\n        });\n      } catch {\n        // Cache may not have been primed yet — the next refetch will\n        // populate `available` and we'll write again on the next event.\n      }\n    },\n  });\n\n  // Also refetch when the tab regains focus so installs made elsewhere flow in.\n  useEffect(() => {\n    const onFocus = () => void refetch();\n    window.addEventListener('focus', onFocus);\n    return () => window.removeEventListener('focus', onFocus);\n  }, [refetch]);\n\n  useEffect(() => {\n    return () => {\n      if (errorTimerRef.current) clearTimeout(errorTimerRef.current);\n    };\n  }, []);\n\n  const install = useCallback(\n    async (packageName: string): Promise<boolean> => {\n      if (!agentId) return false;\n      setInstalling(packageName);\n      setError(null);\n      try {\n        const { data } = await installPluginMutation({\n          variables: { agentId, packageName },\n        });\n        if (data?.installAgentPlugin?.success) {\n          setInstalledMap((prev) => ({ ...prev, [packageName]: true }));\n          // Don't immediately refetch — the mutation returns success the\n          // moment the agent's plugin manager accepts the install, but the\n          // npm-level fetch + manifest publish takes a beat. An eager\n          // refetch races that and overwrites our optimistic flip with a\n          // stale \"not installed\" result, putting the install card right\n          // back up.\n          //\n          // The subscription stream is the primary signal; this delayed\n          // refetch is the fallback for environments where the SSE upgrade\n          // is slow. 1200ms is enough for the agent to publish the new\n          // entry on the plugin stream in the common case, short enough\n          // that the user doesn't notice when AgentManagerPage's\n          // onInstalled fires a window.location.reload() at 1500ms.\n          setTimeout(() => void refetch(), 1200);\n          return true;\n        }\n        throw new Error(data?.installAgentPlugin?.error || 'Install failed');\n      } catch (err) {\n        if (isQuotaExhaustedError(err)) {\n          markQuotaHandledLocally();\n          setQuotaExhausted(true);\n          return false;\n        }\n        const msg = err instanceof Error ? err.message : 'Failed to install plugin';\n        // eslint-disable-next-line no-console -- intentional: keep technical detail for debugging\n        console.error('[ai] plugin install failed', err);\n        setError(sanitizeAgentStateError(msg));\n        if (errorTimerRef.current) clearTimeout(errorTimerRef.current);\n        if (!classifyAgentStateError(msg)) {\n          errorTimerRef.current = setTimeout(() => setError(null), 5000);\n        }\n        return false;\n      } finally {\n        setInstalling(null);\n      }\n    },\n    [agentId, installPluginMutation, refetch]\n  );\n\n  const clearQuotaExhausted = useCallback(() => setQuotaExhausted(false), []);\n\n  const missing = useMemo(\n    () => packages.filter((pkg) => !installedMap[pkg]),\n    [packages, installedMap]\n  );\n  const anyInstalled = useMemo(\n    () => packages.some((pkg) => installedMap[pkg]),\n    [packages, installedMap]\n  );\n  const allInstalled = missing.length === 0 && packages.length > 0;\n\n  return {\n    loading,\n    initialLoading: !hasFetchedOnce,\n    installed: installedMap,\n    missing,\n    anyInstalled,\n    allInstalled,\n    installing,\n    install,\n    error,\n    errorIsAgentState: classifyAgentStateError(error),\n    quotaExhausted,\n    clearQuotaExhausted,\n    refetch,\n  };\n}\n"],"mappings":"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"}

package/dist/hooks/useQueryBackedTab.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useQueryBackedTab.js","names":[],"sources":["../../src/hooks/useQueryBackedTab.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\nimport { useSearchParams } from 'react-router';\n\nexport function useQueryBackedTab<T extends string>(\n  validTabs: readonly T[],\n  defaultTab: T,\n  paramName = 'tab'\n): [T, (tab: T) => void] {\n  const [searchParams, setSearchParams] = useSearchParams();\n  const validTabSet = useMemo(() => new Set(validTabs), [validTabs]);\n  const tabParam = searchParams.get(paramName);\n  const activeTab = tabParam && validTabSet.has(tabParam as T) ? (tabParam as T) : defaultTab;\n\n  const setActiveTab = useCallback(\n    (tab: T) => {\n      const next = new URLSearchParams(\n        typeof window === 'undefined' ? searchParams.toString() : window.location.search\n      );\n      if (tab === defaultTab) {\n        next.delete(paramName);\n      } else {\n        next.set(paramName, tab);\n      }\n      setSearchParams(next, { replace: true });\n    },\n    [defaultTab, paramName, searchParams, setSearchParams]\n  );\n\n  return [activeTab, setActiveTab];\n}\n"],"mappings":";;;AAGA,SAAgB,EACd,GACA,GACA,IAAY,OACW;CACvB,IAAM,CAAC,GAAc,KAAmB,GAAiB,EACnD,IAAc,QAAc,IAAI,IAAI,EAAU,EAAE,CAAC,EAAU,CAAC,EAC5D,IAAW,EAAa,IAAI,EAAU;AAkB5C,QAAO,CAjBW,KAAY,EAAY,IAAI,EAAc,GAAI,IAAiB,GAE5D,GAClB,MAAW;EACV,IAAM,IAAO,IAAI,gBACf,OAAO,SAAW,MAAc,EAAa,UAAU,GAAG,OAAO,SAAS,OAC3E;AAMD,EALI,MAAQ,IACV,EAAK,OAAO,EAAU,GAEtB,EAAK,IAAI,GAAW,EAAI,EAE1B,EAAgB,GAAM,EAAE,SAAS,IAAM,CAAC;IAE1C;EAAC;EAAY;EAAW;EAAc;EAAgB,CACvD,CAE+B"}

package/dist/hooks/useTenantContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useTenantContext.js","names":[],"sources":["../../src/hooks/useTenantContext.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { useSearchParams } from 'react-router';\n\n/**\n * Support deep-link flow: callers pass `?org=…&tenant=…` in the URL\n * to override the workspace/tenant the Apollo auth link would read\n * from storage. Return value is shaped for direct use as the Apollo\n * `context` option on a query/mutation so the headers reach the\n * gateway on a per-request basis. `undefined` means no overrides\n * are present, so callers can spread it without adding empty\n * headers to every request.\n *\n * Security boundary: these headers DO NOT grant cross-tenant access.\n * `wspace-public-gateway` lists `x-tenant-id` (and the other\n * `x-actor-*` headers) in `SPOOF_SENSITIVE_HEADERS` and scrubs them\n * from `req.headers` before injecting the gateway-verified set, so\n * a crafted deep-link (`?org=victim&tenant=victim`) does NOT\n * authenticate the victim's session as the attacker's chosen tenant\n * — the actor identity in `x-actor-id` is always gateway-derived\n * from the auth token, and every subgraph enforces `@rbac` against\n * that. The override is honoured at the gateway only for\n * `super_admin` callers (latency hint on token issuance); for\n * regular users it's effectively informational and the RBAC\n * directive on the resolver decides. See\n * `gateways/wspace-public-gateway/src/handlers.ts:574-668`.\n */\nexport function useTenantContext(): { headers: Record<string, string> } | undefined {\n  const [searchParams] = useSearchParams();\n  return useMemo(() => {\n    const orgFromUrl = searchParams.get('org');\n    const tenantFromUrl = searchParams.get('tenant');\n    const headers: Record<string, string> = {};\n    if (orgFromUrl) headers['x-org-id'] = orgFromUrl;\n    if (tenantFromUrl) headers['x-tenant-id'] = tenantFromUrl;\n    return Object.keys(headers).length > 0 ? { headers } : undefined;\n  }, [searchParams]);\n}\n"],"mappings":";;;AA0BA,SAAgB,IAAoE;CAClF,IAAM,CAAC,KAAgB,GAAiB;AACxC,QAAO,QAAc;EACnB,IAAM,IAAa,EAAa,IAAI,MAAM,EACpC,IAAgB,EAAa,IAAI,SAAS,EAC1C,IAAkC,EAAE;AAG1C,SAFI,MAAY,EAAQ,cAAc,IAClC,MAAe,EAAQ,iBAAiB,IACrC,OAAO,KAAK,EAAQ,CAAC,SAAS,IAAI,EAAE,YAAS,GAAG,KAAA;IACtD,CAAC,EAAa,CAAC"}

package/dist/hooks/useTerminalCapabilityUrl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useTerminalCapabilityUrl.js","names":[],"sources":["../../src/hooks/useTerminalCapabilityUrl.ts"],"sourcesContent":["/**\n * useTerminalCapabilityUrl — F3 helper.\n *\n * Takes a session's bare ttyd tunnel URL plus its owning agentId and\n * returns an iframe-ready URL with `#vt=<short-lived-token>` appended\n * (or null while the mint is in flight / failed).\n *\n * The mint flow is identical to the one inlined into SessionDetailsPage:\n *   1. Strip any legacy `?apiKey=` from `baseTtydUrl` (defensive).\n *   2. Call `mintAgentCapability(TERMINAL_SESSION, resourceId=sessionId)`\n *      to mint a short-lived (60s) HMAC ticket path-scoped to\n *      `/terminal/<sessionId>`.\n *   3. Return `${baseTtydUrl}#vt=${encodeURIComponent(token)}` — the\n *      fragment never leaves the browser, so the token stays out of\n *      proxy logs, Referer, and history.\n *\n * The hook owns its own loading + error state. Bump `remintNonce` to\n * force a re-mint (used on iframe error / 10-min cookie expiry).\n */\nimport { useCallback, useEffect, useMemo, useState } from 'react';\n\nimport { useMintAgentCapabilityMutation } from '@/generated/wspace-operations';\nimport { AgentCapabilityScope } from '@/generated/wspace-types';\n\nexport interface UseTerminalCapabilityUrlResult {\n  /** iframe-ready URL with #vt= appended, or null while loading. */\n  url: string | null;\n  /** Mint error from the latest attempt. */\n  error: string | null;\n  /** Mint is in flight. */\n  loading: boolean;\n  /** Force a re-mint (call on iframe error / refresh). */\n  remint: () => void;\n}\n\nfunction stripApiKey(url: string): string {\n  try {\n    const u = new URL(url);\n    u.searchParams.delete('apiKey');\n    return u.toString();\n  } catch {\n    return url;\n  }\n}\n\nexport function useTerminalCapabilityUrl(\n  agentId: string | null | undefined,\n  sessionId: string | null | undefined,\n  baseTtydUrl: string | null | undefined,\n  profile: string = 'default'\n): UseTerminalCapabilityUrlResult {\n  const [mintAgentCapability] = useMintAgentCapabilityMutation();\n  const [token, setToken] = useState<string | null>(null);\n  const [error, setError] = useState<string | null>(null);\n  const [loading, setLoading] = useState(false);\n  const [nonce, setNonce] = useState(0);\n\n  const remint = useCallback(() => setNonce((n) => n + 1), []);\n\n  const sanitizedBase = useMemo(\n    () => (baseTtydUrl ? stripApiKey(baseTtydUrl) : null),\n    [baseTtydUrl]\n  );\n\n  useEffect(() => {\n    let cancelled = false;\n    if (!agentId || !sessionId || !sanitizedBase) {\n      setToken(null);\n      setError(null);\n      return undefined;\n    }\n    setLoading(true);\n    setError(null);\n    mintAgentCapability({\n      variables: {\n        agentId,\n        profile,\n        scope: AgentCapabilityScope.TerminalSession,\n        resourceId: sessionId,\n        ttlSeconds: 60,\n      },\n    })\n      .then((res) => {\n        if (cancelled) return;\n        const minted = res.data?.mintAgentCapability?.token ?? null;\n        if (!minted) {\n          setError('Failed to mint terminal capability');\n          setToken(null);\n        } else {\n          setToken(minted);\n        }\n      })\n      .catch((err) => {\n        if (cancelled) return;\n        setError(err instanceof Error ? err.message : 'Failed to mint terminal capability');\n        setToken(null);\n      })\n      .finally(() => {\n        if (!cancelled) setLoading(false);\n      });\n    return () => {\n      cancelled = true;\n    };\n  }, [agentId, sessionId, sanitizedBase, nonce, profile, mintAgentCapability]);\n\n  const url = sanitizedBase && token ? `${sanitizedBase}#vt=${encodeURIComponent(token)}` : null;\n\n  return { url, error, loading, remint };\n}\n"],"mappings":";;;;AAmCA,SAAS,EAAY,GAAqB;AACxC,KAAI;EACF,IAAM,IAAI,IAAI,IAAI,EAAI;AAEtB,SADA,EAAE,aAAa,OAAO,SAAS,EACxB,EAAE,UAAU;SACb;AACN,SAAO;;;AAIX,SAAgB,EACd,GACA,GACA,GACA,IAAkB,WACc;CAChC,IAAM,CAAC,KAAuB,GAAgC,EACxD,CAAC,GAAO,KAAY,EAAwB,KAAK,EACjD,CAAC,GAAO,KAAY,EAAwB,KAAK,EACjD,CAAC,GAAS,KAAc,EAAS,GAAM,EACvC,CAAC,GAAO,KAAY,EAAS,EAAE,EAE/B,IAAS,QAAkB,GAAU,MAAM,IAAI,EAAE,EAAE,EAAE,CAAC,EAEtD,IAAgB,QACb,IAAc,EAAY,EAAY,GAAG,MAChD,CAAC,EAAY,CACd;AA6CD,QA3CA,QAAgB;EACd,IAAI,IAAY;AAChB,MAAI,CAAC,KAAW,CAAC,KAAa,CAAC,GAAe;AAE5C,GADA,EAAS,KAAK,EACd,EAAS,KAAK;AACd;;AA+BF,SA7BA,EAAW,GAAK,EAChB,EAAS,KAAK,EACd,EAAoB,EAClB,WAAW;GACT;GACA;GACA,OAAO,EAAqB;GAC5B,YAAY;GACZ,YAAY;GACb,EACF,CAAC,CACC,MAAM,MAAQ;AACb,OAAI,EAAW;GACf,IAAM,IAAS,EAAI,MAAM,qBAAqB,SAAS;AACvD,GAAK,IAIH,EAAS,EAAO,IAHhB,EAAS,qCAAqC,EAC9C,EAAS,KAAK;IAIhB,CACD,OAAO,MAAQ;AACV,SACJ,EAAS,aAAe,QAAQ,EAAI,UAAU,qCAAqC,EACnF,EAAS,KAAK;IACd,CACD,cAAc;AACb,GAAK,KAAW,EAAW,GAAM;IACjC,QACS;AACX,OAAY;;IAEb;EAAC;EAAS;EAAW;EAAe;EAAO;EAAS;EAAoB,CAAC,EAIrE;EAAE,KAFG,KAAiB,IAAQ,GAAG,EAAc,MAAM,mBAAmB,EAAM,KAAK;EAE5E;EAAO;EAAS;EAAQ"}

package/dist/hooks/useToggleAgentBookmark.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useToggleAgentBookmark.js","names":[],"sources":["../../src/hooks/useToggleAgentBookmark.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\n\nimport {\n  useCreateAgentMessageBookmarkMutation,\n  useDeleteAgentMessageBookmarkMutation,\n  useMyAgentMessageBookmarksQuery,\n  type AgentMessageBookmarkFieldsFragment,\n} from '../generated/wspace-operations';\n\ninterface ToggleArgs {\n  agentId: string;\n  sessionId: string;\n  messageId: string;\n}\n\ninterface UseToggleAgentBookmarkResult {\n  bookmarkedIds: Set<string>;\n  bookmarkIdByMessageId: Map<string, string>;\n  toggle: (args: ToggleArgs) => Promise<void>;\n  isLoading: boolean;\n  refetch: () => Promise<unknown>;\n}\n\nexport const useToggleAgentBookmark = (\n  sessionId: string | null | undefined\n): UseToggleAgentBookmarkResult => {\n  const { data, loading, refetch } = useMyAgentMessageBookmarksQuery({\n    variables: { filter: { sessionId: sessionId ?? null } },\n    skip: !sessionId,\n    fetchPolicy: 'cache-and-network',\n  });\n\n  const items = useMemo(\n    () => data?.myAgentMessageBookmarks.items ?? [],\n    [data?.myAgentMessageBookmarks.items]\n  );\n\n  const bookmarkedIds = useMemo(\n    () => new Set<string>(items.map((b: AgentMessageBookmarkFieldsFragment) => b.messageId)),\n    [items]\n  );\n  const bookmarkIdByMessageId = useMemo(\n    () =>\n      new Map<string, string>(\n        items.map((b: AgentMessageBookmarkFieldsFragment) => [b.messageId, b.id])\n      ),\n    [items]\n  );\n\n  const [createMutation, { loading: creating }] = useCreateAgentMessageBookmarkMutation({\n    refetchQueries: ['MyAgentMessageBookmarks'],\n  });\n\n  const [deleteMutation, { loading: deleting }] = useDeleteAgentMessageBookmarkMutation({\n    refetchQueries: ['MyAgentMessageBookmarks'],\n  });\n\n  const toggle = useCallback(\n    async ({ agentId, sessionId: sid, messageId }: ToggleArgs) => {\n      const existingId = bookmarkIdByMessageId.get(messageId);\n      if (existingId) {\n        await deleteMutation({ variables: { id: existingId } });\n      } else {\n        await createMutation({\n          variables: { input: { agentId, sessionId: sid, messageId } },\n        });\n      }\n    },\n    [bookmarkIdByMessageId, createMutation, deleteMutation]\n  );\n\n  return {\n    bookmarkedIds,\n    bookmarkIdByMessageId,\n    toggle,\n    isLoading: loading || creating || deleting,\n    refetch,\n  };\n};\n"],"mappings":";;;AAuBA,IAAa,KACX,MACiC;CACjC,IAAM,EAAE,SAAM,YAAS,eAAY,EAAgC;EACjE,WAAW,EAAE,QAAQ,EAAE,WAAW,KAAa,MAAM,EAAE;EACvD,MAAM,CAAC;EACP,aAAa;EACd,CAAC,EAEI,IAAQ,QACN,GAAM,wBAAwB,SAAS,EAAE,EAC/C,CAAC,GAAM,wBAAwB,MAAM,CACtC,EAEK,IAAgB,QACd,IAAI,IAAY,EAAM,KAAK,MAA0C,EAAE,UAAU,CAAC,EACxF,CAAC,EAAM,CACR,EACK,IAAwB,QAE1B,IAAI,IACF,EAAM,KAAK,MAA0C,CAAC,EAAE,WAAW,EAAE,GAAG,CAAC,CAC1E,EACH,CAAC,EAAM,CACR,EAEK,CAAC,GAAgB,EAAE,SAAS,OAAc,EAAsC,EACpF,gBAAgB,CAAC,0BAA0B,EAC5C,CAAC,EAEI,CAAC,GAAgB,EAAE,SAAS,OAAc,EAAsC,EACpF,gBAAgB,CAAC,0BAA0B,EAC5C,CAAC;AAgBF,QAAO;EACL;EACA;EACA,QAjBa,EACb,OAAO,EAAE,YAAS,WAAW,GAAK,mBAA4B;GAC5D,IAAM,IAAa,EAAsB,IAAI,EAAU;AACvD,GAAI,IACF,MAAM,EAAe,EAAE,WAAW,EAAE,IAAI,GAAY,EAAE,CAAC,GAEvD,MAAM,EAAe,EACnB,WAAW,EAAE,OAAO;IAAE;IAAS,WAAW;IAAK;IAAW,EAAE,EAC7D,CAAC;KAGN;GAAC;GAAuB;GAAgB;GAAe,CACxD;EAMC,WAAW,KAAW,KAAY;EAClC;EACD"}

package/dist/hooks/useVoiceMode.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useVoiceMode.js","names":[],"sources":["../../src/hooks/useVoiceMode.ts"],"sourcesContent":["/**\n * Web Speech API integration hook.\n *\n * Provides speech-to-text (SpeechRecognition) and text-to-speech\n * (SpeechSynthesis) capabilities with browser compatibility checks.\n */\n\nimport { useState, useRef, useCallback, useEffect } from 'react';\n\ninterface SpeechRecognitionEvent extends Event {\n  results: SpeechRecognitionResultList;\n  resultIndex: number;\n}\n\ninterface SpeechRecognitionErrorEvent extends Event {\n  error: string;\n  message: string;\n}\n\n/** Browser SpeechRecognition constructor (prefixed or standard) */\ntype SpeechRecognitionConstructor = new () => SpeechRecognitionInstance;\n\ninterface SpeechRecognitionInstance extends EventTarget {\n  continuous: boolean;\n  interimResults: boolean;\n  lang: string;\n  start(): void;\n  stop(): void;\n  abort(): void;\n  onresult: ((event: SpeechRecognitionEvent) => void) | null;\n  onerror: ((event: SpeechRecognitionErrorEvent) => void) | null;\n  onend: (() => void) | null;\n}\n\nfunction getSpeechRecognitionConstructor(): SpeechRecognitionConstructor | null {\n  if (typeof window === 'undefined') return null;\n  const win = window as unknown as Record<string, unknown>;\n  return (\n    (win.SpeechRecognition as SpeechRecognitionConstructor | undefined) ??\n    (win.webkitSpeechRecognition as SpeechRecognitionConstructor | undefined) ??\n    null\n  );\n}\n\ninterface UseVoiceModeReturn {\n  isListening: boolean;\n  transcript: string;\n  startListening: () => void;\n  stopListening: () => void;\n  speak: (text: string) => void;\n  isSupported: boolean;\n}\n\nexport function useVoiceMode(): UseVoiceModeReturn {\n  const [isListening, setIsListening] = useState(false);\n  const [transcript, setTranscript] = useState('');\n  const recognitionRef = useRef<SpeechRecognitionInstance | null>(null);\n\n  const RecognitionCtor = getSpeechRecognitionConstructor();\n  const isSupported =\n    RecognitionCtor !== null && typeof window !== 'undefined' && 'speechSynthesis' in window;\n\n  // Cleanup on unmount\n  useEffect(() => {\n    return () => {\n      if (recognitionRef.current) {\n        recognitionRef.current.abort();\n        recognitionRef.current = null;\n      }\n    };\n  }, []);\n\n  const startListening = useCallback(() => {\n    if (!RecognitionCtor) return;\n\n    const recognition = new RecognitionCtor();\n    recognition.continuous = true;\n    recognition.interimResults = true;\n    recognition.lang = 'en-US';\n\n    recognition.onresult = (event: SpeechRecognitionEvent) => {\n      let finalTranscript = '';\n      for (let i = event.resultIndex; i < event.results.length; i++) {\n        const result = event.results[i];\n        if (result.isFinal) {\n          finalTranscript += result[0].transcript;\n        }\n      }\n      if (finalTranscript) {\n        setTranscript((prev) => (prev ? `${prev} ${finalTranscript}` : finalTranscript));\n      }\n    };\n\n    recognition.onerror = () => {\n      setIsListening(false);\n      recognitionRef.current = null;\n    };\n\n    recognition.onend = () => {\n      setIsListening(false);\n      recognitionRef.current = null;\n    };\n\n    recognitionRef.current = recognition;\n    recognition.start();\n    setIsListening(true);\n  }, [RecognitionCtor]);\n\n  const stopListening = useCallback(() => {\n    if (recognitionRef.current) {\n      recognitionRef.current.stop();\n      recognitionRef.current = null;\n    }\n    setIsListening(false);\n  }, []);\n\n  const speak = useCallback((text: string) => {\n    if (typeof window === 'undefined' || !('speechSynthesis' in window)) return;\n\n    // Cancel any ongoing speech\n    window.speechSynthesis.cancel();\n\n    const utterance = new SpeechSynthesisUtterance(text);\n    utterance.rate = 1;\n    utterance.pitch = 1;\n    window.speechSynthesis.speak(utterance);\n  }, []);\n\n  return {\n    isListening,\n    transcript,\n    startListening,\n    stopListening,\n    speak,\n    isSupported,\n  };\n}\n"],"mappings":";;AAkCA,SAAS,IAAuE;AAC9E,KAAI,OAAO,SAAW,IAAa,QAAO;CAC1C,IAAM,IAAM;AACZ,QACG,EAAI,qBACJ,EAAI,2BACL;;AAaJ,SAAgB,IAAmC;CACjD,IAAM,CAAC,GAAa,KAAkB,EAAS,GAAM,EAC/C,CAAC,GAAY,KAAiB,EAAS,GAAG,EAC1C,IAAiB,EAAyC,KAAK,EAE/D,IAAkB,GAAiC,EACnD,IACJ,MAAoB,QAAQ,OAAO,SAAW,OAAe,qBAAqB;AAoEpF,QAjEA,cACe;AACX,EAEE,EAAe,aADf,EAAe,QAAQ,OAAO,EACL;IAG5B,EAAE,CAAC,EA0DC;EACL;EACA;EACA,gBA3DqB,QAAkB;AACvC,OAAI,CAAC,EAAiB;GAEtB,IAAM,IAAc,IAAI,GAAiB;AA8BzC,GA7BA,EAAY,aAAa,IACzB,EAAY,iBAAiB,IAC7B,EAAY,OAAO,SAEnB,EAAY,YAAY,MAAkC;IACxD,IAAI,IAAkB;AACtB,SAAK,IAAI,IAAI,EAAM,aAAa,IAAI,EAAM,QAAQ,QAAQ,KAAK;KAC7D,IAAM,IAAS,EAAM,QAAQ;AAC7B,KAAI,EAAO,YACT,KAAmB,EAAO,GAAG;;AAGjC,IAAI,KACF,GAAe,MAAU,IAAO,GAAG,EAAK,GAAG,MAAoB,EAAiB;MAIpF,EAAY,gBAAgB;AAE1B,IADA,EAAe,GAAM,EACrB,EAAe,UAAU;MAG3B,EAAY,cAAc;AAExB,IADA,EAAe,GAAM,EACrB,EAAe,UAAU;MAG3B,EAAe,UAAU,GACzB,EAAY,OAAO,EACnB,EAAe,GAAK;KACnB,CAAC,EAAgB,CAAC;EA0BnB,eAxBoB,QAAkB;AAKtC,GAJA,AAEE,EAAe,aADf,EAAe,QAAQ,MAAM,EACJ,OAE3B,EAAe,GAAM;KACpB,EAAE,CAAC;EAmBJ,OAjBY,GAAa,MAAiB;AAC1C,OAAI,OAAO,SAAW,OAAe,EAAE,qBAAqB,QAAS;AAGrE,UAAO,gBAAgB,QAAQ;GAE/B,IAAM,IAAY,IAAI,yBAAyB,EAAK;AAGpD,GAFA,EAAU,OAAO,GACjB,EAAU,QAAQ,GAClB,OAAO,gBAAgB,MAAM,EAAU;KACtC,EAAE,CAAC;EAQJ;EACD"}

package/dist/hooks/useWorkspaceWriteAccess.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useWorkspaceWriteAccess.js","names":[],"sources":["../../src/hooks/useWorkspaceWriteAccess.ts"],"sourcesContent":["/**\n * VibeControls' write-access probe.\n *\n * ★ The mechanism lives in `fe-libs/shared/assistant`; the RESOURCE TYPES stay\n * here, because which resources prove \"this user can write in this workspace\"\n * is the product's answer. The shared hook takes them with no default, so\n * another product cannot accidentally probe VibeControls' vibes — or the other\n * way round.\n */\nimport { useWorkspaceWriteAccess as useShared } from '@burdenoff/fe-libs/shared/assistant/useWorkspaceWriteAccess';\nexport type { WorkspaceWriteAccess } from '@burdenoff/fe-libs/shared/assistant/useWorkspaceWriteAccess';\n\n/**\n * Resources an api-calls turn is most likely to write. Not exhaustive — the\n * assistant can reach far more — but a representative probe. The shared hook\n * asks `checkPermissions` for `action: \"create\"` on each.\n *\n * ★★ These are the names the BACKEND enforces, which are unprefixed:\n *   vibe     `createVibe`              @rbac(action: \"create\", resource: \"vibe\")\n *   session  `createSession`           @rbac(action: \"create\", resource: \"session\")\n *   agent    `createVibecontrolsAgent` @rbac(action: \"create\", resource: \"agent\")\n * (wspace-vibecontrols-svc, and the composed `graphql/wspace.graphql` here) —\n * and the RBAC service seeds exactly these resource types.\n *\n * They were `vibecontrols_vibe` / `_session` / `_agent`, copied from\n * HealthyBowl's `healthybowl_crop` convention. No such resource type exists in\n * VibeControls' schema or RBAC seed, so no seeded role grants them, RBAC falls\n * through to default-DENY, and the composer's warning said nothing about the\n * permissions a Take-action turn actually needs.\n *\n * Still advisory, never a gate: the shared panel only shows a warning.\n * `useWorkspaceWriteAccess.test.ts` checks these against the schema.\n */\nexport const PROBE_RESOURCES = ['vibe', 'session', 'agent'] as const;\n\nexport function useWorkspaceWriteAccess(actorId: string | null, workspaceId: string | null) {\n  return useShared(actorId, workspaceId, PROBE_RESOURCES);\n}\n"],"mappings":";;AAiCA,IAAa,IAAkB;CAAC;CAAQ;CAAW;CAAQ;AAE3D,SAAgB,EAAwB,GAAwB,GAA4B;AAC1F,QAAO,EAAU,GAAS,GAAa,EAAgB"}

package/dist/lib/apolloCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"apolloCache.js","names":[],"sources":["../../src/lib/apolloCache.ts"],"sourcesContent":["/**\n * Apollo InMemoryCache for the VibeControls MFE.\n *\n * `typePolicies` make cross-query normalization explicit so the provider's\n * `VibeControlsInitialData` agents/vibes/sessions and the per-page list queries\n * (ListAgents/ListTargets/…) write into the SAME normalized objects — pages then\n * paint instantly from cache. `AgentHealthProbeResult` has no `id`, so it needs\n * an explicit `keyFields` for the probe query + the live subscription to share\n * objects (otherwise they collide as un-normalized embedded values).\n */\n\nimport { InMemoryCache } from '@apollo/client';\n\nexport function buildVibeControlsCache(): InMemoryCache {\n  return new InMemoryCache({\n    typePolicies: {\n      // id-bearing types are auto-normalized by Apollo; declaring keyFields is\n      // explicit + future-proof and lets cache.modify target them reliably.\n      VibecontrolsAgent: { keyFields: ['id'] },\n      Target: { keyFields: ['id'] },\n      Vibe: { keyFields: ['id'] },\n      Session: { keyFields: ['id'] },\n      AiPrompt: { keyFields: ['id'] },\n      AiContext: { keyFields: ['id'] },\n      AgentInstructionFile: { keyFields: ['id'] },\n      // No `id` field — key on agentId so the probe query result and the\n      // health-probe-stream subscription update the same normalized object.\n      AgentHealthProbeResult: { keyFields: ['agentId'] },\n    },\n  });\n}\n"],"mappings":";;AAaA,SAAgB,IAAwC;AACtD,QAAO,IAAI,EAAc,EACvB,cAAc;EAGZ,mBAAmB,EAAE,WAAW,CAAC,KAAK,EAAE;EACxC,QAAQ,EAAE,WAAW,CAAC,KAAK,EAAE;EAC7B,MAAM,EAAE,WAAW,CAAC,KAAK,EAAE;EAC3B,SAAS,EAAE,WAAW,CAAC,KAAK,EAAE;EAC9B,UAAU,EAAE,WAAW,CAAC,KAAK,EAAE;EAC/B,WAAW,EAAE,WAAW,CAAC,KAAK,EAAE;EAChC,sBAAsB,EAAE,WAAW,CAAC,KAAK,EAAE;EAG3C,wBAAwB,EAAE,WAAW,CAAC,UAAU,EAAE;EACnD,EACF,CAAC"}

package/dist/lib/toast.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"toast.js","names":[],"sources":["../../src/lib/toast.ts"],"sourcesContent":["import { toast } from 'sonner';\n\n/**\n * Module-wide toast API. sonner is a global singleton; the matching <Toaster>\n * is owned by the HOST — the production app shell mounts a single one via\n * AppShellProvider, and the standalone dev harness mounts its own (see\n * VibeControlsRoot's `renderToaster`). Every page/component must emit feedback\n * through these helpers instead of hand-rolling fixed-position toast markup.\n *\n * Durations follow the notification spec: success/info auto-dismiss,\n * errors stay until the user dismisses them (sonner renders a close\n * button and announces via aria-live).\n */\nexport const notify = {\n  success(message: string, description?: string): void {\n    toast.success(message, { description, duration: 4000 });\n  },\n  info(message: string, description?: string): void {\n    toast.info(message, { description, duration: 4000 });\n  },\n  warning(message: string, description?: string): void {\n    toast.warning(message, { description, duration: 8000 });\n  },\n  error(message: string, description?: string): void {\n    toast.error(message, { description, duration: Infinity, closeButton: true });\n  },\n  dismiss(id?: string | number): void {\n    toast.dismiss(id);\n  },\n};\n\nexport { toast };\n"],"mappings":";;AAaA,IAAa,IAAS;CACpB,QAAQ,GAAiB,GAA4B;AACnD,IAAM,QAAQ,GAAS;GAAE;GAAa,UAAU;GAAM,CAAC;;CAEzD,KAAK,GAAiB,GAA4B;AAChD,IAAM,KAAK,GAAS;GAAE;GAAa,UAAU;GAAM,CAAC;;CAEtD,QAAQ,GAAiB,GAA4B;AACnD,IAAM,QAAQ,GAAS;GAAE;GAAa,UAAU;GAAM,CAAC;;CAEzD,MAAM,GAAiB,GAA4B;AACjD,IAAM,MAAM,GAAS;GAAE;GAAa,UAAU;GAAU,aAAa;GAAM,CAAC;;CAE9E,QAAQ,GAA4B;AAClC,IAAM,QAAQ,EAAG;;CAEpB"}

package/dist/lib/vibeFeatures.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"vibeFeatures.js","names":[],"sources":["../../src/lib/vibeFeatures.ts"],"sourcesContent":["/**\n * Per-vibe feature flag helpers (frontend mirror of the backend catalog).\n *\n * The runtime source of truth for the catalog is the `vibeFeatureCatalog`\n * GraphQL query, but we keep a static fallback so the UI can render\n * deterministically before the catalog query resolves and so TypeScript can\n * narrow tab ids.\n */\n\nexport interface VibeFeatureDefinition {\n  id: string;\n  label: string;\n  defaultEnabled: boolean;\n}\n\nexport const DEFAULT_VIBE_FEATURE_CATALOG: readonly VibeFeatureDefinition[] = [\n  { id: 'git', label: 'Git', defaultEnabled: true },\n  { id: 'sessions', label: 'Sessions', defaultEnabled: true },\n  { id: 'browserEditor', label: 'Browser Editor', defaultEnabled: true },\n  { id: 'notes', label: 'Notes', defaultEnabled: true },\n  { id: 'docs', label: 'Docs', defaultEnabled: true },\n  { id: 'scorecard', label: 'Scorecard', defaultEnabled: true },\n  { id: 'catalogs', label: 'Catalogs', defaultEnabled: true },\n  { id: 'graphqlPlayground', label: 'GraphQL Playground', defaultEnabled: true },\n  { id: 'gitops', label: 'GitOps', defaultEnabled: true },\n  { id: 'related', label: 'Related', defaultEnabled: true },\n  { id: 'costManagement', label: 'Cost Management', defaultEnabled: false },\n] as const;\n\n/**\n * Determine if a feature is enabled for a vibe.\n *\n * Resolution order:\n *   1. Server-provided `effectiveFeatureFlags` (already merged backend-side)\n *   2. Stored `featureFlags` overrides\n *   3. Catalog `defaultEnabled`\n *   4. `true` (unknown ids fail open so adding a new tab does not require a\n *      backend deploy first)\n */\nexport function isVibeFeatureEnabled(\n  vibe:\n    | {\n        featureFlags?: Record<string, unknown> | null;\n        effectiveFeatureFlags?: Record<string, unknown> | null;\n      }\n    | null\n    | undefined,\n  featureId: string,\n  catalog: readonly VibeFeatureDefinition[] = DEFAULT_VIBE_FEATURE_CATALOG\n): boolean {\n  if (!vibe) {\n    const def = catalog.find((f) => f.id === featureId);\n    return def ? def.defaultEnabled : true;\n  }\n\n  const effective = vibe.effectiveFeatureFlags;\n  if (effective && typeof effective === 'object' && featureId in effective) {\n    const value = (effective as Record<string, unknown>)[featureId];\n    if (typeof value === 'boolean') {\n      return value;\n    }\n  }\n\n  const stored = vibe.featureFlags;\n  if (stored && typeof stored === 'object' && featureId in stored) {\n    const value = (stored as Record<string, unknown>)[featureId];\n    if (typeof value === 'boolean') {\n      return value;\n    }\n  }\n\n  const def = catalog.find((f) => f.id === featureId);\n  return def ? def.defaultEnabled : true;\n}\n"],"mappings":";AAeA,IAAa,IAAiE;CAC5E;EAAE,IAAI;EAAO,OAAO;EAAO,gBAAgB;EAAM;CACjD;EAAE,IAAI;EAAY,OAAO;EAAY,gBAAgB;EAAM;CAC3D;EAAE,IAAI;EAAiB,OAAO;EAAkB,gBAAgB;EAAM;CACtE;EAAE,IAAI;EAAS,OAAO;EAAS,gBAAgB;EAAM;CACrD;EAAE,IAAI;EAAQ,OAAO;EAAQ,gBAAgB;EAAM;CACnD;EAAE,IAAI;EAAa,OAAO;EAAa,gBAAgB;EAAM;CAC7D;EAAE,IAAI;EAAY,OAAO;EAAY,gBAAgB;EAAM;CAC3D;EAAE,IAAI;EAAqB,OAAO;EAAsB,gBAAgB;EAAM;CAC9E;EAAE,IAAI;EAAU,OAAO;EAAU,gBAAgB;EAAM;CACvD;EAAE,IAAI;EAAW,OAAO;EAAW,gBAAgB;EAAM;CACzD;EAAE,IAAI;EAAkB,OAAO;EAAmB,gBAAgB;EAAO;CAC1E;AAYD,SAAgB,EACd,GAOA,GACA,IAA4C,GACnC;AACT,KAAI,CAAC,GAAM;EACT,IAAM,IAAM,EAAQ,MAAM,MAAM,EAAE,OAAO,EAAU;AACnD,SAAO,IAAM,EAAI,iBAAiB;;CAGpC,IAAM,IAAY,EAAK;AACvB,KAAI,KAAa,OAAO,KAAc,YAAY,KAAa,GAAW;EACxE,IAAM,IAAS,EAAsC;AACrD,MAAI,OAAO,KAAU,UACnB,QAAO;;CAIX,IAAM,IAAS,EAAK;AACpB,KAAI,KAAU,OAAO,KAAW,YAAY,KAAa,GAAQ;EAC/D,IAAM,IAAS,EAAmC;AAClD,MAAI,OAAO,KAAU,UACnB,QAAO;;CAIX,IAAM,IAAM,EAAQ,MAAM,MAAM,EAAE,OAAO,EAAU;AACnD,QAAO,IAAM,EAAI,iBAAiB"}

package/dist/node_modules/@apollo/client/errors/CombinedGraphQLErrors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CombinedGraphQLErrors.js","names":[],"sources":["../../../../../node_modules/@apollo/client/errors/CombinedGraphQLErrors.js"],"sourcesContent":["import { brand, isBranded } from \"./utils.js\";\nfunction defaultFormatMessage(errors) {\n    return (errors\n        // Handle non-spec-compliant servers: See #1185\n        .filter((e) => e)\n        .map((e) => e.message || \"Error message not found.\")\n        .join(\"\\n\"));\n}\n/**\n * Represents the combined list of GraphQL errors returned from the server in a\n * GraphQL response. This error type is used when your GraphQL operation returns\n * errors in the `errors` field of the response.\n *\n * @remarks\n *\n * When your GraphQL operation encounters errors on the server side (such as\n * resolver errors, validation errors, or syntax errors), the server returns\n * these errors in the `errors` array of the GraphQL response. Apollo Client\n * wraps these errors in a `CombinedGraphQLErrors` object, which provides access\n * to the individual errors while maintaining additional context about the\n * response.\n *\n * @example\n *\n * ```ts\n * import { CombinedGraphQLErrors } from \"@apollo/client/errors\";\n *\n * // Check if an error is a CombinedGraphQLErrors object\n * if (CombinedGraphQLErrors.is(error)) {\n *   // Access individual GraphQL errors\n *   error.errors.forEach((graphQLError) => {\n *     console.log(graphQLError.message);\n *     console.log(graphQLError.path);\n *     console.log(graphQLError.locations);\n *   });\n *\n *   // Access the original GraphQL result\n *   console.log(error.result);\n * }\n * ```\n */\nexport class CombinedGraphQLErrors extends Error {\n    /**\n    * A method that determines whether an error is a `CombinedGraphQLErrors`\n    * object. This method enables TypeScript to narrow the error type.\n    * \n    * @example\n    * \n    * ```ts\n    * if (CombinedGraphQLErrors.is(error)) {\n    *   // TypeScript now knows `error` is a `CombinedGraphQLErrors` object\n    *   console.log(error.errors);\n    * }\n    * ```\n    */\n    static is(error) {\n        return isBranded(error, \"CombinedGraphQLErrors\");\n    }\n    /**\n    * A function that formats the error message used for the error's `message`\n    * property. Override this method to provide your own formatting.\n    * \n    * @remarks\n    * \n    * The `formatMessage` function is called by the `CombinedGraphQLErrors`\n    * constructor to provide a formatted message as the `message` property of the\n    * `CombinedGraphQLErrors` object. Follow the [\"Providing a custom message\n    * formatter\"](https://www.apollographql.com/docs/react/api/errors/CombinedGraphQLErrors#providing-a-custom-message-formatter) guide to learn how to modify the message format.\n    * \n    * @param errors - The array of GraphQL errors returned from the server in\n    * the `errors` field of the response.\n    * @param options - Additional context that could be useful when formatting\n    * the message.\n    */\n    static formatMessage = defaultFormatMessage;\n    /**\n    * The raw list of GraphQL errors returned by the `errors` field in the GraphQL response.\n    */\n    errors;\n    /**\n    * Partial data returned in the `data` field of the GraphQL response.\n    */\n    data;\n    /**\n    * Extensions returned by the `extensions` field in the GraphQL response.\n    */\n    extensions;\n    constructor(result, errors = result.errors || []) {\n        super(CombinedGraphQLErrors.formatMessage(errors, {\n            result,\n            defaultFormatMessage,\n        }));\n        this.errors = errors;\n        this.data = result.data;\n        this.extensions = result.extensions;\n        this.name = \"CombinedGraphQLErrors\";\n        brand(this);\n        Object.setPrototypeOf(this, CombinedGraphQLErrors.prototype);\n    }\n}\n//# sourceMappingURL=CombinedGraphQLErrors.js.map\n"],"x_google_ignoreList":[0],"mappings":";;AACA,SAAS,EAAqB,GAAQ;AAClC,QAAQ,EAEH,QAAQ,MAAM,EAAE,CAChB,KAAK,MAAM,EAAE,WAAW,2BAA2B,CACnD,KAAK,KAAK;;AAmCnB,IAAa,IAAb,MAAa,UAA8B,MAAM;CAc7C,OAAO,GAAG,GAAO;AACb,SAAO,EAAU,GAAO,wBAAwB;;CAkBpD,OAAO,gBAAgB;CAIvB;CAIA;CAIA;CACA,YAAY,GAAQ,IAAS,EAAO,UAAU,EAAE,EAAE;AAU9C,EATA,MAAM,EAAsB,cAAc,GAAQ;GAC9C;GACA;GACH,CAAC,CAAC,EACH,KAAK,SAAS,GACd,KAAK,OAAO,EAAO,MACnB,KAAK,aAAa,EAAO,YACzB,KAAK,OAAO,yBACZ,EAAM,KAAK,EACX,OAAO,eAAe,MAAM,EAAsB,UAAU"}

package/dist/node_modules/@apollo/client/errors/ServerError.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ServerError.js","names":[],"sources":["../../../../../node_modules/@apollo/client/errors/ServerError.js"],"sourcesContent":["import { brand, isBranded } from \"./utils.js\";\n/**\n * Represents an error when a non-200 HTTP status code is returned from the\n * server according to the [GraphQL Over HTTP specification](https://graphql.github.io/graphql-over-http/draft/). This error\n * contains the full server response, including status code and body text.\n *\n * @remarks\n *\n * This error occurs when your GraphQL server responds with an HTTP status code\n * other than 200 (such as 4xx or 5xx status codes) with any media type other\n * than [`application/graphql-response+json`](https://graphql.github.io/graphql-over-http/draft/#sec-application-graphql-response-json).\n *\n * Servers that return non-200 status codes with other media types are not\n * guaranteed to contain a well-formed GraphQL response and may indicate issues\n * at the HTTP level, such as authentication failures, server unavailability,\n * or other HTTP-level problems.\n *\n * @example\n *\n * ```ts\n * import { ServerError } from \"@apollo/client/errors\";\n *\n * // Check if an error is a ServerError instance\n * if (ServerError.is(error)) {\n *   console.log(`Server returned status: ${error.statusCode}`);\n *   console.log(`Response body: ${error.bodyText}`);\n *\n *   // Handle specific status codes\n *   if (error.statusCode === 401) {\n *     // Handle unauthorized access\n *   }\n * }\n * ```\n */\nexport class ServerError extends Error {\n    /**\n     * A method that determines whether an error is a `ServerError` object. This\n     * method enables TypeScript to narrow the error type.\n     *\n     * @example\n     *\n     * ```ts\n     * if (ServerError.is(error)) {\n     *   // TypeScript now knows `error` is a ServerError object\n     *   console.log(error.errors);\n     * }\n     * ```\n     */\n    static is(error) {\n        return isBranded(error, \"ServerError\");\n    }\n    /**\n    * The raw [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) object provided by the [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API).\n    */\n    response;\n    /**\n    * The status code returned by the server in the response. This is provided as\n    * a shortcut for `response.status`.\n    */\n    statusCode;\n    /**\n    * The raw response body text.\n    */\n    bodyText;\n    constructor(message, options) {\n        super(message);\n        this.name = \"ServerError\";\n        this.response = options.response;\n        this.statusCode = options.response.status;\n        this.bodyText = options.bodyText;\n        brand(this);\n        Object.setPrototypeOf(this, ServerError.prototype);\n    }\n}\n//# sourceMappingURL=ServerError.js.map\n"],"x_google_ignoreList":[0],"mappings":";;AAkCA,IAAa,IAAb,MAAa,UAAoB,MAAM;CAcnC,OAAO,GAAG,GAAO;AACb,SAAO,EAAU,GAAO,cAAc;;CAK1C;CAKA;CAIA;CACA,YAAY,GAAS,GAAS;AAO1B,EANA,MAAM,EAAQ,EACd,KAAK,OAAO,eACZ,KAAK,WAAW,EAAQ,UACxB,KAAK,aAAa,EAAQ,SAAS,QACnC,KAAK,WAAW,EAAQ,UACxB,EAAM,KAAK,EACX,OAAO,eAAe,MAAM,EAAY,UAAU"}

package/dist/node_modules/@apollo/client/errors/ServerParseError.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ServerParseError.js","names":[],"sources":["../../../../../node_modules/@apollo/client/errors/ServerParseError.js"],"sourcesContent":["import { brand, isBranded } from \"./utils.js\";\n/**\n * Represents a failure to parse the response as JSON from the server. This\n * error helps debug issues where the server returns malformed JSON or non-JSON\n * content.\n *\n * @remarks\n *\n * This error occurs when Apollo Client receives a response from the server but\n * cannot parse it as valid JSON. This typically happens when the server returns\n * HTML error pages, plain text responses, or malformed JSON instead of the\n * expected GraphQL JSON response format.\n *\n * @example\n *\n * ```ts\n * import { ServerParseError } from \"@apollo/client/errors\";\n *\n * // Check if an error is a ServerParseError instance\n * if (ServerParseError.is(error)) {\n *   console.log(`Failed to parse response from ${error.response.url}`);\n *   console.log(`Raw response: ${error.bodyText}`);\n *   console.log(`Status code: ${error.statusCode}`);\n *\n *   // Access the original parse error\n *   console.log(`Parse error: ${error.cause}`);\n * }\n * ```\n */\nexport class ServerParseError extends Error {\n    /**\n     * A method that determines whether an error is a `ServerParseError`\n     * object. This method enables TypeScript to narrow the error type.\n     *\n     * @example\n     *\n     * ```ts\n     * if (ServerParseError.is(error)) {\n     *   // TypeScript now knows `error` is a ServerParseError object\n     *   console.log(error.statusCode);\n     * }\n     * ```\n     */\n    static is(error) {\n        return isBranded(error, \"ServerParseError\");\n    }\n    /**\n    * The raw [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) object provided by the [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API).\n    */\n    response;\n    /**\n    * The status code returned by the server in the response. This is provided\n    * as a shortcut for `response.status`.\n    */\n    statusCode;\n    /**\n    * The raw response body text.\n    */\n    bodyText;\n    constructor(originalParseError, options) {\n        super(originalParseError instanceof Error ?\n            originalParseError.message\n            : \"Could not parse server response\", { cause: originalParseError });\n        this.name = \"ServerParseError\";\n        this.response = options.response;\n        this.statusCode = options.response.status;\n        this.bodyText = options.bodyText;\n        brand(this);\n        Object.setPrototypeOf(this, ServerParseError.prototype);\n    }\n}\n//# sourceMappingURL=ServerParseError.js.map\n"],"x_google_ignoreList":[0],"mappings":";;AA6BA,IAAa,IAAb,MAAa,UAAyB,MAAM;CAcxC,OAAO,GAAG,GAAO;AACb,SAAO,EAAU,GAAO,mBAAmB;;CAK/C;CAKA;CAIA;CACA,YAAY,GAAoB,GAAS;AASrC,EARA,MAAM,aAA8B,QAChC,EAAmB,UACjB,mCAAmC,EAAE,OAAO,GAAoB,CAAC,EACvE,KAAK,OAAO,oBACZ,KAAK,WAAW,EAAQ,UACxB,KAAK,aAAa,EAAQ,SAAS,QACnC,KAAK,WAAW,EAAQ,UACxB,EAAM,KAAK,EACX,OAAO,eAAe,MAAM,EAAiB,UAAU"}

package/dist/node_modules/@apollo/client/errors/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../../../../../node_modules/@apollo/client/errors/utils.js"],"sourcesContent":["export function isBranded(error, name) {\n    return (typeof error === \"object\" &&\n        error !== null &&\n        error[Symbol.for(\"apollo.error\")] === name);\n}\nexport function brand(error) {\n    Object.defineProperty(error, Symbol.for(\"apollo.error\"), {\n        value: error.name,\n        enumerable: false,\n        writable: false,\n        configurable: false,\n    });\n}\n//# sourceMappingURL=utils.js.map"],"x_google_ignoreList":[0],"mappings":";AAAA,SAAgB,EAAU,GAAO,GAAM;AACnC,QAAQ,OAAO,KAAU,cACrB,KACA,EAAM,OAAO,IAAI,eAAe,MAAM;;AAE9C,SAAgB,EAAM,GAAO;AACzB,QAAO,eAAe,GAAO,OAAO,IAAI,eAAe,EAAE;EACrD,OAAO,EAAM;EACb,YAAY;EACZ,UAAU;EACV,cAAc;EACjB,CAAC"}

package/dist/node_modules/@apollo/client/link/batch/batchLink.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"batchLink.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/link/batch/batchLink.js"],"sourcesContent":["import { EMPTY } from \"rxjs\";\nimport { ApolloLink } from \"@apollo/client/link\";\nimport { OperationBatcher } from \"./batching.js\";\n/**\n * `BatchLink` is a non-terminating link that provides the core batching\n * functionality for grouping multiple GraphQL operations into batches based\n * on configurable timing and key-based grouping strategies. It serves as a base\n * link to `BatchHttpLink`.\n *\n * @remarks\n *\n * > [!NOTE]\n * > You will not generally use `BatchLink` on your own unless you need to\n * > provide batching capabilities to third-party terminating links. Prefer\n * > using `BatchHttpLink` to batch GraphQL operations over HTTP.\n *\n * @example\n *\n * ```ts\n * import { BatchLink } from \"@apollo/client/link/batch\";\n *\n * const link = new BatchLink({\n *   batchInterval: 20,\n *   batchMax: 5,\n *   batchHandler: (operations, forwards) => {\n *     // Custom logic to process batch of operations\n *     return handleBatch(operations, forwards);\n *   },\n * });\n * ```\n */\nexport class BatchLink extends ApolloLink {\n    batcher;\n    constructor(options) {\n        super();\n        const { batchDebounce, batchInterval = 10, batchMax = 0, batchHandler = () => EMPTY, batchKey = () => \"\", } = options || {};\n        this.batcher = new OperationBatcher({\n            batchDebounce,\n            batchInterval,\n            batchMax,\n            batchHandler,\n            batchKey,\n        });\n    }\n    request(operation, forward) {\n        return this.batcher.enqueueRequest({ operation, forward });\n    }\n}\n//# sourceMappingURL=batchLink.js.map"],"x_google_ignoreList":[0],"mappings":";;;;AA+BA,IAAa,IAAb,cAA+B,EAAW;CACtC;CACA,YAAY,GAAS;AACjB,SAAO;EACP,IAAM,EAAE,kBAAe,mBAAgB,IAAI,cAAW,GAAG,wBAAqB,GAAO,oBAAiB,OAAQ,KAAW,EAAE;AAC3H,OAAK,UAAU,IAAI,EAAiB;GAChC;GACA;GACA;GACA;GACA;GACH,CAAC;;CAEN,QAAQ,GAAW,GAAS;AACxB,SAAO,KAAK,QAAQ,eAAe;GAAE;GAAW;GAAS,CAAC"}

package/dist/node_modules/@apollo/client/link/batch/batching.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"batching.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/link/batch/batching.js"],"sourcesContent":["import { Observable } from \"rxjs\";\n// QueryBatcher doesn't fire requests immediately. Requests that were enqueued within\n// a certain amount of time (configurable through `batchInterval`) will be batched together\n// into one query.\nexport class OperationBatcher {\n    // Queue on which the QueryBatcher will operate on a per-tick basis.\n    batchesByKey = new Map();\n    scheduledBatchTimerByKey = new Map();\n    batchDebounce;\n    batchInterval;\n    batchMax;\n    //This function is called to the queries in the queue to the server.\n    batchHandler;\n    batchKey;\n    constructor({ batchDebounce, batchInterval, batchMax, batchHandler, batchKey, }) {\n        this.batchDebounce = batchDebounce;\n        this.batchInterval = batchInterval;\n        this.batchMax = batchMax || 0;\n        this.batchHandler = batchHandler;\n        this.batchKey = batchKey || (() => \"\");\n    }\n    enqueueRequest(request) {\n        const requestCopy = {\n            ...request,\n            next: [],\n            error: [],\n            complete: [],\n            subscribers: new Set(),\n        };\n        const key = this.batchKey(request.operation);\n        if (!requestCopy.observable) {\n            requestCopy.observable = new Observable((observer) => {\n                let batch = this.batchesByKey.get(key);\n                if (!batch)\n                    this.batchesByKey.set(key, (batch = new Set()));\n                // These booleans seem to me (@benjamn) like they might always be the\n                // same (and thus we could do with only one of them), but I'm not 100%\n                // sure about that.\n                const isFirstEnqueuedRequest = batch.size === 0;\n                const isFirstSubscriber = requestCopy.subscribers.size === 0;\n                requestCopy.subscribers.add(observer);\n                if (isFirstSubscriber) {\n                    batch.add(requestCopy);\n                }\n                // called for each subscriber, so need to save all listeners (next, error, complete)\n                if (observer.next) {\n                    requestCopy.next.push(observer.next.bind(observer));\n                }\n                if (observer.error) {\n                    requestCopy.error.push(observer.error.bind(observer));\n                }\n                if (observer.complete) {\n                    requestCopy.complete.push(observer.complete.bind(observer));\n                }\n                // The first enqueued request triggers the queue consumption after `batchInterval` milliseconds.\n                if (isFirstEnqueuedRequest || this.batchDebounce) {\n                    this.scheduleQueueConsumption(key);\n                }\n                // When amount of requests reaches `batchMax`, trigger the queue consumption without waiting on the `batchInterval`.\n                if (batch.size === this.batchMax) {\n                    this.consumeQueue(key);\n                }\n                return () => {\n                    // If this is last subscriber for this request, remove request from queue\n                    if (requestCopy.subscribers.delete(observer) &&\n                        requestCopy.subscribers.size < 1) {\n                        // If this is last request from queue, remove queue entirely\n                        if (batch.delete(requestCopy) && batch.size < 1) {\n                            this.consumeQueue(key);\n                            // If queue was in flight, cancel it\n                            batch.subscription?.unsubscribe();\n                        }\n                    }\n                };\n            });\n        }\n        return requestCopy.observable;\n    }\n    // Consumes the queue.\n    // Returns a list of promises (one for each query).\n    consumeQueue(key = \"\") {\n        const batch = this.batchesByKey.get(key);\n        // Delete this batch and process it below.\n        this.batchesByKey.delete(key);\n        if (!batch || !batch.size) {\n            // No requests to be processed.\n            return;\n        }\n        const operations = [];\n        const forwards = [];\n        const observables = [];\n        const nexts = [];\n        const errors = [];\n        const completes = [];\n        // Even though batch is a Set, it preserves the order of first insertion\n        // when iterating (per ECMAScript specification), so these requests will be\n        // handled in the order they were enqueued (minus any deleted ones).\n        batch.forEach((request) => {\n            operations.push(request.operation);\n            forwards.push(request.forward);\n            observables.push(request.observable);\n            nexts.push(request.next);\n            errors.push(request.error);\n            completes.push(request.complete);\n        });\n        const batchedObservable = this.batchHandler(operations, forwards);\n        const onError = (error) => {\n            //each callback list in batch\n            errors.forEach((rejecters) => {\n                if (rejecters) {\n                    //each subscriber to request\n                    rejecters.forEach((e) => e(error));\n                }\n            });\n        };\n        batch.subscription = batchedObservable.subscribe({\n            next: (results) => {\n                if (!Array.isArray(results)) {\n                    results = [results];\n                }\n                if (nexts.length !== results.length) {\n                    const error = new Error(`server returned results with length ${results.length}, expected length of ${nexts.length}`);\n                    error.result = results;\n                    return onError(error);\n                }\n                results.forEach((result, index) => {\n                    if (nexts[index]) {\n                        nexts[index].forEach((next) => next(result));\n                    }\n                });\n            },\n            error: onError,\n            complete: () => {\n                completes.forEach((complete) => {\n                    if (complete) {\n                        //each subscriber to request\n                        complete.forEach((c) => c());\n                    }\n                });\n            },\n        });\n        return observables;\n    }\n    scheduleQueueConsumption(key) {\n        clearTimeout(this.scheduledBatchTimerByKey.get(key));\n        this.scheduledBatchTimerByKey.set(key, setTimeout(() => {\n            this.consumeQueue(key);\n            this.scheduledBatchTimerByKey.delete(key);\n        }, this.batchInterval));\n    }\n}\n//# sourceMappingURL=batching.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/@apollo/client/link/batch-http/BaseBatchHttpLink.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BaseBatchHttpLink.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/link/batch-http/BaseBatchHttpLink.js"],"sourcesContent":["import { Observable, throwError } from \"rxjs\";\nimport { ApolloLink } from \"@apollo/client/link\";\nimport { BatchLink } from \"@apollo/client/link/batch\";\nimport { checkFetcher, defaultPrinter, fallbackHttpConfig, parseAndCheckHttpResponse, selectHttpOptionsAndBodyInternal, selectURI, } from \"@apollo/client/link/http\";\nimport { filterOperationVariables } from \"@apollo/client/link/utils\";\nimport { __DEV__ } from \"@apollo/client/utilities/environment\";\nimport { compact } from \"@apollo/client/utilities/internal\";\nimport { maybe } from \"@apollo/client/utilities/internal/globals\";\nconst backupFetch = maybe(() => fetch);\n/**\n * `BaseBatchHttpLink` is a terminating link that batches array of individual\n * GraphQL operations into a single HTTP request that's sent to a single GraphQL\n * endpoint. It serves as a base link to `BatchHttpLink`.\n *\n * @remarks\n *\n * > [!NOTE]\n * > Prefer using `BatchHttpLink` over `BaseBatchHttpLink`. Use\n * > `BaseBatchHttpLink` when you need to disable client awareness features and\n * > would like to tree-shake the implementation of `ClientAwarenessLink` out\n * > of your app bundle.\n *\n * @example\n *\n * ```ts\n * import { BaseBatchHttpLink } from \"@apollo/client/link/batch-http\";\n *\n * const link = new BaseBatchHttpLink({\n *   uri: \"http://localhost:4000/graphql\",\n *   batchMax: 5, // No more than 5 operations per batch\n *   batchInterval: 20, // Wait no more than 20ms after first batched operation\n * });\n * ```\n */\nexport class BaseBatchHttpLink extends ApolloLink {\n    batchDebounce;\n    batchInterval;\n    batchMax;\n    batcher;\n    constructor(options = {}) {\n        super();\n        let { uri = \"/graphql\", \n        // use default global fetch if nothing is passed in\n        fetch: preferredFetch, print = defaultPrinter, includeExtensions, preserveHeaderCase, batchInterval, batchDebounce, batchMax, batchKey, includeUnusedVariables = false, ...requestOptions } = options;\n        if (__DEV__) {\n            // Make sure at least one of preferredFetch, window.fetch, or backupFetch\n            // is defined, so requests won't fail at runtime.\n            checkFetcher(preferredFetch || backupFetch);\n        }\n        const linkConfig = {\n            http: compact({ includeExtensions, preserveHeaderCase }),\n            options: requestOptions.fetchOptions,\n            credentials: requestOptions.credentials,\n            headers: requestOptions.headers,\n        };\n        this.batchDebounce = batchDebounce;\n        this.batchInterval = batchInterval || 10;\n        this.batchMax = batchMax || 10;\n        const batchHandler = (operations) => {\n            const chosenURI = selectURI(operations[0], uri);\n            const context = operations[0].getContext();\n            const contextConfig = {\n                http: context.http,\n                options: context.fetchOptions,\n                credentials: context.credentials,\n                headers: context.headers,\n            };\n            //uses fallback, link, and then context to build options\n            const optsAndBody = operations.map((operation) => {\n                const result = selectHttpOptionsAndBodyInternal(operation, print, fallbackHttpConfig, linkConfig, contextConfig);\n                if (result.body.variables && !includeUnusedVariables) {\n                    result.body.variables = filterOperationVariables(result.body.variables, operation.query);\n                }\n                return result;\n            });\n            const loadedBody = optsAndBody.map(({ body }) => body);\n            const options = optsAndBody[0].options;\n            // There's no spec for using GET with batches.\n            if (options.method === \"GET\") {\n                return throwError(() => new Error(\"apollo-link-batch-http does not support GET requests\"));\n            }\n            try {\n                options.body = JSON.stringify(loadedBody);\n            }\n            catch (parseError) {\n                return throwError(() => parseError);\n            }\n            let controller;\n            if (!options.signal && typeof AbortController !== \"undefined\") {\n                controller = new AbortController();\n                options.signal = controller.signal;\n            }\n            return new Observable((observer) => {\n                // Prefer BatchHttpLink.Options.fetch (preferredFetch) if provided, and\n                // otherwise fall back to the *current* global window.fetch function\n                // (see issue #7832), or (if all else fails) the backupFetch function we\n                // saved when this module was first evaluated. This last option protects\n                // against the removal of window.fetch, which is unlikely but not\n                // impossible.\n                const currentFetch = preferredFetch || maybe(() => fetch) || backupFetch;\n                currentFetch(chosenURI, options)\n                    .then((response) => {\n                    // Make the raw response available in the context.\n                    operations.forEach((operation) => operation.setContext({ response }));\n                    return response;\n                })\n                    .then(parseAndCheckHttpResponse(operations))\n                    .then((result) => {\n                    controller = undefined;\n                    // we have data and can send it to back up the link chain\n                    observer.next(result);\n                    observer.complete();\n                    return result;\n                })\n                    .catch((err) => {\n                    controller = undefined;\n                    observer.error(err);\n                });\n                return () => {\n                    // XXX support canceling this request\n                    // https://developers.google.com/web/updates/2017/09/abortable-fetch\n                    if (controller)\n                        controller.abort();\n                };\n            });\n        };\n        batchKey =\n            batchKey ||\n                ((operation) => {\n                    const context = operation.getContext();\n                    const contextConfig = {\n                        http: context.http,\n                        options: context.fetchOptions,\n                        credentials: context.credentials,\n                        headers: context.headers,\n                    };\n                    //may throw error if config not serializable\n                    return selectURI(operation, uri) + JSON.stringify(contextConfig);\n                });\n        this.batcher = new BatchLink({\n            batchDebounce: this.batchDebounce,\n            batchInterval: this.batchInterval,\n            batchMax: this.batchMax,\n            batchKey,\n            batchHandler,\n        });\n    }\n    request(operation, forward) {\n        return this.batcher.request(operation, forward);\n    }\n}\n//# sourceMappingURL=BaseBatchHttpLink.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;AAQA,IAAM,IAAc,QAAY,MAAM,EA0BzB,IAAb,cAAuC,EAAW;CAC9C;CACA;CACA;CACA;CACA,YAAY,IAAU,EAAE,EAAE;AACtB,SAAO;EACP,IAAI,EAAE,SAAM,YAEZ,OAAO,GAAgB,WAAQ,GAAgB,sBAAmB,uBAAoB,kBAAe,kBAAe,aAAU,aAAU,4BAAyB,IAAO,GAAG,MAAmB,GAMxL,IAAa;GACf,MAAM,EAAQ;IAAE;IAAmB;IAAoB,CAAC;GACxD,SAAS,EAAe;GACxB,aAAa,EAAe;GAC5B,SAAS,EAAe;GAC3B;AAqFD,EApFA,KAAK,gBAAgB,GACrB,KAAK,gBAAgB,KAAiB,IACtC,KAAK,WAAW,KAAY,IAqE5B,QAEU,MAAc;GACZ,IAAM,IAAU,EAAU,YAAY,EAChC,IAAgB;IAClB,MAAM,EAAQ;IACd,SAAS,EAAQ;IACjB,aAAa,EAAQ;IACrB,SAAS,EAAQ;IACpB;AAED,UAAO,EAAU,GAAW,EAAI,GAAG,KAAK,UAAU,EAAc;MAE5E,KAAK,UAAU,IAAI,EAAU;GACzB,eAAe,KAAK;GACpB,eAAe,KAAK;GACpB,UAAU,KAAK;GACf;GACA,eAtFkB,MAAe;IACjC,IAAM,IAAY,EAAU,EAAW,IAAI,EAAI,EACzC,IAAU,EAAW,GAAG,YAAY,EACpC,IAAgB;KAClB,MAAM,EAAQ;KACd,SAAS,EAAQ;KACjB,aAAa,EAAQ;KACrB,SAAS,EAAQ;KACpB,EAEK,IAAc,EAAW,KAAK,MAAc;KAC9C,IAAM,IAAS,EAAiC,GAAW,GAAO,GAAoB,GAAY,EAAc;AAIhH,YAHI,EAAO,KAAK,aAAa,CAAC,MAC1B,EAAO,KAAK,YAAY,EAAyB,EAAO,KAAK,WAAW,EAAU,MAAM,GAErF;MACT,EACI,IAAa,EAAY,KAAK,EAAE,cAAW,EAAK,EAChD,IAAU,EAAY,GAAG;AAE/B,QAAI,EAAQ,WAAW,MACnB,QAAO,QAAiB,gBAAI,MAAM,uDAAuD,CAAC;AAE9F,QAAI;AACA,OAAQ,OAAO,KAAK,UAAU,EAAW;aAEtC,GAAY;AACf,YAAO,QAAiB,EAAW;;IAEvC,IAAI;AAKJ,WAJI,CAAC,EAAQ,UAAU,OAAO,kBAAoB,QAC9C,IAAa,IAAI,iBAAiB,EAClC,EAAQ,SAAS,EAAW,SAEzB,IAAI,GAAY,QAOE,KAAkB,QAAY,MAAM,IAAI,GAChD,GAAW,EAAQ,CAC3B,MAAM,OAEP,EAAW,SAAS,MAAc,EAAU,WAAW,EAAE,aAAU,CAAC,CAAC,EAC9D,GACT,CACG,KAAK,EAA0B,EAAW,CAAC,CAC3C,MAAM,OACP,IAAa,KAAA,GAEb,EAAS,KAAK,EAAO,EACrB,EAAS,UAAU,EACZ,GACT,CACG,OAAO,MAAQ;AAEhB,KADA,IAAa,KAAA,GACb,EAAS,MAAM,EAAI;MACrB,QACW;AAGT,KAAI,KACA,EAAW,OAAO;OAE5B;;GAqBL,CAAC;;CAEN,QAAQ,GAAW,GAAS;AACxB,SAAO,KAAK,QAAQ,QAAQ,GAAW,EAAQ"}

package/dist/node_modules/@apollo/client/link/batch-http/batchHttpLink.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"batchHttpLink.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/link/batch-http/batchHttpLink.js"],"sourcesContent":["import { ApolloLink } from \"@apollo/client/link\";\nimport { ClientAwarenessLink } from \"@apollo/client/link/client-awareness\";\nimport { BaseBatchHttpLink } from \"./BaseBatchHttpLink.js\";\n/**\n * `BatchHttpLink` is a terminating link that batches array of individual\n * GraphQL operations into a single HTTP request that's sent to a single GraphQL\n * endpoint. It combines the functionality of `BaseBatchHttpLink` and\n * `ClientAwarenessLink` into a single link.\n *\n * @remarks\n *\n * If you use `BatchHttpLink` instead of `HttpLink` as your terminating link,\n * Apollo Client automatically batches executed GraphQL operations and transmits\n * them to your server according to the batching options you provide.\n *\n * @example\n *\n * ```ts\n * import { BatchHttpLink } from \"@apollo/client/link/batch-http\";\n *\n * const link = new BatchHttpLink({\n *   uri: \"http://localhost:4000/graphql\",\n *   batchMax: 5, // No more than 5 operations per batch\n *   batchInterval: 20, // Wait no more than 20ms after first batched operation\n * });\n * ```\n */\nexport class BatchHttpLink extends ApolloLink {\n    constructor(options = {}) {\n        const { left, right, request } = ApolloLink.from([\n            new ClientAwarenessLink(options),\n            new BaseBatchHttpLink(options),\n        ]);\n        super(request);\n        Object.assign(this, { left, right });\n    }\n}\n//# sourceMappingURL=batchHttpLink.js.map"],"x_google_ignoreList":[0],"mappings":";;;;AA2BA,IAAa,IAAb,cAAmC,EAAW;CAC1C,YAAY,IAAU,EAAE,EAAE;EACtB,IAAM,EAAE,SAAM,UAAO,eAAY,EAAW,KAAK,CAC7C,IAAI,EAAoB,EAAQ,EAChC,IAAI,EAAkB,EAAQ,CACjC,CAAC;AAEF,EADA,MAAM,EAAQ,EACd,OAAO,OAAO,MAAM;GAAE;GAAM;GAAO,CAAC"}

package/dist/node_modules/@apollo/client/link/client-awareness/ClientAwarenessLink.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClientAwarenessLink.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/link/client-awareness/ClientAwarenessLink.js"],"sourcesContent":["import { ApolloLink } from \"@apollo/client/link\";\nimport { compact } from \"@apollo/client/utilities/internal\";\n/**\n * `ClientAwarenessLink` provides support for providing client awareness\n * features.\n *\n * @remarks\n *\n * Client awareness adds identifying information about the client to HTTP\n * requests for use with metrics reporting tools, such as [Apollo GraphOS](https://apollographql.com/docs/graphos/platform).\n * It is included in the functionality of [`HttpLink`](https://apollographql.com/docs/react/api/link/apollo-link-http) by default.\n *\n * Client awareness distinguishes between user-provided client awareness\n * (provided by the `clientAwareness` option) and enhanced client awareness\n * (provided by the `enhancedClientAwareness` option). User-provided client\n * awareness enables you to set a customized client name and version for\n * identification in metrics reporting tools. Enhanced client awareness enables\n * the identification of the Apollo Client package name and version.\n *\n * @example\n *\n * ```ts\n * import { ClientAwarenessLink } from \"@apollo/client/link/client-awareness\";\n *\n * const link = new ClientAwarenessLink({\n *   clientAwareness: {\n *     name: \"My Client\",\n *     version: \"1\",\n *   },\n *   enhancedClientAwareness: {\n *     transport: \"extensions\",\n *   },\n * });\n * ```\n */\nexport class ClientAwarenessLink extends ApolloLink {\n    constructor(options = {}) {\n        super((operation, forward) => {\n            const client = operation.client;\n            const clientOptions = client[\"queryManager\"].clientOptions;\n            const context = operation.getContext();\n            {\n                const { name, version, transport = \"headers\", } = compact({}, clientOptions.clientAwareness, options.clientAwareness, context.clientAwareness);\n                if (transport === \"headers\") {\n                    operation.setContext(({ headers }) => {\n                        return {\n                            headers: compact(\n                            // setting these first so that they can be overridden by user-provided headers\n                            {\n                                \"apollographql-client-name\": name,\n                                \"apollographql-client-version\": version,\n                            }, headers),\n                        };\n                    });\n                }\n            }\n            {\n                const { transport = \"extensions\" } = compact({}, clientOptions.enhancedClientAwareness, options.enhancedClientAwareness);\n                if (transport === \"extensions\") {\n                    operation.extensions = compact(\n                    // setting these first so that it can be overridden by user-provided extensions\n                    {\n                        clientLibrary: {\n                            name: \"@apollo/client\",\n                            version: client.version,\n                        },\n                    }, operation.extensions);\n                }\n                if (transport === \"headers\") {\n                    operation.setContext(({ headers }) => {\n                        return {\n                            headers: compact(\n                            // setting these first so that they can be overridden by user-provided headers\n                            {\n                                \"apollographql-library-name\": \"@apollo/client\",\n                                \"apollographql-library-version\": client.version,\n                            }, headers),\n                        };\n                    });\n                }\n            }\n            return forward(operation);\n        });\n    }\n}\n//# sourceMappingURL=ClientAwarenessLink.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAmCA,IAAa,IAAb,cAAyC,EAAW;CAChD,YAAY,IAAU,EAAE,EAAE;AACtB,SAAO,GAAW,MAAY;GAC1B,IAAM,IAAS,EAAU,QACnB,IAAgB,EAAO,aAAgB,eACvC,IAAU,EAAU,YAAY;GACtC;IACI,IAAM,EAAE,SAAM,YAAS,eAAY,cAAe,EAAQ,EAAE,EAAE,EAAc,iBAAiB,EAAQ,iBAAiB,EAAQ,gBAAgB;AAC9I,IAAI,MAAc,aACd,EAAU,YAAY,EAAE,kBACb,EACH,SAAS,EAET;KACI,6BAA6B;KAC7B,gCAAgC;KACnC,EAAE,EAAQ,EACd,EACH;;GAGV;IACI,IAAM,EAAE,eAAY,iBAAiB,EAAQ,EAAE,EAAE,EAAc,yBAAyB,EAAQ,wBAAwB;AAWxH,IAVI,MAAc,iBACd,EAAU,aAAa,EAEvB,EACI,eAAe;KACX,MAAM;KACN,SAAS,EAAO;KACnB,EACJ,EAAE,EAAU,WAAW,GAExB,MAAc,aACd,EAAU,YAAY,EAAE,kBACb,EACH,SAAS,EAET;KACI,8BAA8B;KAC9B,iCAAiC,EAAO;KAC3C,EAAE,EAAQ,EACd,EACH;;AAGV,UAAO,EAAQ,EAAU;IAC3B"}

package/dist/node_modules/@apollo/client/link/core/ApolloLink.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ApolloLink.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/link/core/ApolloLink.js"],"sourcesContent":["import { EMPTY } from \"rxjs\";\nimport { createOperation } from \"@apollo/client/link/utils\";\nimport { __DEV__ } from \"@apollo/client/utilities/environment\";\nimport { invariant, newInvariantError, } from \"@apollo/client/utilities/invariant\";\n/**\n * The base class for all links in Apollo Client. A link represents either a\n * self-contained modification to a GraphQL operation or a side effect (such as\n * logging).\n *\n * @remarks\n *\n * Links enable you to customize Apollo Client's request flow by composing\n * together different pieces of functionality into a chain of links. Each\n * link represents a specific capability, such as adding authentication headers,\n * retrying failed requests, batching operations, or sending requests to a\n * GraphQL server.\n *\n * Every link must define a request handler via its constructor or by extending\n * this class and implementing the `request` method.\n *\n * @example\n *\n * ```ts\n * import { ApolloLink } from \"@apollo/client\";\n *\n * const link = new ApolloLink((operation, forward) => {\n *   console.log(\"Operation:\", operation.operationName);\n *   return forward(operation);\n * });\n * ```\n */\nexport class ApolloLink {\n    /**\n     * Creates a link that completes immediately and does not emit a result.\n     *\n     * @example\n     *\n     * ```ts\n     * const link = ApolloLink.empty();\n     * ```\n     */\n    static empty() {\n        return new ApolloLink(() => EMPTY);\n    }\n    /**\n     * Composes multiple links into a single composed link that executes each\n     * provided link in serial order.\n     *\n     * @example\n     *\n     * ```ts\n     * import { from, HttpLink, ApolloLink } from \"@apollo/client\";\n     * import { RetryLink } from \"@apollo/client/link/retry\";\n     * import MyAuthLink from \"../auth\";\n     *\n     * const link = ApolloLink.from([\n     *   new RetryLink(),\n     *   new MyAuthLink(),\n     *   new HttpLink({ uri: \"http://localhost:4000/graphql\" }),\n     * ]);\n     * ```\n     *\n     * @param links - An array of `ApolloLink` instances or request handlers that\n     * are executed in serial order.\n     */\n    static from(links) {\n        if (links.length === 0)\n            return ApolloLink.empty();\n        const [first, ...rest] = links;\n        return first.concat(...rest);\n    }\n    /**\n     * Creates a link that conditionally routes a request to different links.\n     *\n     * @example\n     *\n     * ```ts\n     * import { ApolloLink, HttpLink } from \"@apollo/client\";\n     *\n     * const link = ApolloLink.split(\n     *   (operation) => operation.getContext().version === 1,\n     *   new HttpLink({ uri: \"http://localhost:4000/v1/graphql\" }),\n     *   new HttpLink({ uri: \"http://localhost:4000/v2/graphql\" })\n     * );\n     * ```\n     *\n     * @param test - A predicate function that receives the current `operation`\n     * and returns a boolean indicating which link to execute. Returning `true`\n     * executes the `left` link. Returning `false` executes the `right` link.\n     *\n     * @param left - The link that executes when the `test` function returns\n     * `true`.\n     *\n     * @param right - The link that executes when the `test` function returns\n     * `false`. If the `right` link is not provided, the request is forwarded to\n     * the next link in the chain.\n     */\n    static split(test, left, right = new ApolloLink((op, forward) => forward(op))) {\n        const link = new ApolloLink((operation, forward) => {\n            const result = test(operation);\n            if (__DEV__) {\n                if (typeof result !== \"boolean\") {\n                    __DEV__ && invariant.warn(63, result);\n                }\n            }\n            return result ?\n                left.request(operation, forward)\n                : right.request(operation, forward);\n        });\n        return Object.assign(link, { left, right });\n    }\n    /**\n     * Executes a GraphQL request against a link. The `execute` function begins\n     * the request by calling the request handler of the link.\n     *\n     * @example\n     *\n     * ```ts\n     * const observable = ApolloLink.execute(link, { query, variables }, { client });\n     *\n     * observable.subscribe({\n     *   next(value) {\n     *     console.log(\"Received\", value);\n     *   },\n     *   error(error) {\n     *     console.error(\"Oops got error\", error);\n     *   },\n     *   complete() {\n     *     console.log(\"Request complete\");\n     *   },\n     * });\n     * ```\n     *\n     * @param link - The `ApolloLink` instance to execute the request.\n     *\n     * @param request - The GraphQL request details, such as the `query` and\n     * `variables`.\n     *\n     * @param context - The execution context for the request, such as the\n     * `client` making the request.\n     */\n    static execute(link, request, context) {\n        return link.request(createOperation(request, context), () => {\n            if (__DEV__) {\n                __DEV__ && invariant.warn(64);\n            }\n            return EMPTY;\n        });\n    }\n    /**\n     * Combines multiple links into a single composed link.\n     *\n     * @example\n     *\n     * ```ts\n     * const link = ApolloLink.concat(firstLink, secondLink, thirdLink);\n     * ```\n     *\n     * @param links - The links to concatenate into a single link. Each link will\n     * execute in serial order.\n     *\n     * @deprecated Use `ApolloLink.from` instead. `ApolloLink.concat` will be\n     * removed in a future major version.\n     */\n    static concat(...links) {\n        return ApolloLink.from(links);\n    }\n    constructor(request) {\n        if (request)\n            this.request = request;\n    }\n    /**\n     * Concatenates a link that conditionally routes a request to different links.\n     *\n     * @example\n     *\n     * ```ts\n     * import { ApolloLink, HttpLink } from \"@apollo/client\";\n     *\n     * const previousLink = new ApolloLink((operation, forward) => {\n     *   // Handle the request\n     *\n     *   return forward(operation);\n     * });\n     *\n     * const link = previousLink.split(\n     *   (operation) => operation.getContext().version === 1,\n     *   new HttpLink({ uri: \"http://localhost:4000/v1/graphql\" }),\n     *   new HttpLink({ uri: \"http://localhost:4000/v2/graphql\" })\n     * );\n     * ```\n     *\n     * @param test - A predicate function that receives the current `operation`\n     * and returns a boolean indicating which link to execute. Returning `true`\n     * executes the `left` link. Returning `false` executes the `right` link.\n     *\n     * @param left - The link that executes when the `test` function returns\n     * `true`.\n     *\n     * @param right - The link that executes when the `test` function returns\n     * `false`. If the `right` link is not provided, the request is forwarded to\n     * the next link in the chain.\n     */\n    split(test, left, right) {\n        return this.concat(ApolloLink.split(test, left, right));\n    }\n    /**\n     * Combines the link with other links into a single composed link.\n     *\n     * @example\n     *\n     * ```ts\n     * import { ApolloLink, HttpLink } from \"@apollo/client\";\n     *\n     * const previousLink = new ApolloLink((operation, forward) => {\n     *   // Handle the request\n     *\n     *   return forward(operation);\n     * });\n     *\n     * const link = previousLink.concat(\n     *   link1,\n     *   link2,\n     *   new HttpLink({ uri: \"http://localhost:4000/graphql\" })\n     * );\n     * ```\n     */\n    concat(...links) {\n        if (links.length === 0) {\n            return this;\n        }\n        return links.reduce(this.combine.bind(this), this);\n    }\n    combine(left, right) {\n        const link = new ApolloLink((operation, forward) => {\n            return left.request(operation, (op) => right.request(op, forward));\n        });\n        return Object.assign(link, { left, right });\n    }\n    /**\n     * Runs the request handler for the provided operation.\n     *\n     * > [!NOTE]\n     * > This is called by the `ApolloLink.execute` function for you and should\n     * > not be called directly. Prefer using `ApolloLink.execute` to make the\n     * > request instead.\n     */\n    request(operation, forward) {\n        throw newInvariantError(65);\n    }\n    /**\n    * @internal\n    * Used to iterate through all links that are concatenations or `split` links.\n    * \n    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n    */\n    left;\n    /**\n    * @internal\n    * Used to iterate through all links that are concatenations or `split` links.\n    * \n    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n    */\n    right;\n}\n//# sourceMappingURL=ApolloLink.js.map\n"],"x_google_ignoreList":[0],"mappings":";;;;AA+BA,IAAa,IAAb,MAAa,EAAW;CAUpB,OAAO,QAAQ;AACX,SAAO,IAAI,QAAiB,EAAM;;CAuBtC,OAAO,KAAK,GAAO;AACf,MAAI,EAAM,WAAW,EACjB,QAAO,EAAW,OAAO;EAC7B,IAAM,CAAC,GAAO,GAAG,KAAQ;AACzB,SAAO,EAAM,OAAO,GAAG,EAAK;;CA4BhC,OAAO,MAAM,GAAM,GAAM,IAAQ,IAAI,GAAY,GAAI,MAAY,EAAQ,EAAG,CAAC,EAAE;EAC3E,IAAM,IAAO,IAAI,GAAY,GAAW,MACrB,EAAK,EAAU,GAO1B,EAAK,QAAQ,GAAW,EAAQ,GAC9B,EAAM,QAAQ,GAAW,EAAQ,CACzC;AACF,SAAO,OAAO,OAAO,GAAM;GAAE;GAAM;GAAO,CAAC;;CAgC/C,OAAO,QAAQ,GAAM,GAAS,GAAS;AACnC,SAAO,EAAK,QAAQ,EAAgB,GAAS,EAAQ,QAI1C,EACT;;CAiBN,OAAO,OAAO,GAAG,GAAO;AACpB,SAAO,EAAW,KAAK,EAAM;;CAEjC,YAAY,GAAS;AACjB,EAAI,MACA,KAAK,UAAU;;CAkCvB,MAAM,GAAM,GAAM,GAAO;AACrB,SAAO,KAAK,OAAO,EAAW,MAAM,GAAM,GAAM,EAAM,CAAC;;CAuB3D,OAAO,GAAG,GAAO;AAIb,SAHI,EAAM,WAAW,IACV,OAEJ,EAAM,OAAO,KAAK,QAAQ,KAAK,KAAK,EAAE,KAAK;;CAEtD,QAAQ,GAAM,GAAO;EACjB,IAAM,IAAO,IAAI,GAAY,GAAW,MAC7B,EAAK,QAAQ,IAAY,MAAO,EAAM,QAAQ,GAAI,EAAQ,CAAC,CACpE;AACF,SAAO,OAAO,OAAO,GAAM;GAAE;GAAM;GAAO,CAAC;;CAU/C,QAAQ,GAAW,GAAS;AACxB,QAAM,EAAkB,GAAG;;CAQ/B;CAOA"}

package/dist/node_modules/@apollo/client/link/http/checkFetcher.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"checkFetcher.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/link/http/checkFetcher.js"],"sourcesContent":["import { invariant } from \"@apollo/client/utilities/invariant\";\nexport const checkFetcher = (fetcher) => {\n    invariant(fetcher || typeof fetch !== \"undefined\", 61);\n};\n//# sourceMappingURL=checkFetcher.js.map\n"],"x_google_ignoreList":[0],"mappings":";;AACA,IAAa,KAAgB,MAAY;AACrC,GAAU,KAAW,OAAO,QAAU,KAAa,GAAG"}