fluidsoul-js 0.1.0

package/dist/index.cjs

@@ -0,0 +1,135 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FluidsoulClient: () => FluidsoulClient,
+  FluidsoulError: () => FluidsoulError,
+  createFluidsoulConfig: () => createFluidsoulConfig,
+  getContext: () => getContext,
+  refreshContext: () => refreshContext,
+  sendEvent: () => sendEvent
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var FluidsoulError = class extends Error {
+  constructor(message, status, endpoint, body) {
+    super(message);
+    this.status = status;
+    this.endpoint = endpoint;
+    this.body = body;
+    this.name = "FluidsoulError";
+  }
+};
+
+// src/client.ts
+function buildHeaders(config, requestId) {
+  return {
+    "Authorization": `Bearer ${config.token}`,
+    "Content-Type": "application/json",
+    "X-Workspace-Id": config.workspaceId,
+    ...requestId ? { "X-Request-Id": requestId } : {}
+  };
+}
+async function assertOk(res, endpoint) {
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new FluidsoulError(
+      `fluidsoul request failed: ${endpoint} returned ${res.status}`,
+      res.status,
+      endpoint,
+      body
+    );
+  }
+}
+async function sendEvent(config, input, requestId) {
+  const endpoint = `${config.apiUrl}/v1/events/ingest`;
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: buildHeaders(config, requestId),
+    body: JSON.stringify({
+      user_id: input.userId,
+      event_type: input.eventType,
+      event_time: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata: input.metadata ?? {}
+    })
+  });
+  await assertOk(res, endpoint);
+}
+async function refreshContext(config, userId, requestId) {
+  const endpoint = `${config.apiUrl}/v1/context/refresh`;
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: buildHeaders(config, requestId),
+    body: JSON.stringify({
+      user_id: userId,
+      refresh_reason: "new_events"
+    })
+  });
+  await assertOk(res, endpoint);
+}
+async function getContext(config, userId, requestId) {
+  const endpoint = `${config.apiUrl}/v1/context/users/${encodeURIComponent(userId)}`;
+  const res = await fetch(endpoint, {
+    method: "GET",
+    headers: buildHeaders(config, requestId)
+  });
+  if (res.status === 404) return null;
+  await assertOk(res, endpoint);
+  return res.json();
+}
+
+// src/helpers.ts
+function createFluidsoulConfig(overrides) {
+  const env = typeof globalThis !== "undefined" && "process" in globalThis ? globalThis.process : void 0;
+  const vars = env?.env ?? {};
+  return {
+    apiUrl: overrides?.apiUrl ?? vars.FLUIDSOUL_API_URL ?? vars.NEXT_PUBLIC_FLUIDSOUL_API_URL ?? "http://localhost:4000",
+    token: overrides?.token ?? vars.FLUIDSOUL_API_TOKEN ?? vars.NEXT_PUBLIC_FLUIDSOUL_API_TOKEN ?? "",
+    workspaceId: overrides?.workspaceId ?? vars.FLUIDSOUL_WORKSPACE_ID ?? vars.NEXT_PUBLIC_FLUIDSOUL_WORKSPACE_ID ?? ""
+  };
+}
+var FluidsoulClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /** Send a user action event. */
+  async sendEvent(input, requestId) {
+    return sendEvent(this.config, input, requestId);
+  }
+  /** Trigger a context refresh for a user. */
+  async refreshContext(userId, requestId) {
+    return refreshContext(this.config, userId, requestId);
+  }
+  /** Get the current computed context for a user. Returns null if not found. */
+  async getContext(userId, requestId) {
+    return getContext(this.config, userId, requestId);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FluidsoulClient,
+  FluidsoulError,
+  createFluidsoulConfig,
+  getContext,
+  refreshContext,
+  sendEvent
+});

package/dist/index.d.cts

