@bodhiapp/bodhi-js-react-ext 0.0.11

package/dist/bodhi-browser-ext/src/types/bodhiext.d.ts

@@ -0,0 +1,201 @@
+import { OpenAiApiError, PingResponse, CreateChatCompletionRequest, CreateChatCompletionResponse, CreateChatCompletionStreamResponse } from '@bodhiapp/ts-client';
+/**
+ * HTTP response wrapper - body can be success type OR error type
+ * Use isApiErrorResponse() to narrow the type based on status
+ */
+export interface ApiResponse<T = unknown> {
+    body: T | OpenAiApiError;
+    status: number;
+    headers: Record<string, string>;
+}
+/**
+ * Stream chunk returned by sendStreamRequest
+ *
+ * This is the chunk structure yielded by the ReadableStream from sendStreamRequest.
+ * Different from StreamChunkMessage which is the internal message wrapper.
+ */
+export interface StreamChunk {
+    body: unknown;
+    headers?: Record<string, string>;
+    status?: number;
+    done?: boolean;
+}
+/**
+ * Server state information returned by /bodhi/v1/info endpoint
+ */
+export interface ServerStateInfo {
+    /** Current application status */
+    status: 'setup' | 'ready' | 'resource-admin' | 'error' | 'unreachable';
+    /** Application version */
+    version?: string;
+    /** Server URL (added by extension) */
+    url?: string;
+    /** Error details if status is 'error' or 'unreachable' */
+    error?: {
+        message: string;
+        type?: string;
+        code?: string;
+        param?: string;
+    };
+}
+/**
+ * API error thrown when server returns HTTP 4xx/5xx
+ * Used for streaming responses (non-streaming returns ApiResponse)
+ */
+export interface ApiError extends Error {
+    response: {
+        status: number;
+        body: OpenAiApiError;
+        headers?: Record<string, string>;
+    };
+}
+/**
+ * Operation error thrown when HTTP request couldn't complete
+ * (network unreachable, timeout, extension error)
+ */
+export interface OperationError extends Error {
+    error: {
+        message: string;
+        type: string;
+    };
+}
+/**
+ * Union of all extension-thrown errors
+ */
+export type ExtensionError = ApiError | OperationError;
+/**
+ * Type guard: API error (has response field)
+ */
+export declare function isApiError(err: unknown): err is ApiError;
+/**
+ * Type guard: Operation error (has error field, no response)
+ */
+export declare function isOperationError(err: unknown): err is OperationError;
+/**
+ * Chat API uses types from @bodhiapp/ts-client.
+ * Consumers should import these types directly from @bodhiapp/ts-client:
+ * - ChatCompletionRequestMessage
+ * - ChatCompletionResponseMessage
+ * - CreateChatCompletionRequest
+ * - CreateChatCompletionResponse
+ * - CreateChatCompletionStreamResponse
+ * - ChatChoice
+ * - ChatChoiceStream
+ * - ChatCompletionStreamResponseDelta
+ */
+/**
+ * Chat completions API interface
+ */
+export interface ChatCompletionsApi {
+    /**
+     * Create a chat completion
+     *
+     * Non-streaming: Returns ApiResponse - caller checks status for success/error
+     * Streaming: Yields chunks via AsyncIterable - throws ApiError or OperationError on error
+     *
+     * @param params - Chat completion parameters
+     * @returns Non-streaming: Promise<ApiResponse<CreateChatCompletionResponse>>, Streaming: AsyncIterable<CreateChatCompletionStreamResponse>
+     */
+    create(params: CreateChatCompletionRequest & {
+        stream?: false;
+    }): Promise<ApiResponse<CreateChatCompletionResponse>>;
+    create(params: CreateChatCompletionRequest & {
+        stream: true;
+    }): AsyncIterable<CreateChatCompletionStreamResponse>;
+    create(params: CreateChatCompletionRequest): Promise<ApiResponse<CreateChatCompletionResponse>> | AsyncIterable<CreateChatCompletionStreamResponse>;
+}
+/**
+ * Chat API namespace
+ */
+export interface ChatApi {
+    completions: ChatCompletionsApi;
+}
+/**
+ * Public window.bodhiext interface
+ *
+ * This interface defines all methods available to web pages through window.bodhiext.
+ * The extension creates this interface in inject.ts and attaches it to the window object.
+ */
+export interface BodhiExtPublicApi {
+    /**
+     * Send a generic API request through the extension to the backend server.
+     *
+     * @template TReq - Request body type (inferred from body parameter)
+     * @template TRes - Response body type (must be specified explicitly)
+     * @param method - HTTP method (GET, POST, PUT, DELETE, etc.)
+     * @param endpoint - API endpoint path (e.g., '/v1/chat/completions')
+     * @param body - Optional request body (will be JSON stringified)
+     * @param headers - Optional additional headers
+     * @returns Promise resolving to ApiResponse with body, headers, and status
+     */
+    sendApiRequest<TReq = unknown, TRes = unknown>(method: string, endpoint: string, body?: TReq, headers?: Record<string, string>): Promise<ApiResponse<TRes>>;
+    /**
+     * Send a streaming API request through the extension.
+     *
+     * Used for SSE (Server-Sent Events) endpoints like streaming chat completions.
+     * Returns a ReadableStream that yields StreamChunk objects.
+     *
+     * @template TReq - Request body type (inferred from body parameter)
+     * @param method - HTTP method (typically POST for streaming)
+     * @param endpoint - API endpoint path (e.g., '/v1/chat/completions')
+     * @param body - Optional request body
+     * @param headers - Optional additional headers
+     * @returns ReadableStream yielding StreamChunk objects
+     */
+    sendStreamRequest<TReq = unknown>(method: string, endpoint: string, body?: TReq, headers?: Record<string, string>): ReadableStream<StreamChunk>;
+    /**
+     * Send a generic extension request.
+     *
+     * Used for extension-specific operations like test_connection, get_extension_id, etc.
+     * This is a low-level API for extension capabilities.
+     *
+     * @param action - Extension action name (e.g., 'test_connection')
+     * @param params - Optional action parameters
+     * @returns Promise resolving to action-specific response
+     */
+    sendExtRequest(action: string, params?: any): Promise<any>;
+    /**
+     * Simple health check to verify extension connectivity.
+     *
+     * Returns ApiResponse - caller should check status to determine success/error.
+     * On success (2xx), body is PingResponse. On error (4xx/5xx), body is OpenAiApiError.
+     *
+     * @returns Promise resolving to ApiResponse<PingResponse>
+     */
+    ping(): Promise<ApiResponse<PingResponse>>;
+    /**
+     * Get server state information from /bodhi/v1/info endpoint.
+     *
+     * Returns the current status of the backend server including
+     * whether it's in setup mode, ready, or has errors.
+     *
+     * @returns Promise resolving to ServerStateInfo
+     */
+    serverState(): Promise<ServerStateInfo>;
+    /**
+     * OpenAI-compatible chat API.
+     *
+     * Provides chat completion functionality compatible with OpenAI's API structure.
+     */
+    chat: ChatApi;
+    /**
+     * Get the extension ID.
+     *
+     * The extension ID is fetched asynchronously during initialization.
+     * This method returns a promise that resolves to the extension ID once available.
+     *
+     * @returns Promise resolving to the extension ID string
+     */
+    getExtensionId(): Promise<string>;
+}
+/**
+ * Window augmentation for TypeScript
+ *
+ * Declares the optional bodhiext property on the Window interface.
+ * This allows TypeScript code to access window.bodhiext with proper typing.
+ */
+declare global {
+    interface Window {
+        bodhiext?: BodhiExtPublicApi;
+    }
+}