@@ -0,0 +1,182 @@
+/**
+ * Configuration required to connect to a fluidsoul API server.
+ * Store these values in environment variables — never hardcode them.
+ */
+interface FluidsoulConfig {
+    /** URL of the fluidsoul API server. e.g. "https://api.fluidsoul.dev" or "http://localhost:4000" */
+    apiUrl: string;
+    /** Bearer token for your workspace. Set via fluidsoul CLI: `fluidsoul token set <token>` */
+    token: string;
+    /** Your workspace ID (UUID). Found in your fluidsoul dashboard or config file. */
+    workspaceId: string;
+}
+/**
+ * The computed context profile for a user.
+ * fluidsoul produces this by running its rules engine over the user's event history.
+ * Use it to decide what your UI should show, hide, prioritize, or pre-configure.
+ */
+interface UserContext {
+    user_id: string;
+    /**
+     * What kind of user this is, inferred from their behavior.
+     * The possible values depend on your workspace's rules config dimensions.
+     * Examples: "b2b_focused", "analyst", "power_user", "new_user", "hybrid"
+     */
+    user_category: string;
+    /**
+     * The dominant mode/value this user prefers based on their activity.
+     * Derived from the primary dimension in your rules config.
+     */
+    preferred_mode: string;
+    /**
+     * Features ordered by how relevant they are to this user.
+     * Use this to decide what to surface first in your UI.
+     * e.g. ["discovery", "lead_management", "analytics", "scanning"]
+     */
+    feature_priorities: string[];
+    /**
+     * Suggested default settings to pre-configure for this user.
+     * Keys and values depend on your workspace's rules config.
+     * e.g. { "default_view": "reports", "default_period": "weekly" }
+     */
+    recommended_defaults: Record<string, string>;
+    /** How actively this user engages with the app. */
+    engagement_level: "low" | "moderate" | "high";
+    /**
+     * How experienced this user is with the app.
+     * - "new" — show onboarding hints and tooltips
+     * - "intermediate" — show hints for unfamiliar features only
+     * - "power_user" — hide onboarding, show advanced options
+     */
+    user_maturity: "new" | "intermediate" | "power_user";
+    /**
+     * How confident fluidsoul is about each inference, as a number between 0 and 1.
+     * e.g. { "user_category": 0.85, "preferred_mode": 0.92 }
+     */
+    confidence_scores: Record<string, number>;
+    /**
+     * Plain-English reasons explaining why the context looks the way it does.
+     * e.g. ["Classified as 'analyst' based on 12 analyst and 3 executive signals"]
+     * Show these to developers and power users for transparency.
+     */
+    explainability: string[];
+    /**
+     * A natural-language summary of this user, generated by an LLM.
+     * Null if no LLM is configured or inference hasn't run yet.
+     */
+    user_narrative?: string | null;
+    /**
+     * How this context was computed.
+     * - "rules" — deterministic rules engine only
+     * - "rules+llm" — rules engine + LLM-generated narrative
+     */
+    inference_source?: "rules" | "rules+llm";
+    /** ISO 8601 timestamp of when this context was last computed. */
+    last_refreshed_at: string;
+}
+/** Input for sending a user action event to fluidsoul. */
+interface SendEventInput {
+    /** The ID of the user who performed the action. Must match how you identify users in your app. */
+    userId: string;
+    /**
+     * What the user did. Use consistent names across your app.
+     * Define event types that match your workspace's signal conditions.
+     */
+    eventType: string;
+    /** Optional extra details about the event. e.g. { platform: "linkedin" } or { feature_name: "analytics" } */
+    metadata?: Record<string, unknown>;
+}
+/** Error thrown when a fluidsoul API call fails. */
+declare class FluidsoulError extends Error {
+    readonly status: number;
+    readonly endpoint: string;
+    readonly body: string;
+    constructor(message: string, status: number, endpoint: string, body: string);
+}
+
+/**
+ * fluidsoul core HTTP client.
+ *
+ * Framework-agnostic — works in any environment that supports the Fetch API:
+ * browsers, Node.js 18+, Electron, VS Code extensions, Figma plugins, Photoshop UXP.
+ *
+ * If you're using React, prefer the hooks in "fluidsoul-js/react" which wrap this client
+ * with state management. Use this client directly for server-side calls (Next.js
+ * server components / route handlers) or non-React environments.
+ */
+
+/**
+ * Send a user action event to fluidsoul.
+ *
+ * Call this fire-and-forget whenever a user does something meaningful in your app.
+ * fluidsoul accumulates these events and uses them to build the user's context profile.
+ *
+ * @example
+ * // In a server action or route handler — never call this from browser code directly
+ * await sendEvent(fluidsoulConfig, { userId, eventType: "b2b_mode_used" })
+ */
+declare function sendEvent(config: FluidsoulConfig, input: SendEventInput, requestId?: string): Promise<void>;
+/**
+ * Trigger a context refresh for a user.
+ *
+ * This tells fluidsoul to re-run its rules engine over all of the user's events and
+ * update their context profile. Call this after sending a batch of events, or at
+ * natural session boundaries (end of session, start of a new session).
+ *
+ * You don't need to call this after every single event — batch events and refresh
+ * periodically for best performance.
+ */
+declare function refreshContext(config: FluidsoulConfig, userId: string, requestId?: string): Promise<void>;
+/**
+ * Get the current context profile for a user.
+ *
+ * Returns the user's computed context — who they are, what they prefer, what features
+ * to surface. Use this to configure your UI before rendering.
+ *
+ * Returns null if no context exists yet for this user (they haven't sent any events,
+ * or context hasn't been refreshed yet). Always handle the null case by showing
+ * your default layout.
+ *
+ * @example
+ * const context = await getContext(fluidsoulConfig, userId)
+ * const featureOrder = context?.feature_priorities ?? ["scan", "leads", "analytics"]
+ */
+declare function getContext(config: FluidsoulConfig, userId: string, requestId?: string): Promise<UserContext | null>;
+
+/**
+ * Create a fluidsoul config from environment variables.
+ * Reads FLUIDSOUL_API_URL, FLUIDSOUL_API_TOKEN, and FLUIDSOUL_WORKSPACE_ID.
+ *
+ * Works in Node.js and any environment where `process.env` is available.
+ * For browser environments, use NEXT_PUBLIC_ prefixed variables.
+ */
+declare function createFluidsoulConfig(overrides?: Partial<FluidsoulConfig>): FluidsoulConfig;
+/**
+ * A class-based wrapper around the fluidsoul SDK functions.
+ * Useful when you want to pass a single client instance around.
+ *
+ * @example
+ * ```typescript
+ * const client = new FluidsoulClient({
+ *   apiUrl: "https://api.fluidsoul.dev",
+ *   token: process.vars.FLUIDSOUL_API_TOKEN!,
+ *   workspaceId: process.vars.FLUIDSOUL_WORKSPACE_ID!,
+ * });
+ *
+ * await client.sendEvent({ userId: "user_123", eventType: "page_viewed" });
+ * await client.refreshContext("user_123");
+ * const ctx = await client.getContext("user_123");
+ * ```
+ */
+declare class FluidsoulClient {
+    private readonly config;
+    constructor(config: FluidsoulConfig);
+    /** Send a user action event. */
+    sendEvent(input: SendEventInput, requestId?: string): Promise<void>;
+    /** Trigger a context refresh for a user. */
+    refreshContext(userId: string, requestId?: string): Promise<void>;
+    /** Get the current computed context for a user. Returns null if not found. */
+    getContext(userId: string, requestId?: string): Promise<UserContext | null>;
+}
+
+export { FluidsoulClient, type FluidsoulConfig, FluidsoulError, type SendEventInput, type UserContext, createFluidsoulConfig, getContext, refreshContext, sendEvent };

package/dist/index.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Configuration required to connect to a fluidsoul API server.
+ * Store these values in environment variables — never hardcode them.
+ */
+interface FluidsoulConfig {
+    /** URL of the fluidsoul API server. e.g. "https://api.fluidsoul.dev" or "http://localhost:4000" */
+    apiUrl: string;
+    /** Bearer token for your workspace. Set via fluidsoul CLI: `fluidsoul token set <token>` */
+    token: string;
+    /** Your workspace ID (UUID). Found in your fluidsoul dashboard or config file. */
+    workspaceId: string;
+}
+/**
+ * The computed context profile for a user.
+ * fluidsoul produces this by running its rules engine over the user's event history.
+ * Use it to decide what your UI should show, hide, prioritize, or pre-configure.
+ */
+interface UserContext {
+    user_id: string;
+    /**
+     * What kind of user this is, inferred from their behavior.
+     * The possible values depend on your workspace's rules config dimensions.
+     * Examples: "b2b_focused", "analyst", "power_user", "new_user", "hybrid"
+     */
+    user_category: string;
+    /**
+     * The dominant mode/value this user prefers based on their activity.
+     * Derived from the primary dimension in your rules config.
+     */
+    preferred_mode: string;
+    /**
+     * Features ordered by how relevant they are to this user.
+     * Use this to decide what to surface first in your UI.
+     * e.g. ["discovery", "lead_management", "analytics", "scanning"]
+     */
+    feature_priorities: string[];
+    /**
+     * Suggested default settings to pre-configure for this user.
+     * Keys and values depend on your workspace's rules config.
+     * e.g. { "default_view": "reports", "default_period": "weekly" }
+     */
+    recommended_defaults: Record<string, string>;
+    /** How actively this user engages with the app. */
+    engagement_level: "low" | "moderate" | "high";
+    /**
+     * How experienced this user is with the app.
+     * - "new" — show onboarding hints and tooltips
+     * - "intermediate" — show hints for unfamiliar features only
+     * - "power_user" — hide onboarding, show advanced options
+     */
+    user_maturity: "new" | "intermediate" | "power_user";
+    /**
+     * How confident fluidsoul is about each inference, as a number between 0 and 1.
+     * e.g. { "user_category": 0.85, "preferred_mode": 0.92 }
+     */
+    confidence_scores: Record<string, number>;
+    /**
+     * Plain-English reasons explaining why the context looks the way it does.
+     * e.g. ["Classified as 'analyst' based on 12 analyst and 3 executive signals"]
+     * Show these to developers and power users for transparency.
+     */
+    explainability: string[];
+    /**
+     * A natural-language summary of this user, generated by an LLM.
+     * Null if no LLM is configured or inference hasn't run yet.
+     */
+    user_narrative?: string | null;
+    /**
+     * How this context was computed.
+     * - "rules" — deterministic rules engine only
+     * - "rules+llm" — rules engine + LLM-generated narrative
+     */
+    inference_source?: "rules" | "rules+llm";
+    /** ISO 8601 timestamp of when this context was last computed. */
+    last_refreshed_at: string;
+}
+/** Input for sending a user action event to fluidsoul. */
+interface SendEventInput {
+    /** The ID of the user who performed the action. Must match how you identify users in your app. */
+    userId: string;
+    /**
+     * What the user did. Use consistent names across your app.
+     * Define event types that match your workspace's signal conditions.
+     */
+    eventType: string;
+    /** Optional extra details about the event. e.g. { platform: "linkedin" } or { feature_name: "analytics" } */
+    metadata?: Record<string, unknown>;
+}
+/** Error thrown when a fluidsoul API call fails. */
+declare class FluidsoulError extends Error {
+    readonly status: number;
+    readonly endpoint: string;
+    readonly body: string;
+    constructor(message: string, status: number, endpoint: string, body: string);
+}
+
+/**
+ * fluidsoul core HTTP client.
+ *
+ * Framework-agnostic — works in any environment that supports the Fetch API:
+ * browsers, Node.js 18+, Electron, VS Code extensions, Figma plugins, Photoshop UXP.
+ *
+ * If you're using React, prefer the hooks in "fluidsoul-js/react" which wrap this client
+ * with state management. Use this client directly for server-side calls (Next.js
+ * server components / route handlers) or non-React environments.
+ */
+
+/**
+ * Send a user action event to fluidsoul.
+ *
+ * Call this fire-and-forget whenever a user does something meaningful in your app.
+ * fluidsoul accumulates these events and uses them to build the user's context profile.
+ *
+ * @example
+ * // In a server action or route handler — never call this from browser code directly
+ * await sendEvent(fluidsoulConfig, { userId, eventType: "b2b_mode_used" })
+ */
+declare function sendEvent(config: FluidsoulConfig, input: SendEventInput, requestId?: string): Promise<void>;
+/**
+ * Trigger a context refresh for a user.
+ *
+ * This tells fluidsoul to re-run its rules engine over all of the user's events and
+ * update their context profile. Call this after sending a batch of events, or at
+ * natural session boundaries (end of session, start of a new session).
+ *
+ * You don't need to call this after every single event — batch events and refresh
+ * periodically for best performance.
+ */
+declare function refreshContext(config: FluidsoulConfig, userId: string, requestId?: string): Promise<void>;
+/**
+ * Get the current context profile for a user.
+ *
+ * Returns the user's computed context — who they are, what they prefer, what features
+ * to surface. Use this to configure your UI before rendering.
+ *
+ * Returns null if no context exists yet for this user (they haven't sent any events,
+ * or context hasn't been refreshed yet). Always handle the null case by showing
+ * your default layout.
+ *
+ * @example
+ * const context = await getContext(fluidsoulConfig, userId)
+ * const featureOrder = context?.feature_priorities ?? ["scan", "leads", "analytics"]
+ */
+declare function getContext(config: FluidsoulConfig, userId: string, requestId?: string): Promise<UserContext | null>;
+
+/**
+ * Create a fluidsoul config from environment variables.
+ * Reads FLUIDSOUL_API_URL, FLUIDSOUL_API_TOKEN, and FLUIDSOUL_WORKSPACE_ID.
+ *
+ * Works in Node.js and any environment where `process.env` is available.
+ * For browser environments, use NEXT_PUBLIC_ prefixed variables.
+ */
+declare function createFluidsoulConfig(overrides?: Partial<FluidsoulConfig>): FluidsoulConfig;
+/**
+ * A class-based wrapper around the fluidsoul SDK functions.
+ * Useful when you want to pass a single client instance around.
+ *
+ * @example
+ * ```typescript
+ * const client = new FluidsoulClient({
+ *   apiUrl: "https://api.fluidsoul.dev",
+ *   token: process.vars.FLUIDSOUL_API_TOKEN!,
+ *   workspaceId: process.vars.FLUIDSOUL_WORKSPACE_ID!,
+ * });
+ *
+ * await client.sendEvent({ userId: "user_123", eventType: "page_viewed" });
+ * await client.refreshContext("user_123");
+ * const ctx = await client.getContext("user_123");
+ * ```
+ */
+declare class FluidsoulClient {
+    private readonly config;
+    constructor(config: FluidsoulConfig);
+    /** Send a user action event. */
+    sendEvent(input: SendEventInput, requestId?: string): Promise<void>;
+    /** Trigger a context refresh for a user. */
+    refreshContext(userId: string, requestId?: string): Promise<void>;
+    /** Get the current computed context for a user. Returns null if not found. */
+    getContext(userId: string, requestId?: string): Promise<UserContext | null>;
+}
+
+export { FluidsoulClient, type FluidsoulConfig, FluidsoulError, type SendEventInput, type UserContext, createFluidsoulConfig, getContext, refreshContext, sendEvent };