package/dist/bodhi-browser-ext/src/types/common.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared constants for Bodhi Browser Extension
+ *
+ * Constants used by both inject.ts and background/content.ts scripts,
+ * or common to the entire extension.
+ */
+export declare const CONTENT_TYPE_JSON = "application/json";
+export declare const CONTENT_TYPE_EVENT_STREAM = "text/event-stream";
+export declare const CONTENT_TYPE_HEADER = "Content-Type";
+export declare const HTTP_METHOD_GET = "GET";
+export declare const HTTP_METHOD_POST = "POST";
+export declare const ENDPOINT_PING = "/ping";
+export declare const ENDPOINT_CHAT_COMPLETIONS = "/v1/chat/completions";
+export declare const DEFAULT_API_BASE_URL = "http://localhost:1135";
+export declare const DEFAULT_API_TIMEOUT = 10000;
+export declare const DEFAULT_STREAM_TIMEOUT = 60000;
+export declare const STORAGE_KEY_BACKEND_URL = "backendUrl";
+export declare const SSE_DONE_MARKER = "[DONE]";
+export declare const SSE_DATA_PREFIX = "data: ";
+export declare const SSE_CHUNK_DELIMITER = "\n\n";
+export declare const EXT_ACTIONS: {
+    readonly GET_EXTENSION_ID: "get_extension_id";
+    readonly TEST_CONNECTION: "test_connection";
+};
+export declare const ERROR_TYPES: {
+    readonly NETWORK_ERROR: "network_error";
+    readonly EXTENSION_ERROR: "extension_error";
+    readonly TIMEOUT_ERROR: "timeout_error";
+    readonly AUTH_ERROR: "auth_error";
+};
+export type ConnectionErrorType = (typeof ERROR_TYPES)[keyof typeof ERROR_TYPES];
+export declare const DOCUMENT_STATE_COMPLETE = "complete";
+export declare const EVENT_INITIALIZED = "bodhiext:initialized";
+export declare const BODHI_STREAM_PORT = "BODHI_STREAM_PORT";
+export declare const ORIGIN_WILDCARD = "*";
+export declare const ERROR_MISSING_REQUEST_ID = "Invalid message format: missing requestId or request";
+export declare const ERROR_CONNECTION_CLOSED = "Connection closed unexpectedly";

package/dist/bodhi-browser-ext/src/types/index.d.ts

@@ -0,0 +1,6 @@
+export type { ApiResponse, StreamChunk, ServerStateInfo, ApiError, OperationError, ExtensionError, ChatCompletionsApi, ChatApi, BodhiExtPublicApi } from './bodhiext';
+export { isApiError, isOperationError } from './bodhiext';
+export type { ApiRequest, ApiRequestMessage, OperationErrorResponse, ApiResponseSuccessMessage, OperationErrorResponseMessage, ApiResponseMessage, ErrorMessage, StreamChunkMessage, StreamApiErrorMessage, StreamErrorMessage, StreamMessage, StreamController, SSEChunk, ExtRequest, ExtRequestMessage, ExtError, ExtErrorResponse, ExtResponse, ExtResponseMessage, GetExtensionIdRequest, GetExtensionIdResponse, TestConnectionRequest, TestConnectionResponse, } from './protocol';
+export { MESSAGE_TYPES, isOperationErrorResponse, isApiErrorResponse, isApiSuccessResponse, isStreamChunk, isStreamApiError, isStreamError, isExtError, isOpenAiApiErrorBody, isOperationErrorStructure, } from './protocol';
+export { CONTENT_TYPE_JSON, CONTENT_TYPE_EVENT_STREAM, CONTENT_TYPE_HEADER, HTTP_METHOD_GET, HTTP_METHOD_POST, ENDPOINT_PING, ENDPOINT_CHAT_COMPLETIONS, DEFAULT_API_BASE_URL, DEFAULT_API_TIMEOUT, DEFAULT_STREAM_TIMEOUT, STORAGE_KEY_BACKEND_URL, SSE_DONE_MARKER, SSE_DATA_PREFIX, SSE_CHUNK_DELIMITER, EXT_ACTIONS, ERROR_TYPES, DOCUMENT_STATE_COMPLETE, EVENT_INITIALIZED, BODHI_STREAM_PORT, ORIGIN_WILDCARD, ERROR_MISSING_REQUEST_ID, ERROR_CONNECTION_CLOSED, } from './common';
+export type { ConnectionErrorType } from './common';

package/dist/bodhi-browser-ext/src/types/protocol.d.ts