package/dist/index.js

@@ -0,0 +1,103 @@
+// src/types.ts
+var FluidsoulError = class extends Error {
+  constructor(message, status, endpoint, body) {
+    super(message);
+    this.status = status;
+    this.endpoint = endpoint;
+    this.body = body;
+    this.name = "FluidsoulError";
+  }
+};
+
+// src/client.ts
+function buildHeaders(config, requestId) {
+  return {
+    "Authorization": `Bearer ${config.token}`,
+    "Content-Type": "application/json",
+    "X-Workspace-Id": config.workspaceId,
+    ...requestId ? { "X-Request-Id": requestId } : {}
+  };
+}
+async function assertOk(res, endpoint) {
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new FluidsoulError(
+      `fluidsoul request failed: ${endpoint} returned ${res.status}`,
+      res.status,
+      endpoint,
+      body
+    );
+  }
+}
+async function sendEvent(config, input, requestId) {
+  const endpoint = `${config.apiUrl}/v1/events/ingest`;
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: buildHeaders(config, requestId),
+    body: JSON.stringify({
+      user_id: input.userId,
+      event_type: input.eventType,
+      event_time: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata: input.metadata ?? {}
+    })
+  });
+  await assertOk(res, endpoint);
+}
+async function refreshContext(config, userId, requestId) {
+  const endpoint = `${config.apiUrl}/v1/context/refresh`;
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: buildHeaders(config, requestId),
+    body: JSON.stringify({
+      user_id: userId,
+      refresh_reason: "new_events"
+    })
+  });
+  await assertOk(res, endpoint);
+}
+async function getContext(config, userId, requestId) {
+  const endpoint = `${config.apiUrl}/v1/context/users/${encodeURIComponent(userId)}`;
+  const res = await fetch(endpoint, {
+    method: "GET",
+    headers: buildHeaders(config, requestId)
+  });
+  if (res.status === 404) return null;
+  await assertOk(res, endpoint);
+  return res.json();
+}
+
+// src/helpers.ts
+function createFluidsoulConfig(overrides) {
+  const env = typeof globalThis !== "undefined" && "process" in globalThis ? globalThis.process : void 0;
+  const vars = env?.env ?? {};
+  return {
+    apiUrl: overrides?.apiUrl ?? vars.FLUIDSOUL_API_URL ?? vars.NEXT_PUBLIC_FLUIDSOUL_API_URL ?? "http://localhost:4000",
+    token: overrides?.token ?? vars.FLUIDSOUL_API_TOKEN ?? vars.NEXT_PUBLIC_FLUIDSOUL_API_TOKEN ?? "",
+    workspaceId: overrides?.workspaceId ?? vars.FLUIDSOUL_WORKSPACE_ID ?? vars.NEXT_PUBLIC_FLUIDSOUL_WORKSPACE_ID ?? ""
+  };
+}
+var FluidsoulClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /** Send a user action event. */
+  async sendEvent(input, requestId) {
+    return sendEvent(this.config, input, requestId);
+  }
+  /** Trigger a context refresh for a user. */
+  async refreshContext(userId, requestId) {
+    return refreshContext(this.config, userId, requestId);
+  }
+  /** Get the current computed context for a user. Returns null if not found. */
+  async getContext(userId, requestId) {
+    return getContext(this.config, userId, requestId);
+  }
+};
+export {
+  FluidsoulClient,
+  FluidsoulError,
+  createFluidsoulConfig,
+  getContext,
+  refreshContext,
+  sendEvent
+};