@@ -0,0 +1,222 @@
+import { OpenAiApiError, ErrorBody } from '@bodhiapp/ts-client';
+import { ApiResponse, ServerStateInfo } from './bodhiext';
+/**
+ * Validate OpenAI API error body structure
+ * { error: { message: string, type: string } }
+ */
+export declare function isOpenAiApiErrorBody(body: unknown): body is OpenAiApiError;
+/**
+ * Validate OperationErrorResponse structure
+ * { message: string, type: string }
+ */
+export declare function isOperationErrorStructure(obj: unknown): obj is OperationErrorResponse;
+export declare const MESSAGE_TYPES: {
+    readonly API_REQUEST: "BODHI_API_REQUEST";
+    readonly API_RESPONSE: "BODHI_API_RESPONSE";
+    readonly STREAM_REQUEST: "BODHI_STREAM_REQUEST";
+    readonly STREAM_CHUNK: "BODHI_STREAM_CHUNK";
+    readonly STREAM_ERROR: "BODHI_STREAM_ERROR";
+    readonly STREAM_API_ERROR: "BODHI_STREAM_API_ERROR";
+    readonly ERROR: "BODHI_ERROR";
+    readonly EXT_REQUEST: "BODHI_EXT_REQUEST";
+    readonly EXT_RESPONSE: "BODHI_EXT_RESPONSE";
+};
+export interface ApiRequest<T = unknown> {
+    method: string;
+    endpoint: string;
+    body?: T;
+    headers?: Record<string, string>;
+}
+export interface ApiRequestMessage<TReq = unknown> {
+    type: string;
+    requestId: string;
+    request: ApiRequest<TReq>;
+}
+/**
+ * Operation-level error response (network unreachable, timeout, extension error)
+ * NOT an API error (those come through ApiResponse with OpenAiApiError body)
+ * This is a response type, not a thrown error
+ */
+export interface OperationErrorResponse {
+    message: string;
+    type: string;
+}
+/**
+ * Success API response message (HTTP request completed, regardless of status code)
+ */
+export interface ApiResponseSuccessMessage<T = unknown> {
+    type: string;
+    requestId: string;
+    response: ApiResponse<T>;
+}
+/**
+ * Operation error response message - HTTP request couldn't complete
+ */
+export interface OperationErrorResponseMessage {
+    type: string;
+    requestId: string;
+    error: OperationErrorResponse;
+}
+/**
+ * API response message - discriminated union
+ */
+export type ApiResponseMessage<T = unknown> = ApiResponseSuccessMessage<T> | OperationErrorResponseMessage;
+/**
+ * Type guard for operation error response
+ */
+export declare function isOperationErrorResponse(msg: ApiResponseMessage): msg is OperationErrorResponseMessage;
+/**
+ * Type guard to check if response is an API error (4xx/5xx)
+ * Narrows body type to OpenAiApiError
+ */
+export declare function isApiErrorResponse<T>(response: ApiResponse<T>): response is ApiResponse<T> & {
+    body: OpenAiApiError;
+    status: number;
+};
+/**
+ * Type guard to check if response is successful (2xx)
+ * Narrows body type to T
+ */
+export declare function isApiSuccessResponse<T>(response: ApiResponse<T>): response is ApiResponse<T> & {
+    body: T;
+    status: number;
+};
+export interface ErrorMessage {
+    type: string;
+    requestId: string;
+    response: {
+        body: ErrorBody;
+        status: number;
+        headers: Record<string, string>;
+    };
+}
+/**
+ * Stream chunk message - successful SSE chunk received
+ * Uses ApiResponse<T> wrapper for consistency with non-streaming pattern
+ */
+export interface StreamChunkMessage<T = unknown> {
+    type: typeof MESSAGE_TYPES.STREAM_CHUNK;
+    requestId: string;
+    response: ApiResponse<T>;
+}
+/**
+ * Stream API error message - server returned error response (not SSE)
+ * E.g., 400/401/500 JSON error instead of SSE stream
+ */
+export interface StreamApiErrorMessage {
+    type: typeof MESSAGE_TYPES.STREAM_API_ERROR;
+    requestId: string;
+    response: ApiResponse<OpenAiApiError>;
+}
+/**
+ * Stream error message - network/extension level error
+ * E.g., connection refused, timeout, extension error
+ */
+export interface StreamErrorMessage {
+    type: typeof MESSAGE_TYPES.STREAM_ERROR;
+    requestId: string;
+    error: OperationErrorResponse;
+}
+/**
+ * Union type for all streaming messages
+ */
+export type StreamMessage<T = unknown> = StreamChunkMessage<T> | StreamApiErrorMessage | StreamErrorMessage;
+/**
+ * Type guard for stream chunk message
+ */
+export declare function isStreamChunk<T>(msg: StreamMessage<T>): msg is StreamChunkMessage<T>;
+/**
+ * Type guard for stream API error
+ */
+export declare function isStreamApiError(msg: StreamMessage): msg is StreamApiErrorMessage;
+/**
+ * Type guard for stream error
+ */
+export declare function isStreamError(msg: StreamMessage): msg is StreamErrorMessage;
+/**
+ * Interface for stream controller to handle SSE responses
+ */
+export interface StreamController {
+    enqueue: (chunk: any) => void;
+    error: (err: Error) => void;
+    complete: () => void;
+}
+/**
+ * Interface for SSE data chunk
+ */
+export interface SSEChunk {
+    done?: boolean;
+    [key: string]: any;
+}
+/**
+ * Generic extension request interface
+ */
+export interface ExtRequest {
+    action: string;
+    params?: any;
+}
+/**
+ * Generic extension request message
+ */
+export interface ExtRequestMessage {
+    type: 'BODHI_EXT_REQUEST';
+    requestId: string;
+    request: ExtRequest;
+}
+/**
+ * Extension-level error structure
+ */
+export interface ExtError {
+    message: string;
+    type?: string;
+}
+/**
+ * Error response for extension operations
+ */
+export interface ExtErrorResponse {
+    error: ExtError;
+}
+/**
+ * Union type for extension response (flattened - no wrapper for success)
+ * Success: T (the actual response data)
+ * Error: { error: ExtError }
+ */
+export type ExtResponse<T = unknown> = T | ExtErrorResponse;
+/**
+ * Type guard to check if extension response is an error
+ */
+export declare function isExtError<T>(res: ExtResponse<T>): res is ExtErrorResponse;
+/**
+ * Generic extension response message
+ */
+export interface ExtResponseMessage<T = unknown> {
+    type: 'BODHI_EXT_RESPONSE';
+    requestId: string;
+    response: ExtResponse<T>;
+}
+/**
+ * Get Extension ID request (no params needed)
+ */
+export interface GetExtensionIdRequest extends ExtRequest {
+    action: 'get_extension_id';
+    params?: undefined;
+}
+/**
+ * Get Extension ID response body
+ */
+export interface GetExtensionIdResponse {
+    extension_id: string;
+}
+/**
+ * Test Connection request
+ */
+export interface TestConnectionRequest extends ExtRequest {
+    action: 'test_connection';
+    params: {
+        url: string;
+    };
+}
+/**
+ * Test Connection response body (reuses ServerStateInfo)
+ */
+export type TestConnectionResponse = ServerStateInfo;

package/dist/bodhi-js-sdk/react-ext/src/BodhiProvider.d.ts

@@ -0,0 +1,8 @@
+import { ExtUIClientParams } from '../../ext/src/index.ts';
+import { BodhiProviderProps as CoreBodhiProviderProps, UIClient } from '../../react-core/src/index.ts';
+export interface BodhiProviderProps extends Omit<CoreBodhiProviderProps, 'client'> {
+    authClientId?: string;
+    clientConfig?: ExtUIClientParams;
+    client?: UIClient;
+}
+export declare function BodhiProvider({ children, authClientId, clientConfig, client: providedClient, basePath, ...restProps }: BodhiProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/bodhi-js-sdk/react-ext/src/api/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Re-export all OpenAI-compatible types from @bodhiapp/bodhi-js-core/api
+ *
+ * Usage:
+ * import type { CreateChatCompletionRequest, Model } from '@bodhiapp/bodhi-js-react-ext/api';
+ */
+export * from '../../../core/src/index.ts/api';

package/dist/bodhi-js-sdk/react-ext/src/build-info.d.ts

@@ -0,0 +1 @@
+export declare const BUILD_MODE: string;

package/dist/bodhi-js-sdk/react-ext/src/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @bodhiapp/bodhi-js-react-ext - React bindings for Bodhi Browser SDK (Extension preset)
+ *
+ * Preset package that auto-creates ExtUIClient for simplified developer experience in Chrome extensions.
+ * For advanced usage with custom client configuration, use @bodhiapp/bodhi-js-react-core.
+ */
+export { BodhiProvider, type BodhiProviderProps } from './BodhiProvider';
+export { ExtUIClient, type ExtUIClientParams } from '../../ext/src/index.ts';
+export { BodhiReactContext, useBodhi, type BodhiContext, type SetupState, type ClientContextState, type ClientContextStatus, INITIAL_CLIENT_CONTEXT_STATE, INITIALIZING_CLIENT_CONTEXT_STATE, ClientCtxState, clientStateToContextState, isClientCtxInitialized, isClientCtxInitializing, isClientCtxNotInitialized, isClientCtxReady, isOverallReady, type ApiResponseResult, type ClientState, type AuthState, type UIClient, type OperationError, isApiResultError, isApiResultOperationError, isApiResultSuccess, isDirectState, isExtensionState, isWebUIClient, isAuthError, isAuthLoading, isAuthenticated, isClientReady, isOperationError, createApiError, createOperationError, } from '../../react-core/src/index.ts';
+export { BUILD_MODE as REACT_EXT_BUILD_MODE } from './build-info';

package/dist/bodhi-react-ext.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const d=require("react/jsx-runtime"),o=require("react"),a=require("@bodhiapp/bodhi-js-ext"),e=require("@bodhiapp/bodhi-js-react-core");function p({children:l,authClientId:i,clientConfig:n,client:t,basePath:u,...s}){if(!t&&!i)throw new Error('BodhiProvider requires either "client" or "authClientId" prop');const r=o.useRef(null),c=o.useMemo(()=>{if(t)return t;if(r.current)return r.current;const b={...n,basePath:n?.basePath??u};return r.current=new a.ExtUIClient(i,b),r.current},[t,i,n,u]);return d.jsx(e.BodhiProvider,{client:c,basePath:u,...s,children:l})}const O="production";Object.defineProperty(exports,"ExtUIClient",{enumerable:!0,get:()=>a.ExtUIClient});Object.defineProperty(exports,"BodhiReactContext",{enumerable:!0,get:()=>e.BodhiReactContext});Object.defineProperty(exports,"ClientCtxState",{enumerable:!0,get:()=>e.ClientCtxState});Object.defineProperty(exports,"INITIALIZING_CLIENT_CONTEXT_STATE",{enumerable:!0,get:()=>e.INITIALIZING_CLIENT_CONTEXT_STATE});Object.defineProperty(exports,"INITIAL_CLIENT_CONTEXT_STATE",{enumerable:!0,get:()=>e.INITIAL_CLIENT_CONTEXT_STATE});Object.defineProperty(exports,"clientStateToContextState",{enumerable:!0,get:()=>e.clientStateToContextState});Object.defineProperty(exports,"createApiError",{enumerable:!0,get:()=>e.createApiError});Object.defineProperty(exports,"createOperationError",{enumerable:!0,get:()=>e.createOperationError});Object.defineProperty(exports,"isApiResultError",{enumerable:!0,get:()=>e.isApiResultError});Object.defineProperty(exports,"isApiResultOperationError",{enumerable:!0,get:()=>e.isApiResultOperationError});Object.defineProperty(exports,"isApiResultSuccess",{enumerable:!0,get:()=>e.isApiResultSuccess});Object.defineProperty(exports,"isAuthError",{enumerable:!0,get:()=>e.isAuthError});Object.defineProperty(exports,"isAuthLoading",{enumerable:!0,get:()=>e.isAuthLoading});Object.defineProperty(exports,"isAuthenticated",{enumerable:!0,get:()=>e.isAuthenticated});Object.defineProperty(exports,"isClientCtxInitialized",{enumerable:!0,get:()=>e.isClientCtxInitialized});Object.defineProperty(exports,"isClientCtxInitializing",{enumerable:!0,get:()=>e.isClientCtxInitializing});Object.defineProperty(exports,"isClientCtxNotInitialized",{enumerable:!0,get:()=>e.isClientCtxNotInitialized});Object.defineProperty(exports,"isClientCtxReady",{enumerable:!0,get:()=>e.isClientCtxReady});Object.defineProperty(exports,"isClientReady",{enumerable:!0,get:()=>e.isClientReady});Object.defineProperty(exports,"isDirectState",{enumerable:!0,get:()=>e.isDirectState});Object.defineProperty(exports,"isExtensionState",{enumerable:!0,get:()=>e.isExtensionState});Object.defineProperty(exports,"isOperationError",{enumerable:!0,get:()=>e.isOperationError});Object.defineProperty(exports,"isOverallReady",{enumerable:!0,get:()=>e.isOverallReady});Object.defineProperty(exports,"isWebUIClient",{enumerable:!0,get:()=>e.isWebUIClient});Object.defineProperty(exports,"useBodhi",{enumerable:!0,get:()=>e.useBodhi});exports.BodhiProvider=p;exports.REACT_EXT_BUILD_MODE=O;

package/dist/bodhi-react-ext.esm.d.ts

@@ -0,0 +1,2 @@
+export * from './bodhi-js-sdk/react-ext/src/index'
+export {}

package/dist/bodhi-react-ext.esm.js

@@ -0,0 +1,50 @@
+import { jsx as c } from "react/jsx-runtime";
+import { useRef as E, useMemo as l } from "react";
+import { ExtUIClient as I } from "@bodhiapp/bodhi-js-ext";
+import { ExtUIClient as R } from "@bodhiapp/bodhi-js-ext";
+import { BodhiProvider as C } from "@bodhiapp/bodhi-js-react-core";
+import { BodhiReactContext as B, ClientCtxState as N, INITIALIZING_CLIENT_CONTEXT_STATE as O, INITIAL_CLIENT_CONTEXT_STATE as S, clientStateToContextState as L, createApiError as D, createOperationError as U, isApiResultError as P, isApiResultOperationError as w, isApiResultSuccess as y, isAuthError as z, isAuthLoading as M, isAuthenticated as X, isClientCtxInitialized as g, isClientCtxInitializing as v, isClientCtxNotInitialized as b, isClientCtxReady as j, isClientReady as q, isDirectState as G, isExtensionState as W, isOperationError as Z, isOverallReady as $, isWebUIClient as k, useBodhi as F } from "@bodhiapp/bodhi-js-react-core";
+function m({ children: n, authClientId: e, clientConfig: i, client: t, basePath: o, ...s }) {
+  if (!t && !e)
+    throw new Error('BodhiProvider requires either "client" or "authClientId" prop');
+  const r = E(null), a = l(() => {
+    if (t) return t;
+    if (r.current) return r.current;
+    const u = {
+      ...i,
+      basePath: i?.basePath ?? o
+    };
+    return r.current = new I(e, u), r.current;
+  }, [t, e, i, o]);
+  return /* @__PURE__ */ c(C, { client: a, basePath: o, ...s, children: n });
+}
+const A = "production";
+export {
+  m as BodhiProvider,
+  B as BodhiReactContext,
+  N as ClientCtxState,
+  R as ExtUIClient,
+  O as INITIALIZING_CLIENT_CONTEXT_STATE,
+  S as INITIAL_CLIENT_CONTEXT_STATE,
+  A as REACT_EXT_BUILD_MODE,
+  L as clientStateToContextState,
+  D as createApiError,
+  U as createOperationError,
+  P as isApiResultError,
+  w as isApiResultOperationError,
+  y as isApiResultSuccess,
+  z as isAuthError,
+  M as isAuthLoading,
+  X as isAuthenticated,
+  g as isClientCtxInitialized,
+  v as isClientCtxInitializing,
+  b as isClientCtxNotInitialized,
+  j as isClientCtxReady,
+  q as isClientReady,
+  G as isDirectState,
+  W as isExtensionState,
+  Z as isOperationError,
+  $ as isOverallReady,
+  k as isWebUIClient,
+  F as useBodhi
+};

package/dist/setup-modal/src/types/extension.d.ts

@@ -0,0 +1,24 @@
+export type ExtensionErrorCode = 'ext-not-installed' | 'ext-connection-failed' | 'ext-unsupported-version';
+export declare const EXT_NOT_INSTALLED: ExtensionErrorCode;
+export declare const EXT_CONNECTION_FAILED: ExtensionErrorCode;
+export declare const EXT_UNSUPPORTED_VERSION: ExtensionErrorCode;
+export interface ExtensionStateReady {
+    /** Current extension status */
+    status: 'ready';
+    /** Extension version */
+    version: string;
+    /** Extension ID (always present when ready) */
+    id: string;
+}
+export interface ExtensionStateNotReady {
+    /** Current extension status */
+    status: 'unreachable' | 'not-installed' | 'unsupported';
+    /** Error details */
+    error: {
+        /** Error message */
+        message: string;
+        /** Error code */
+        code: ExtensionErrorCode;
+    };
+}
+export type ExtensionState = ExtensionStateReady | ExtensionStateNotReady;

package/dist/setup-modal/src/types/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Consolidated types for setup-modal
+ *
+ * This folder contains all domain and protocol types organized by domain.
+ * It is designed to be independent and copyable to other packages.
+ */
+export type { BrowserType, OSType, EnvState, SupportedBrowser, NotSupportedBrowser, Browser, SupportedOS, NotSupportedOS, OS } from './platform';
+export type { ExtensionErrorCode, ExtensionStateReady, ExtensionStateNotReady, ExtensionState } from './extension';
+export { EXT_NOT_INSTALLED, EXT_CONNECTION_FAILED, EXT_UNSUPPORTED_VERSION } from './extension';
+export type { ServerErrorCode, ServerStateReady, ServerStateReachable, ServerStatePending, ServerStateUnreachable, ServerStateError, ServerState } from './server';
+export { SERVER_PENDING_EXT_READY, SERVER_CONN_REFUSED, SERVER_CONN_TIMEOUT, SERVER_NOT_FOUND, SERVER_NETWORK_UNREACHABLE, SERVER_SERVICE_UNAVAILABLE, SERVER_UNEXPECTED_ERROR, SERVER_IN_SETUP_STATUS, SERVER_IN_ADMIN_STATUS, } from './server';
+export type { LnaErrorCode, LnaStatePrompt, LnaStateSkipped, LnaStateGranted, LnaStateUnreachable, LnaStateDenied, LnaStateUnsupported, LnaState, LnaServerStatePending, LnaServerStateReady, LnaServerStateSetup, LnaServerStateResourceAdmin, LnaServerStateError, LnaServerState, } from './lna';
+export { LNA_UNREACHABLE, LNA_PERMISSION_DENIED } from './lna';
+export { SetupStep, DEFAULT_USER_CONFIRMATIONS, DEFAULT_SETUP_STATE } from './state';
+export type { SelectedConnection, UserConfirmations, SetupState } from './state';
+export type { RequestId, MessageKind, RequestMessage, ResponseMessage, ErrorMessage, EventMessage, ProtocolMessage } from './protocol';
+export { isRequestMessage, isResponseMessage, isErrorMessage, isEventMessage } from './protocol';
+export type { MessageTypeRegistry, MessageType, RequestPayload, ResponsePayload, RequestHandlers } from './message-types';
+export { MSG, isMessageType } from './message-types';
+export { isExtensionStateReady, isExtensionStateNotReady, isServerStateReady, isServerStateReachable, isServerStatePending, isServerStateUnreachable, isServerStateError, isLnaStatePrompt, isLnaStateSkipped, isLnaStateGranted, isLnaStateUnreachable, isLnaStateDenied, isLnaStateUnsupported, isLnaServerStatePending, isLnaServerStateReady, isLnaServerStateSetup, isLnaServerStateResourceAdmin, isLnaServerStateError, isSupportedBrowser, isNotSupportedBrowser, isSupportedOS, isNotSupportedOS, } from './type-guards';

package/dist/setup-modal/src/types/lna.d.ts

@@ -0,0 +1,56 @@
+export type LnaErrorCode = 'lna-unreachable' | 'lna-permission-denied';
+export declare const LNA_UNREACHABLE: LnaErrorCode;
+export declare const LNA_PERMISSION_DENIED: LnaErrorCode;
+export interface LnaStatePrompt {
+    status: 'prompt';
+    serverUrl?: string;
+}
+export interface LnaStateSkipped {
+    status: 'skipped';
+    serverUrl?: string;
+}
+export interface LnaStateGranted {
+    status: 'granted';
+    serverUrl: string;
+}
+export interface LnaStateUnreachable {
+    status: 'unreachable';
+    serverUrl: string;
+    error: {
+        message: string;
+        code: LnaErrorCode;
+    };
+}
+export interface LnaStateDenied {
+    status: 'denied';
+    error: {
+        message: string;
+        code: LnaErrorCode;
+    };
+}
+export interface LnaStateUnsupported {
+    status: 'unsupported';
+}
+export type LnaState = LnaStatePrompt | LnaStateSkipped | LnaStateGranted | LnaStateUnreachable | LnaStateDenied | LnaStateUnsupported;
+export interface LnaServerStatePending {
+    status: 'pending-lna-ready';
+}
+export interface LnaServerStateReady {
+    status: 'ready';
+    version: string;
+}
+export interface LnaServerStateSetup {
+    status: 'setup';
+    version: string;
+}
+export interface LnaServerStateResourceAdmin {
+    status: 'resource-admin';
+    version: string;
+}
+export interface LnaServerStateError {
+    status: 'error';
+    error: {
+        message: string;
+    };
+}
+export type LnaServerState = LnaServerStatePending | LnaServerStateReady | LnaServerStateSetup | LnaServerStateResourceAdmin | LnaServerStateError;

package/dist/setup-modal/src/types/message-types.d.ts

@@ -0,0 +1,168 @@
+import { SetupState } from './state';
+/**
+ * Central registry mapping message types to their payload/response shapes
+ * Single source of truth - everything else is inferred!
+ */
+export interface MessageTypeRegistry {
+    /**
+     * Modal is ready and requesting initial state
+     * Sent on modal mount
+     */
+    'modal:ready': {
+        request: void;
+        response: {
+            setupState: SetupState;
+        };
+    };
+    /**
+     * User requested to refresh platform detection
+     * Triggers re-detection of browser, OS, extension, server
+     */
+    'modal:refresh': {
+        request: void;
+        response: {
+            setupState: SetupState;
+        };
+    };
+    /**
+     * User requested to close the modal
+     * Parent should hide/destroy modal
+     */
+    'modal:close': {
+        request: void;
+        response: void;
+    };
+    /**
+     * Setup completed successfully
+     * Signals parent that user has finished setup
+     */
+    'modal:complete': {
+        request: void;
+        response: void;
+    };
+    /**
+     * User requested LNA connection to specific server URL
+     * Triggers LNA permission request and connection attempt
+     */
+    'modal:lna:connect': {
+        request: {
+            serverUrl: string;
+        };
+        response: {
+            success: boolean;
+        };
+    };
+    /**
+     * User chose to skip LNA setup
+     * Falls back to extension-only mode
+     */
+    'modal:lna:skip': {
+        request: void;
+        response: {
+            success: boolean;
+        };
+    };
+    /**
+     * User confirmed server installation status
+     * Used when server needs to be installed
+     */
+    'modal:confirm-server-install': {
+        request: {
+            confirmed: boolean;
+        };
+        response: {
+            success: boolean;
+        };
+    };
+    /**
+     * User selected preferred connection method
+     * Allows choosing between LNA and Extension paths
+     */
+    'modal:select-connection': {
+        request: {
+            connection: 'lna' | 'extension';
+        };
+        response: {
+            success: boolean;
+        };
+    };
+    /**
+     * Parent sending updated state to modal
+     * Fired when platform detection results change
+     */
+    'parent:state-update': {
+        request: {
+            setupState: SetupState;
+        };
+        response: void;
+    };
+}
+/**
+ * Union of all valid message type strings
+ * Derived from MessageTypeRegistry keys
+ */
+export type MessageType = keyof MessageTypeRegistry;
+/**
+ * Extract request payload type for a given message type
+ * Returns the 'request' field from the registry entry
+ */
+export type RequestPayload<T extends MessageType> = MessageTypeRegistry[T]['request'];
+/**
+ * Extract response payload type for a given message type
+ * Returns the 'response' field from the registry entry
+ */
+export type ResponsePayload<T extends MessageType> = MessageTypeRegistry[T]['response'];
+/**
+ * Message type constants - Type-safe identifiers
+ *
+ * @example
+ * switch (message.type) {
+ *   case MSG.MODAL_READY:
+ *     // Type-safe constant, no typos possible
+ *     break;
+ * }
+ */
+export declare const MSG: {
+    readonly MODAL_READY: "modal:ready";
+    readonly MODAL_REFRESH: "modal:refresh";
+    readonly MODAL_CLOSE: "modal:close";
+    readonly MODAL_COMPLETE: "modal:complete";
+    readonly MODAL_LNA_CONNECT: "modal:lna:connect";
+    readonly MODAL_LNA_SKIP: "modal:lna:skip";
+    readonly MODAL_CONFIRM_SERVER_INSTALL: "modal:confirm-server-install";
+    readonly MODAL_SELECT_CONNECTION: "modal:select-connection";
+    readonly PARENT_STATE_UPDATE: "parent:state-update";
+};
+/**
+ * Type guard that narrows RequestMessage to specific type WITH payload typing
+ *
+ * Use this for full type safety when you need access to typed payload fields.
+ * The guard narrows the generic RequestMessage to RequestMessage<T> where T
+ * determines the payload type.
+ *
+ * @example
+ * if (isMessageType(msg, MSG.MODAL_LNA_CONNECT)) {
+ *   // msg.payload is { serverUrl: string } - fully typed!
+ *   console.log(msg.payload.serverUrl); // Autocomplete works!
+ * }
+ */
+export declare function isMessageType<T extends MessageType>(msg: {
+    type: string;
+}, type: T): msg is {
+    type: T;
+};
+/**
+ * Type-safe request handler map
+ * Enforces correct payload access AND correct return type for each message
+ *
+ * Each handler receives a RequestMessage<K> where K is the specific message type,
+ * providing full type safety for payload access. The handler must return the
+ * correct ResponsePayload<K> type.
+ */
+export type RequestHandlers = {
+    [K in MessageType]?: (msg: {
+        type: K;
+        requestId: string;
+        payload: RequestPayload<K>;
+    }) => ResponsePayload<K>;
+};

package/dist/setup-modal/src/types/platform.d.ts

@@ -0,0 +1,32 @@
+export type BrowserType = 'chrome' | 'edge' | 'firefox' | 'safari' | 'unknown';
+export type OSType = 'macos' | 'windows' | 'linux' | 'unknown';
+export interface EnvState {
+    os: OSType;
+    browser: BrowserType;
+}
+export interface SupportedBrowser {
+    id: BrowserType;
+    status: 'supported';
+    name: string;
+    extension_url: string;
+}
+export interface NotSupportedBrowser {
+    id: BrowserType;
+    status: 'not-supported';
+    name: string;
+    github_issue_url?: string;
+}
+export type Browser = SupportedBrowser | NotSupportedBrowser;
+export interface SupportedOS {
+    id: OSType;
+    status: 'supported';
+    name: string;
+    download_url: string;
+}
+export interface NotSupportedOS {
+    id: OSType;
+    status: 'not-supported';
+    name: string;
+    github_issue_url?: string;
+}
+export type OS = SupportedOS | NotSupportedOS;

package/dist/setup-modal/src/types/protocol.d.ts

@@ -0,0 +1,70 @@
+import { MessageType, RequestPayload, ResponsePayload } from './message-types';
+/** Branded type for type-safe request IDs */
+export type RequestId = string & {
+    readonly __brand: 'RequestId';
+};
+/** Message kind discriminator */
+export type MessageKind = 'request' | 'response' | 'error' | 'event';
+/**
+ * Request message - expects a response
+ * Sent by either modal or parent to request an action
+ */
+export interface RequestMessage<T extends MessageType = MessageType> {
+    readonly kind: 'request';
+    readonly type: T;
+    readonly requestId: RequestId;
+    readonly payload: RequestPayload<T>;
+}
+/**
+ * Response message - correlates to a request
+ * Sent in response to a RequestMessage with matching requestId
+ */
+export interface ResponseMessage<T extends MessageType = MessageType> {
+    readonly kind: 'response';
+    readonly type: T;
+    readonly requestId: RequestId;
+    readonly payload: ResponsePayload<T>;
+}
+/**
+ * Error response - indicates request failure
+ * Sent instead of ResponseMessage when request cannot be fulfilled
+ */
+export interface ErrorMessage {
+    readonly kind: 'error';
+    readonly requestId: RequestId;
+    readonly error: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+}
+/**
+ * Event message - fire-and-forget notification
+ * No response expected, used for one-way state updates
+ */
+export interface EventMessage<T extends MessageType = MessageType> {
+    readonly kind: 'event';
+    readonly type: T;
+    readonly payload: RequestPayload<T>;
+}
+/**
+ * Union of all protocol messages
+ * Discriminated by 'kind' field for type narrowing
+ */
+export type ProtocolMessage = RequestMessage | ResponseMessage | ErrorMessage | EventMessage;
+/**
+ * Type guard to check if message is a request
+ */
+export declare function isRequestMessage(msg: ProtocolMessage): msg is RequestMessage;
+/**
+ * Type guard to check if message is a response
+ */
+export declare function isResponseMessage(msg: ProtocolMessage): msg is ResponseMessage;
+/**
+ * Type guard to check if message is an error
+ */
+export declare function isErrorMessage(msg: ProtocolMessage): msg is ErrorMessage;
+/**
+ * Type guard to check if message is an event
+ */
+export declare function isEventMessage(msg: ProtocolMessage): msg is EventMessage;

package/dist/setup-modal/src/types/server.d.ts

@@ -0,0 +1,63 @@
+export type ServerErrorCode = 'server-pending-ext-ready' | 'server-conn-refused' | 'server-conn-timeout' | 'server-not-found' | 'server-network-unreachable' | 'server-service-unavailable' | 'server-unexpected-error' | 'server-in-setup-status' | 'server-in-admin-status';
+export declare const SERVER_PENDING_EXT_READY: ServerErrorCode;
+export declare const SERVER_CONN_REFUSED: ServerErrorCode;
+export declare const SERVER_CONN_TIMEOUT: ServerErrorCode;
+export declare const SERVER_NOT_FOUND: ServerErrorCode;
+export declare const SERVER_NETWORK_UNREACHABLE: ServerErrorCode;
+export declare const SERVER_SERVICE_UNAVAILABLE: ServerErrorCode;
+export declare const SERVER_UNEXPECTED_ERROR: ServerErrorCode;
+export declare const SERVER_IN_SETUP_STATUS: ServerErrorCode;
+export declare const SERVER_IN_ADMIN_STATUS: ServerErrorCode;
+export interface ServerStateReady {
+    /** Current server status */
+    status: 'ready';
+    /** Server version */
+    version: string;
+}
+export interface ServerStateReachable {
+    /** Current server status */
+    status: 'setup' | 'resource-admin';
+    /** Server version */
+    version: string;
+    /** Error details */
+    error: {
+        /** Error message */
+        message: string;
+        /** Error code */
+        code: ServerErrorCode;
+    };
+}
+export interface ServerStatePending {
+    /** Current server status */
+    status: 'pending-extension-ready';
+    /** Error details */
+    error: {
+        /** Error message */
+        message: string;
+        /** Error code */
+        code: ServerErrorCode;
+    };
+}
+export interface ServerStateUnreachable {
+    /** Current server status */
+    status: 'unreachable';
+    /** Error details */
+    error: {
+        /** Error message */
+        message: string;
+        /** Error code */
+        code: ServerErrorCode;
+    };
+}
+export interface ServerStateError {
+    /** Current server status */
+    status: 'error';
+    /** Error details */
+    error: {
+        /** Error message */
+        message: string;
+        /** Error code */
+        code: ServerErrorCode;
+    };
+}
+export type ServerState = ServerStateReady | ServerStateReachable | ServerStatePending | ServerStateUnreachable | ServerStateError;

package/dist/setup-modal/src/types/state.d.ts

@@ -0,0 +1,42 @@
+import { Browser, EnvState, OS } from './platform';
+import { ExtensionState } from './extension';
+import { ServerState } from './server';
+import { LnaServerState, LnaState } from './lna';
+export declare enum SetupStep {
+    PLATFORM_CHECK = "platform-check",
+    SERVER_SETUP = "server-setup",
+    LNA_SETUP = "lna-setup",
+    EXTENSION_SETUP = "extension-setup",
+    COMPLETE = "complete"
+}
+export type SelectedConnection = 'lna' | 'extension' | null;
+export interface UserConfirmations {
+    /** Whether user has confirmed server installation */
+    serverInstall: boolean;
+}
+export declare const DEFAULT_USER_CONFIRMATIONS: UserConfirmations;
+export interface SetupState {
+    /** Extension state details */
+    extension: ExtensionState;
+    /** Server state details (via extension) */
+    server: ServerState;
+    /** LNA connection state */
+    lna: LnaState;
+    /** Server state details (via LNA) */
+    lnaServer: LnaServerState;
+    /** Environment detection */
+    env: EnvState;
+    /** Browser platforms list */
+    browsers: Browser[];
+    /** Operating systems list */
+    os: OS[];
+    /** User confirmations for manual steps */
+    userConfirmations: UserConfirmations;
+    /** User's preferred connection method (null = auto-select based on priority) */
+    selectedConnection: SelectedConnection;
+}
+/**
+ * Default setup state used during initialization before parent sends real state
+ * Represents "loading" state - unknown platform, no extension, no server
+ */
+export declare const DEFAULT_SETUP_STATE: SetupState;

package/dist/setup-modal/src/types/type-guards.d.ts

@@ -0,0 +1,26 @@
+import { ExtensionState, ExtensionStateNotReady, ExtensionStateReady } from './extension';
+import { ServerState, ServerStateError, ServerStatePending, ServerStateReachable, ServerStateReady, ServerStateUnreachable } from './server';
+import { LnaServerState, LnaServerStateError, LnaServerStatePending, LnaServerStateReady, LnaServerStateResourceAdmin, LnaServerStateSetup, LnaState, LnaStateDenied, LnaStateGranted, LnaStatePrompt, LnaStateSkipped, LnaStateUnreachable, LnaStateUnsupported } from './lna';
+import { Browser, NotSupportedBrowser, NotSupportedOS, OS, SupportedBrowser, SupportedOS } from './platform';
+export declare function isExtensionStateReady(ext: ExtensionState): ext is ExtensionStateReady;
+export declare function isExtensionStateNotReady(ext: ExtensionState): ext is ExtensionStateNotReady;
+export declare function isServerStateReady(server: ServerState): server is ServerStateReady;
+export declare function isServerStateReachable(server: ServerState): server is ServerStateReachable;
+export declare function isServerStatePending(server: ServerState): server is ServerStatePending;
+export declare function isServerStateUnreachable(server: ServerState): server is ServerStateUnreachable;
+export declare function isServerStateError(server: ServerState): server is ServerStateError;
+export declare function isLnaStatePrompt(lna: LnaState): lna is LnaStatePrompt;
+export declare function isLnaStateSkipped(lna: LnaState): lna is LnaStateSkipped;
+export declare function isLnaStateGranted(lna: LnaState): lna is LnaStateGranted;
+export declare function isLnaStateUnreachable(lna: LnaState): lna is LnaStateUnreachable;
+export declare function isLnaStateDenied(lna: LnaState): lna is LnaStateDenied;
+export declare function isLnaStateUnsupported(lna: LnaState): lna is LnaStateUnsupported;
+export declare function isLnaServerStatePending(server: LnaServerState): server is LnaServerStatePending;
+export declare function isLnaServerStateReady(server: LnaServerState): server is LnaServerStateReady;
+export declare function isLnaServerStateSetup(server: LnaServerState): server is LnaServerStateSetup;
+export declare function isLnaServerStateResourceAdmin(server: LnaServerState): server is LnaServerStateResourceAdmin;
+export declare function isLnaServerStateError(server: LnaServerState): server is LnaServerStateError;
+export declare function isSupportedBrowser(browser: Browser): browser is SupportedBrowser;
+export declare function isNotSupportedBrowser(browser: Browser): browser is NotSupportedBrowser;
+export declare function isSupportedOS(os: OS): os is SupportedOS;
+export declare function isNotSupportedOS(os: OS): os is NotSupportedOS;

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@bodhiapp/bodhi-js-react-ext",
+  "version": "0.0.11",
+  "description": "React bindings for Bodhi Browser SDK with ExtUIClient preset (Chrome Extension)",
+  "type": "module",
+  "main": "dist/bodhi-react-ext.cjs.js",
+  "module": "dist/bodhi-react-ext.esm.js",
+  "exports": {
+    ".": {
+      "types": "./dist/bodhi-react-ext.esm.d.ts",
+      "import": "./dist/bodhi-react-ext.esm.js",
+      "require": "./dist/bodhi-react-ext.cjs.js"
+    },
+    "./api": {
+      "types": "./src/api/index.ts",
+      "import": "./src/api/index.ts",
+      "default": "./src/api/index.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BodhiSearch/bodhi-js.git",
+    "directory": "bodhi-js-sdk/react-ext"
+  },
+  "license": "MIT",
+  "author": "BodhiSearch",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "vite build --mode development",
+    "ci:build": "vite build --mode development",
+    "dev:build": "node ../../scripts/build-fast.mjs bodhi-js-sdk/react-ext 'npm run build' src package.json vite.config.ts",
+    "build:prod": "vite build --mode production",
+    "lint": "eslint . --ext .js,.jsx,.ts,.tsx && prettier --check .",
+    "lint:fix": "prettier --write . && eslint . --ext .js,.jsx,.ts,.tsx --fix",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@bodhiapp/bodhi-js-react-core": "0.0.11",
+    "@bodhiapp/bodhi-js-ext": "0.0.11"
+  },
+  "peerDependencies": {
+    "react": "^18.3.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.23.0",
+    "@types/node": "^20.19.10",
+    "@types/react": "^19.0.0",
+    "@typescript-eslint/eslint-plugin": "8.28.0",
+    "@typescript-eslint/parser": "8.28.0",
+    "eslint": "9.32.0",
+    "eslint-config-prettier": "10.1.8",
+    "globals": "^16.0.0",
+    "prettier": "3.6.2",
+    "rimraf": "^6.0.1",
+    "tslib": "^2.6.2",
+    "typescript": "^5.8.3",
+    "vite": "^7.1.12",
+    "vite-plugin-dts": "^4.5.4"
+  }
+}