package/dist/react/index.cjs

@@ -0,0 +1,181 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FluidsoulProvider: () => FluidsoulProvider,
+  useFluidsoulContext: () => useFluidsoulContext,
+  useFluidsoulEvents: () => useFluidsoulEvents
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/react/FluidsoulProvider.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var FluidsoulContext = (0, import_react.createContext)(null);
+function FluidsoulProvider({ apiUrl, token, workspaceId, children }) {
+  const config = { apiUrl, token, workspaceId };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FluidsoulContext.Provider, { value: config, children });
+}
+function useFluidsoulConfig() {
+  const config = (0, import_react.useContext)(FluidsoulContext);
+  if (!config) {
+    throw new Error(
+      "useFluidsoulConfig: no FluidsoulProvider found. Wrap your component tree with <FluidsoulProvider>."
+    );
+  }
+  return config;
+}
+
+// src/react/useFluidsoulContext.ts
+var import_react2 = require("react");
+
+// src/types.ts
+var FluidsoulError = class extends Error {
+  constructor(message, status, endpoint, body) {
+    super(message);
+    this.status = status;
+    this.endpoint = endpoint;
+    this.body = body;
+    this.name = "FluidsoulError";
+  }
+};
+
+// src/client.ts
+function buildHeaders(config, requestId) {
+  return {
+    "Authorization": `Bearer ${config.token}`,
+    "Content-Type": "application/json",
+    "X-Workspace-Id": config.workspaceId,
+    ...requestId ? { "X-Request-Id": requestId } : {}
+  };
+}
+async function assertOk(res, endpoint) {
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new FluidsoulError(
+      `fluidsoul request failed: ${endpoint} returned ${res.status}`,
+      res.status,
+      endpoint,
+      body
+    );
+  }
+}
+async function sendEvent(config, input, requestId) {
+  const endpoint = `${config.apiUrl}/v1/events/ingest`;
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: buildHeaders(config, requestId),
+    body: JSON.stringify({
+      user_id: input.userId,
+      event_type: input.eventType,
+      event_time: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata: input.metadata ?? {}
+    })
+  });
+  await assertOk(res, endpoint);
+}
+async function refreshContext(config, userId, requestId) {
+  const endpoint = `${config.apiUrl}/v1/context/refresh`;
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: buildHeaders(config, requestId),
+    body: JSON.stringify({
+      user_id: userId,
+      refresh_reason: "new_events"
+    })
+  });
+  await assertOk(res, endpoint);
+}
+async function getContext(config, userId, requestId) {
+  const endpoint = `${config.apiUrl}/v1/context/users/${encodeURIComponent(userId)}`;
+  const res = await fetch(endpoint, {
+    method: "GET",
+    headers: buildHeaders(config, requestId)
+  });
+  if (res.status === 404) return null;
+  await assertOk(res, endpoint);
+  return res.json();
+}
+
+// src/react/useFluidsoulContext.ts
+function useFluidsoulContext(userId) {
+  const config = useFluidsoulConfig();
+  const [context, setContext] = (0, import_react2.useState)(null);
+  const [loading, setLoading] = (0, import_react2.useState)(true);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const mountedRef = (0, import_react2.useRef)(true);
+  (0, import_react2.useEffect)(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const fetchContext = (0, import_react2.useCallback)(async () => {
+    if (!mountedRef.current) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await getContext(config, userId);
+      if (mountedRef.current) {
+        setContext(result);
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [config, userId]);
+  (0, import_react2.useEffect)(() => {
+    void fetchContext();
+  }, [fetchContext]);
+  const refresh = (0, import_react2.useCallback)(async () => {
+    try {
+      await refreshContext(config, userId);
+    } catch {
+    }
+    await fetchContext();
+  }, [config, userId, fetchContext]);
+  return { context, loading, error, refresh };
+}
+
+// src/react/useFluidsoulEvents.ts
+var import_react3 = require("react");
+function useFluidsoulEvents() {
+  const config = useFluidsoulConfig();
+  const sendEvent2 = (0, import_react3.useCallback)(
+    (input) => {
+      void sendEvent(config, input).catch(() => {
+      });
+    },
+    [config]
+  );
+  return { sendEvent: sendEvent2 };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FluidsoulProvider,
+  useFluidsoulContext,
+  useFluidsoulEvents
+});

package/dist/react/index.d.cts

@@ -0,0 +1,180 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+
+/**
+ * Configuration required to connect to a fluidsoul API server.
+ * Store these values in environment variables — never hardcode them.
+ */
+interface FluidsoulConfig {
+    /** URL of the fluidsoul API server. e.g. "https://api.fluidsoul.dev" or "http://localhost:4000" */
+    apiUrl: string;
+    /** Bearer token for your workspace. Set via fluidsoul CLI: `fluidsoul token set <token>` */
+    token: string;
+    /** Your workspace ID (UUID). Found in your fluidsoul dashboard or config file. */
+    workspaceId: string;
+}
+/**
+ * The computed context profile for a user.
+ * fluidsoul produces this by running its rules engine over the user's event history.
+ * Use it to decide what your UI should show, hide, prioritize, or pre-configure.
+ */
+interface UserContext {
+    user_id: string;
+    /**
+     * What kind of user this is, inferred from their behavior.
+     * The possible values depend on your workspace's rules config dimensions.
+     * Examples: "b2b_focused", "analyst", "power_user", "new_user", "hybrid"
+     */
+    user_category: string;
+    /**
+     * The dominant mode/value this user prefers based on their activity.
+     * Derived from the primary dimension in your rules config.
+     */
+    preferred_mode: string;
+    /**
+     * Features ordered by how relevant they are to this user.
+     * Use this to decide what to surface first in your UI.
+     * e.g. ["discovery", "lead_management", "analytics", "scanning"]
+     */
+    feature_priorities: string[];
+    /**
+     * Suggested default settings to pre-configure for this user.
+     * Keys and values depend on your workspace's rules config.
+     * e.g. { "default_view": "reports", "default_period": "weekly" }
+     */
+    recommended_defaults: Record<string, string>;
+    /** How actively this user engages with the app. */
+    engagement_level: "low" | "moderate" | "high";
+    /**
+     * How experienced this user is with the app.
+     * - "new" — show onboarding hints and tooltips
+     * - "intermediate" — show hints for unfamiliar features only
+     * - "power_user" — hide onboarding, show advanced options
+     */
+    user_maturity: "new" | "intermediate" | "power_user";
+    /**
+     * How confident fluidsoul is about each inference, as a number between 0 and 1.
+     * e.g. { "user_category": 0.85, "preferred_mode": 0.92 }
+     */
+    confidence_scores: Record<string, number>;
+    /**
+     * Plain-English reasons explaining why the context looks the way it does.
+     * e.g. ["Classified as 'analyst' based on 12 analyst and 3 executive signals"]
+     * Show these to developers and power users for transparency.
+     */
+    explainability: string[];
+    /**
+     * A natural-language summary of this user, generated by an LLM.
+     * Null if no LLM is configured or inference hasn't run yet.
+     */
+    user_narrative?: string | null;
+    /**
+     * How this context was computed.
+     * - "rules" — deterministic rules engine only
+     * - "rules+llm" — rules engine + LLM-generated narrative
+     */
+    inference_source?: "rules" | "rules+llm";
+    /** ISO 8601 timestamp of when this context was last computed. */
+    last_refreshed_at: string;
+}
+/** Input for sending a user action event to fluidsoul. */
+interface SendEventInput {
+    /** The ID of the user who performed the action. Must match how you identify users in your app. */
+    userId: string;
+    /**
+     * What the user did. Use consistent names across your app.
+     * Define event types that match your workspace's signal conditions.
+     */
+    eventType: string;
+    /** Optional extra details about the event. e.g. { platform: "linkedin" } or { feature_name: "analytics" } */
+    metadata?: Record<string, unknown>;
+}
+/** Error thrown when a fluidsoul API call fails. */
+declare class FluidsoulError extends Error {
+    readonly status: number;
+    readonly endpoint: string;
+    readonly body: string;
+    constructor(message: string, status: number, endpoint: string, body: string);
+}
+
+interface FluidsoulProviderProps extends FluidsoulConfig {
+    children: React.ReactNode;
+}
+declare function FluidsoulProvider({ apiUrl, token, workspaceId, children }: FluidsoulProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * useFluidsoulContext — fetch and subscribe to a user's fluidsoul context profile.
+ *
+ * Drop this hook into any component that needs to adapt its UI based on who
+ * the current user is. The hook fetches on mount and re-fetches whenever
+ * the userId changes.
+ *
+ * Requires <FluidsoulProvider> somewhere above this component in the tree.
+ *
+ * @example
+ * function Dashboard({ userId }: { userId: string }) {
+ *   const { context, loading, error } = useFluidsoulContext(userId)
+ *
+ *   if (loading) return <Spinner />
+ *
+ *   const features = context?.feature_priorities ?? ["scan", "leads", "analytics"]
+ *   const showOnboarding = !context || context.user_maturity === "new"
+ *
+ *   return (
+ *     <div>
+ *       {showOnboarding && <OnboardingBanner />}
+ *       <FeatureGrid features={features} />
+ *     </div>
+ *   )
+ * }
+ */
+
+interface UseFluidsoulContextResult {
+    /** The user's current context profile. Null if not yet loaded or user has no context. */
+    context: UserContext | null;
+    /** True while the initial fetch is in progress. */
+    loading: boolean;
+    /** Set if the fetch failed. Your UI should fall back to its default layout. */
+    error: FluidsoulError | Error | null;
+    /**
+     * Manually trigger a context refresh then re-fetch.
+     * Call this after sending a batch of events (e.g., end of session).
+     * Returns a promise that resolves when the refresh and re-fetch are complete.
+     */
+    refresh: () => Promise<void>;
+}
+declare function useFluidsoulContext(userId: string): UseFluidsoulContextResult;
+
+/**
+ * useFluidsoulEvents — send user action events from any React component.
+ *
+ * Returns a `sendEvent` function that fires events to fluidsoul fire-and-forget style
+ * (it never blocks your UI or throws — failures are silently ignored so your app
+ * always keeps working even if fluidsoul is temporarily unavailable).
+ *
+ * Requires <FluidsoulProvider> somewhere above this component in the tree.
+ *
+ * @example
+ * function ScanButton({ userId }: { userId: string }) {
+ *   const { sendEvent } = useFluidsoulEvents()
+ *
+ *   function handleScan() {
+ *     sendEvent({ userId, eventType: "scan_triggered", metadata: { scan_type: "b2b", platform: "linkedin" } })
+ *     // Continue immediately — don't wait for fluidsoul
+ *     startScan()
+ *   }
+ *
+ *   return <button onClick={handleScan}>Scan</button>
+ * }
+ */
+
+interface UseFluidsoulEventsResult {
+    /**
+     * Send a user action event to fluidsoul.
+     * Fire-and-forget: call it and move on. Never awaited, never throws.
+     */
+    sendEvent: (input: SendEventInput) => void;
+}
+declare function useFluidsoulEvents(): UseFluidsoulEventsResult;
+
+export { type FluidsoulConfig, FluidsoulError, FluidsoulProvider, type SendEventInput, type UserContext, useFluidsoulContext, useFluidsoulEvents };

package/dist/react/index.d.ts

@@ -0,0 +1,180 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+
+/**
+ * Configuration required to connect to a fluidsoul API server.
+ * Store these values in environment variables — never hardcode them.
+ */
+interface FluidsoulConfig {
+    /** URL of the fluidsoul API server. e.g. "https://api.fluidsoul.dev" or "http://localhost:4000" */
+    apiUrl: string;
+    /** Bearer token for your workspace. Set via fluidsoul CLI: `fluidsoul token set <token>` */
+    token: string;
+    /** Your workspace ID (UUID). Found in your fluidsoul dashboard or config file. */
+    workspaceId: string;
+}
+/**
+ * The computed context profile for a user.
+ * fluidsoul produces this by running its rules engine over the user's event history.
+ * Use it to decide what your UI should show, hide, prioritize, or pre-configure.
+ */
+interface UserContext {
+    user_id: string;
+    /**
+     * What kind of user this is, inferred from their behavior.
+     * The possible values depend on your workspace's rules config dimensions.
+     * Examples: "b2b_focused", "analyst", "power_user", "new_user", "hybrid"
+     */
+    user_category: string;
+    /**
+     * The dominant mode/value this user prefers based on their activity.
+     * Derived from the primary dimension in your rules config.
+     */
+    preferred_mode: string;
+    /**
+     * Features ordered by how relevant they are to this user.
+     * Use this to decide what to surface first in your UI.
+     * e.g. ["discovery", "lead_management", "analytics", "scanning"]
+     */
+    feature_priorities: string[];
+    /**
+     * Suggested default settings to pre-configure for this user.
+     * Keys and values depend on your workspace's rules config.
+     * e.g. { "default_view": "reports", "default_period": "weekly" }
+     */
+    recommended_defaults: Record<string, string>;
+    /** How actively this user engages with the app. */
+    engagement_level: "low" | "moderate" | "high";
+    /**
+     * How experienced this user is with the app.
+     * - "new" — show onboarding hints and tooltips
+     * - "intermediate" — show hints for unfamiliar features only
+     * - "power_user" — hide onboarding, show advanced options
+     */
+    user_maturity: "new" | "intermediate" | "power_user";
+    /**
+     * How confident fluidsoul is about each inference, as a number between 0 and 1.
+     * e.g. { "user_category": 0.85, "preferred_mode": 0.92 }
+     */
+    confidence_scores: Record<string, number>;
+    /**
+     * Plain-English reasons explaining why the context looks the way it does.
+     * e.g. ["Classified as 'analyst' based on 12 analyst and 3 executive signals"]
+     * Show these to developers and power users for transparency.
+     */
+    explainability: string[];
+    /**
+     * A natural-language summary of this user, generated by an LLM.
+     * Null if no LLM is configured or inference hasn't run yet.
+     */
+    user_narrative?: string | null;
+    /**
+     * How this context was computed.
+     * - "rules" — deterministic rules engine only
+     * - "rules+llm" — rules engine + LLM-generated narrative
+     */
+    inference_source?: "rules" | "rules+llm";
+    /** ISO 8601 timestamp of when this context was last computed. */
+    last_refreshed_at: string;
+}
+/** Input for sending a user action event to fluidsoul. */
+interface SendEventInput {
+    /** The ID of the user who performed the action. Must match how you identify users in your app. */
+    userId: string;
+    /**
+     * What the user did. Use consistent names across your app.
+     * Define event types that match your workspace's signal conditions.
+     */
+    eventType: string;
+    /** Optional extra details about the event. e.g. { platform: "linkedin" } or { feature_name: "analytics" } */
+    metadata?: Record<string, unknown>;
+}
+/** Error thrown when a fluidsoul API call fails. */
+declare class FluidsoulError extends Error {
+    readonly status: number;
+    readonly endpoint: string;
+    readonly body: string;
+    constructor(message: string, status: number, endpoint: string, body: string);
+}
+
+interface FluidsoulProviderProps extends FluidsoulConfig {
+    children: React.ReactNode;
+}
+declare function FluidsoulProvider({ apiUrl, token, workspaceId, children }: FluidsoulProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * useFluidsoulContext — fetch and subscribe to a user's fluidsoul context profile.
+ *
+ * Drop this hook into any component that needs to adapt its UI based on who
+ * the current user is. The hook fetches on mount and re-fetches whenever
+ * the userId changes.
+ *
+ * Requires <FluidsoulProvider> somewhere above this component in the tree.
+ *
+ * @example
+ * function Dashboard({ userId }: { userId: string }) {
+ *   const { context, loading, error } = useFluidsoulContext(userId)
+ *
+ *   if (loading) return <Spinner />
+ *
+ *   const features = context?.feature_priorities ?? ["scan", "leads", "analytics"]
+ *   const showOnboarding = !context || context.user_maturity === "new"
+ *
+ *   return (
+ *     <div>
+ *       {showOnboarding && <OnboardingBanner />}
+ *       <FeatureGrid features={features} />
+ *     </div>
+ *   )
+ * }
+ */
+
+interface UseFluidsoulContextResult {
+    /** The user's current context profile. Null if not yet loaded or user has no context. */
+    context: UserContext | null;
+    /** True while the initial fetch is in progress. */
+    loading: boolean;
+    /** Set if the fetch failed. Your UI should fall back to its default layout. */
+    error: FluidsoulError | Error | null;
+    /**
+     * Manually trigger a context refresh then re-fetch.
+     * Call this after sending a batch of events (e.g., end of session).
+     * Returns a promise that resolves when the refresh and re-fetch are complete.
+     */
+    refresh: () => Promise<void>;
+}
+declare function useFluidsoulContext(userId: string): UseFluidsoulContextResult;
+
+/**
+ * useFluidsoulEvents — send user action events from any React component.
+ *
+ * Returns a `sendEvent` function that fires events to fluidsoul fire-and-forget style
+ * (it never blocks your UI or throws — failures are silently ignored so your app
+ * always keeps working even if fluidsoul is temporarily unavailable).
+ *
+ * Requires <FluidsoulProvider> somewhere above this component in the tree.
+ *
+ * @example
+ * function ScanButton({ userId }: { userId: string }) {
+ *   const { sendEvent } = useFluidsoulEvents()
+ *
+ *   function handleScan() {
+ *     sendEvent({ userId, eventType: "scan_triggered", metadata: { scan_type: "b2b", platform: "linkedin" } })
+ *     // Continue immediately — don't wait for fluidsoul
+ *     startScan()
+ *   }
+ *
+ *   return <button onClick={handleScan}>Scan</button>
+ * }
+ */
+
+interface UseFluidsoulEventsResult {
+    /**
+     * Send a user action event to fluidsoul.
+     * Fire-and-forget: call it and move on. Never awaited, never throws.
+     */
+    sendEvent: (input: SendEventInput) => void;
+}
+declare function useFluidsoulEvents(): UseFluidsoulEventsResult;
+
+export { type FluidsoulConfig, FluidsoulError, FluidsoulProvider, type SendEventInput, type UserContext, useFluidsoulContext, useFluidsoulEvents };

package/dist/react/index.js

@@ -0,0 +1,152 @@
+// src/react/FluidsoulProvider.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var FluidsoulContext = createContext(null);
+function FluidsoulProvider({ apiUrl, token, workspaceId, children }) {
+  const config = { apiUrl, token, workspaceId };
+  return /* @__PURE__ */ jsx(FluidsoulContext.Provider, { value: config, children });
+}
+function useFluidsoulConfig() {
+  const config = useContext(FluidsoulContext);
+  if (!config) {
+    throw new Error(
+      "useFluidsoulConfig: no FluidsoulProvider found. Wrap your component tree with <FluidsoulProvider>."
+    );
+  }
+  return config;
+}
+
+// src/react/useFluidsoulContext.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/types.ts
+var FluidsoulError = class extends Error {
+  constructor(message, status, endpoint, body) {
+    super(message);
+    this.status = status;
+    this.endpoint = endpoint;
+    this.body = body;
+    this.name = "FluidsoulError";
+  }
+};
+
+// src/client.ts
+function buildHeaders(config, requestId) {
+  return {
+    "Authorization": `Bearer ${config.token}`,
+    "Content-Type": "application/json",
+    "X-Workspace-Id": config.workspaceId,
+    ...requestId ? { "X-Request-Id": requestId } : {}
+  };
+}
+async function assertOk(res, endpoint) {
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new FluidsoulError(
+      `fluidsoul request failed: ${endpoint} returned ${res.status}`,
+      res.status,
+      endpoint,
+      body
+    );
+  }
+}
+async function sendEvent(config, input, requestId) {
+  const endpoint = `${config.apiUrl}/v1/events/ingest`;
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: buildHeaders(config, requestId),
+    body: JSON.stringify({
+      user_id: input.userId,
+      event_type: input.eventType,
+      event_time: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata: input.metadata ?? {}
+    })
+  });
+  await assertOk(res, endpoint);
+}
+async function refreshContext(config, userId, requestId) {
+  const endpoint = `${config.apiUrl}/v1/context/refresh`;
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: buildHeaders(config, requestId),
+    body: JSON.stringify({
+      user_id: userId,
+      refresh_reason: "new_events"
+    })
+  });
+  await assertOk(res, endpoint);
+}
+async function getContext(config, userId, requestId) {
+  const endpoint = `${config.apiUrl}/v1/context/users/${encodeURIComponent(userId)}`;
+  const res = await fetch(endpoint, {
+    method: "GET",
+    headers: buildHeaders(config, requestId)
+  });
+  if (res.status === 404) return null;
+  await assertOk(res, endpoint);
+  return res.json();
+}
+
+// src/react/useFluidsoulContext.ts
+function useFluidsoulContext(userId) {
+  const config = useFluidsoulConfig();
+  const [context, setContext] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const fetchContext = useCallback(async () => {
+    if (!mountedRef.current) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await getContext(config, userId);
+      if (mountedRef.current) {
+        setContext(result);
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [config, userId]);
+  useEffect(() => {
+    void fetchContext();
+  }, [fetchContext]);
+  const refresh = useCallback(async () => {
+    try {
+      await refreshContext(config, userId);
+    } catch {
+    }
+    await fetchContext();
+  }, [config, userId, fetchContext]);
+  return { context, loading, error, refresh };
+}
+
+// src/react/useFluidsoulEvents.ts
+import { useCallback as useCallback2 } from "react";
+function useFluidsoulEvents() {
+  const config = useFluidsoulConfig();
+  const sendEvent2 = useCallback2(
+    (input) => {
+      void sendEvent(config, input).catch(() => {
+      });
+    },
+    [config]
+  );
+  return { sendEvent: sendEvent2 };
+}
+export {
+  FluidsoulProvider,
+  useFluidsoulContext,
+  useFluidsoulEvents
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "fluidsoul-js",
+  "version": "0.1.0",
+  "description": "Adaptive user context for every app. Classify users, compute engagement, recommend features — from behavior events. Official JavaScript/TypeScript SDK.",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.js",
+      "require": "./dist/react/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "user-context",
+    "adaptive-ui",
+    "personalization",
+    "behavior-analytics",
+    "rules-engine",
+    "react",
+    "next.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/linden-hub/fluidsoul"
+  },
+  "homepage": "https://fluidsoul.dev",
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}