@paceful/sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1938 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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/widgets/PacefulProvider.tsx
+var PacefulProvider_exports = {};
+__export(PacefulProvider_exports, {
+  PacefulProvider: () => PacefulProvider,
+  usePaceful: () => usePaceful
+});
+import React, { createContext, useContext, useMemo } from "react";
+function usePaceful() {
+  const ctx = useContext(PacefulContext);
+  if (!ctx) throw new Error("Wrap your component tree with <PacefulProvider>");
+  return ctx;
+}
+function PacefulProvider({ apiKey, userId, baseUrl, children }) {
+  const value = useMemo(() => ({
+    apiKey,
+    userId,
+    baseUrl: baseUrl || "https://paceful-app.vercel.app/api/v1/partner"
+  }), [apiKey, userId, baseUrl]);
+  return React.createElement(PacefulContext.Provider, { value }, children);
+}
+var PacefulContext;
+var init_PacefulProvider = __esm({
+  "src/widgets/PacefulProvider.tsx"() {
+    "use strict";
+    PacefulContext = createContext(null);
+  }
+});
+
+// src/utils/errors.ts
+var PacefulError = class _PacefulError extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.name = "PacefulError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _PacefulError);
+    }
+  }
+};
+var PacefulAuthError = class extends PacefulError {
+  constructor(message = "Invalid or expired API key") {
+    super(message, "UNAUTHORIZED", 401);
+    this.name = "PacefulAuthError";
+  }
+};
+var PacefulRateLimitError = class extends PacefulError {
+  constructor(retryAfter = 3600) {
+    super("Rate limit exceeded", "RATE_LIMITED", 429);
+    this.name = "PacefulRateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var PacefulNotFoundError = class extends PacefulError {
+  constructor(resource = "Resource") {
+    super(`${resource} not found`, "NOT_FOUND", 404);
+    this.name = "PacefulNotFoundError";
+  }
+};
+var PacefulValidationError = class extends PacefulError {
+  constructor(message, details) {
+    super(message, "BAD_REQUEST", 400, details);
+    this.name = "PacefulValidationError";
+  }
+};
+var PacefulNetworkError = class extends PacefulError {
+  constructor(message = "Network request failed") {
+    super(message, "NETWORK_ERROR");
+    this.name = "PacefulNetworkError";
+  }
+};
+function parseApiError(statusCode, body, headers) {
+  const message = body.error?.message || body.message || "Unknown error";
+  const code = body.error?.code || "UNKNOWN_ERROR";
+  switch (statusCode) {
+    case 401:
+      return new PacefulAuthError(message);
+    case 404:
+      return new PacefulNotFoundError(message);
+    case 429: {
+      const retryAfter = headers?.get("Retry-After");
+      return new PacefulRateLimitError(
+        retryAfter ? parseInt(retryAfter, 10) : 3600
+      );
+    }
+    case 400:
+      return new PacefulValidationError(message);
+    default:
+      return new PacefulError(message, code, statusCode);
+  }
+}
+
+// src/utils/http.ts
+var DEFAULT_BASE_URL = "https://api.paceful.app";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRIES = 3;
+var HttpClient = class {
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new PacefulError("API key is required", "CONFIGURATION_ERROR");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+    this.maxRetries = config.retries ?? DEFAULT_RETRIES;
+  }
+  async request(options) {
+    const { method, path, body, query } = options;
+    let url = `${this.baseUrl}${path}`;
+    if (query) {
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) {
+          params.append(key, String(value));
+        }
+      }
+      const queryString = params.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "X-API-Key": this.apiKey,
+      "User-Agent": "@paceful/sdk/1.0.0"
+    };
+    const fetchOptions = {
+      method,
+      headers
+    };
+    if (body && method !== "GET") {
+      fetchOptions.body = JSON.stringify(body);
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        fetchOptions.signal = controller.signal;
+        const response = await fetch(url, fetchOptions);
+        clearTimeout(timeoutId);
+        const responseBody = await response.json();
+        if (!response.ok) {
+          const error = parseApiError(
+            response.status,
+            responseBody,
+            response.headers
+          );
+          if (response.status < 500 && response.status !== 429) {
+            throw error;
+          }
+          lastError = error;
+          if (attempt < this.maxRetries) {
+            const backoffMs = Math.min(1e3 * Math.pow(2, attempt), 1e4);
+            await this.sleep(backoffMs);
+            continue;
+          }
+          throw error;
+        }
+        if (!responseBody.success) {
+          throw new PacefulError(
+            responseBody.error?.message || "Request failed",
+            responseBody.error?.code || "UNKNOWN_ERROR"
+          );
+        }
+        return responseBody.data;
+      } catch (error) {
+        if (error instanceof PacefulError) {
+          throw error;
+        }
+        if (error instanceof Error) {
+          if (error.name === "AbortError") {
+            lastError = new PacefulNetworkError("Request timed out");
+          } else {
+            lastError = new PacefulNetworkError(error.message);
+          }
+        }
+        if (attempt < this.maxRetries) {
+          const backoffMs = Math.min(1e3 * Math.pow(2, attempt), 1e4);
+          await this.sleep(backoffMs);
+          continue;
+        }
+        throw lastError || new PacefulNetworkError();
+      }
+    }
+    throw lastError || new PacefulNetworkError();
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // Convenience methods
+  async get(path, query) {
+    return this.request({ method: "GET", path, query });
+  }
+  async post(path, body) {
+    return this.request({ method: "POST", path, body });
+  }
+  async put(path, body) {
+    return this.request({ method: "PUT", path, body });
+  }
+  async patch(path, body) {
+    return this.request({ method: "PATCH", path, body });
+  }
+  async delete(path) {
+    return this.request({ method: "DELETE", path });
+  }
+};
+
+// src/modules/users.ts
+var Users = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Register a new user or update existing user metadata
+   *
+   * @param params - User registration parameters
+   * @returns The registered or updated user
+   *
+   * @example
+   * ```typescript
+   * const user = await paceful.users.register({
+   *   externalId: 'user_123',
+   *   email: 'user@example.com',
+   *   metadata: { plan: 'premium' }
+   * });
+   * ```
+   */
+  async register(params) {
+    return this.http.post("/api/v1/partner/users", {
+      externalId: params.externalId,
+      email: params.email,
+      metadata: params.metadata
+    });
+  }
+  /**
+   * Get a user by their external ID
+   *
+   * @param externalId - Your system's user identifier
+   * @returns The user if found
+   *
+   * @example
+   * ```typescript
+   * const user = await paceful.users.get('user_123');
+   * ```
+   */
+  async get(externalId) {
+    return this.http.get(`/api/v1/partner/users/${externalId}`);
+  }
+  /**
+   * Update a user's metadata
+   *
+   * @param externalId - Your system's user identifier
+   * @param metadata - New metadata to merge with existing
+   * @returns The updated user
+   *
+   * @example
+   * ```typescript
+   * const user = await paceful.users.update('user_123', {
+   *   metadata: { plan: 'enterprise' }
+   * });
+   * ```
+   */
+  async update(externalId, params) {
+    return this.http.patch(`/api/v1/partner/users/${externalId}`, params);
+  }
+  /**
+   * List all users for this partner
+   *
+   * @param params - Pagination parameters
+   * @returns Paginated list of users
+   *
+   * @example
+   * ```typescript
+   * const { items, total, hasMore } = await paceful.users.list({ limit: 50 });
+   * ```
+   */
+  async list(params) {
+    return this.http.get("/api/v1/partner/users", {
+      limit: params?.limit,
+      cursor: params?.cursor
+    });
+  }
+  /**
+   * Delete a user and all their data
+   *
+   * @param externalId - Your system's user identifier
+   *
+   * @example
+   * ```typescript
+   * await paceful.users.delete('user_123');
+   * ```
+   */
+  async delete(externalId) {
+    await this.http.delete(`/api/v1/partner/users/${externalId}`);
+  }
+};
+
+// src/modules/mood.ts
+var Mood = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Log a mood entry for a user
+   *
+   * @param params - Mood log parameters
+   * @returns The created mood entry
+   *
+   * @example
+   * ```typescript
+   * const entry = await paceful.mood.log({
+   *   externalId: 'user_123',
+   *   mood: 4,
+   *   note: 'Feeling productive today',
+   *   factors: ['work', 'exercise']
+   * });
+   * ```
+   */
+  async log(params) {
+    return this.http.post("/api/v1/partner/mood", {
+      externalId: params.externalId,
+      mood: params.mood,
+      note: params.note,
+      factors: params.factors,
+      timestamp: params.timestamp
+    });
+  }
+  /**
+   * Get mood history for a user
+   *
+   * @param params - History query parameters
+   * @returns List of mood entries
+   *
+   * @example
+   * ```typescript
+   * const history = await paceful.mood.history({
+   *   externalId: 'user_123',
+   *   startDate: '2024-01-01',
+   *   limit: 30
+   * });
+   * ```
+   */
+  async history(params) {
+    return this.http.get(`/api/v1/partner/mood/${params.externalId}/history`, {
+      startDate: params.startDate,
+      endDate: params.endDate,
+      limit: params.limit
+    });
+  }
+  /**
+   * Get the latest mood entry for a user
+   *
+   * @param externalId - Your system's user identifier
+   * @returns The most recent mood entry or null
+   *
+   * @example
+   * ```typescript
+   * const latest = await paceful.mood.latest('user_123');
+   * if (latest) {
+   *   console.log(`Last mood: ${latest.mood}`);
+   * }
+   * ```
+   */
+  async latest(externalId) {
+    return this.http.get(`/api/v1/partner/mood/${externalId}/latest`);
+  }
+  /**
+   * Get mood statistics for a user over a time period
+   *
+   * @param externalId - Your system's user identifier
+   * @param period - Time period ('7d', '30d', '90d', 'all')
+   * @returns Mood statistics
+   *
+   * @example
+   * ```typescript
+   * const stats = await paceful.mood.stats('user_123', '30d');
+   * console.log(`Average mood: ${stats.average}`);
+   * ```
+   */
+  async stats(externalId, period = "30d") {
+    return this.http.get(`/api/v1/partner/mood/${externalId}/stats`, { period });
+  }
+};
+
+// src/modules/journal.ts
+var Journal = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a journal entry for a user
+   *
+   * @param params - Journal entry parameters
+   * @returns The created journal entry with AI analysis
+   *
+   * @example
+   * ```typescript
+   * const entry = await paceful.journal.create({
+   *   externalId: 'user_123',
+   *   content: 'Today I reflected on my progress...',
+   *   mood: 4
+   * });
+   *
+   * console.log('Themes:', entry.themes);
+   * console.log('Sentiment:', entry.sentimentScore);
+   * ```
+   */
+  async create(params) {
+    return this.http.post("/api/v1/partner/journal", {
+      externalId: params.externalId,
+      content: params.content,
+      promptId: params.promptId,
+      mood: params.mood
+    });
+  }
+  /**
+   * Get journal history for a user
+   *
+   * @param params - History query parameters
+   * @returns List of journal entries
+   *
+   * @example
+   * ```typescript
+   * const entries = await paceful.journal.history({
+   *   externalId: 'user_123',
+   *   limit: 10
+   * });
+   * ```
+   */
+  async history(params) {
+    return this.http.get(`/api/v1/partner/journal/${params.externalId}/history`, {
+      startDate: params.startDate,
+      endDate: params.endDate,
+      limit: params.limit
+    });
+  }
+  /**
+   * Get a specific journal entry
+   *
+   * @param externalId - Your system's user identifier
+   * @param entryId - The journal entry ID
+   * @returns The journal entry
+   *
+   * @example
+   * ```typescript
+   * const entry = await paceful.journal.get('user_123', 'entry_abc');
+   * ```
+   */
+  async get(externalId, entryId) {
+    return this.http.get(`/api/v1/partner/journal/${externalId}/${entryId}`);
+  }
+  /**
+   * Get available journal prompts
+   *
+   * @returns List of prompts categorized by theme
+   *
+   * @example
+   * ```typescript
+   * const prompts = await paceful.journal.prompts();
+   * const gratitudePrompts = prompts.gratitude;
+   * ```
+   */
+  async prompts() {
+    return this.http.get("/api/v1/partner/journal/prompts");
+  }
+  /**
+   * Get journal statistics for a user
+   *
+   * @param externalId - Your system's user identifier
+   * @param period - Time period ('7d', '30d', '90d', 'all')
+   * @returns Journal statistics
+   *
+   * @example
+   * ```typescript
+   * const stats = await paceful.journal.stats('user_123', '30d');
+   * console.log(`Entries this month: ${stats.count}`);
+   * ```
+   */
+  async stats(externalId, period = "30d") {
+    return this.http.get(`/api/v1/partner/journal/${externalId}/stats`, { period });
+  }
+};
+
+// src/modules/ers.ts
+var ERS = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get the current ERS score for a user
+   * Returns cached score if recent (< 24 hours), otherwise calculates fresh
+   *
+   * @param externalId - Your system's user identifier
+   * @returns The user's ERS score with trend data
+   *
+   * @example
+   * ```typescript
+   * const ers = await paceful.ers.get('user_123');
+   *
+   * console.log(`ERS Score: ${ers.ersScore}`);
+   * console.log(`Stage: ${ers.stage}`);
+   * console.log(`Trend: ${ers.trend?.direction}`);
+   * ```
+   */
+  async get(externalId) {
+    return this.http.get(`/api/v1/partner/ers/${externalId}`);
+  }
+  /**
+   * Force a fresh ERS calculation for a user
+   * Useful after significant user activity
+   *
+   * @param externalId - Your system's user identifier
+   * @returns Fresh calculation results with change data
+   *
+   * @example
+   * ```typescript
+   * const result = await paceful.ers.calculate('user_123');
+   *
+   * if (result.change !== null) {
+   *   console.log(`Score changed by ${result.change} points`);
+   * }
+   * ```
+   */
+  async calculate(externalId) {
+    return this.http.post("/api/v1/partner/ers/calculate", {
+      externalId
+    });
+  }
+  /**
+   * Get ERS scores for multiple users in a single request
+   * Maximum 50 users per request
+   *
+   * @param externalIds - Array of your system's user identifiers
+   * @returns Batch results with scores for each user
+   *
+   * @example
+   * ```typescript
+   * const batch = await paceful.ers.batch(['user_1', 'user_2', 'user_3']);
+   *
+   * for (const result of batch.results) {
+   *   console.log(`${result.externalId}: ${result.ersScore}`);
+   * }
+   * ```
+   */
+  async batch(externalIds) {
+    return this.http.post("/api/v1/partner/ers/batch", {
+      externalIds
+    });
+  }
+  /**
+   * Get ERS score history for a user
+   *
+   * @param externalId - Your system's user identifier
+   * @param params - Query parameters
+   * @returns Historical ERS scores
+   *
+   * @example
+   * ```typescript
+   * const history = await paceful.ers.history('user_123', {
+   *   period: '30d',
+   *   granularity: 'daily'
+   * });
+   * ```
+   */
+  async history(externalId, params) {
+    return this.http.get(`/api/v1/partner/ers/${externalId}/history`, {
+      period: params?.period,
+      granularity: params?.granularity
+    });
+  }
+  /**
+   * Set up alerts for ERS threshold crossings
+   *
+   * @param params - Alert configuration
+   * @returns The created alert configuration
+   *
+   * @example
+   * ```typescript
+   * await paceful.ers.setThresholdAlert({
+   *   externalId: 'user_123',
+   *   threshold: 40,
+   *   direction: 'below',
+   *   webhookUrl: 'https://yourapp.com/alerts'
+   * });
+   * ```
+   */
+  async setThresholdAlert(params) {
+    return this.http.post("/api/v1/partner/ers/alerts", params);
+  }
+};
+
+// src/modules/analytics.ts
+var Analytics = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get aggregate analytics summary for all your users
+   *
+   * @param period - Time period for analytics ('7d', '30d', '90d', 'all')
+   * @returns Aggregate analytics summary
+   *
+   * @example
+   * ```typescript
+   * const summary = await paceful.analytics.summary('30d');
+   *
+   * console.log(`Total users: ${summary.totalUsers}`);
+   * console.log(`Average ERS: ${summary.averageErs}`);
+   * console.log(`Healing stage: ${summary.stageDistribution.healing * 100}%`);
+   * ```
+   */
+  async summary(period = "30d") {
+    return this.http.get("/api/v1/partner/analytics/summary", {
+      period
+    });
+  }
+  /**
+   * Get engagement metrics over time
+   *
+   * @param params - Query parameters
+   * @returns Time series engagement data
+   *
+   * @example
+   * ```typescript
+   * const engagement = await paceful.analytics.engagement({
+   *   period: '30d',
+   *   granularity: 'daily'
+   * });
+   *
+   * for (const point of engagement.dataPoints) {
+   *   console.log(`${point.date}: ${point.activeUsers} active users`);
+   * }
+   * ```
+   */
+  async engagement(params) {
+    return this.http.get("/api/v1/partner/analytics/engagement", {
+      period: params?.period,
+      granularity: params?.granularity
+    });
+  }
+  /**
+   * Get ERS distribution across all users
+   *
+   * @param period - Time period for analytics
+   * @returns ERS distribution data
+   *
+   * @example
+   * ```typescript
+   * const distribution = await paceful.analytics.ersDistribution('30d');
+   *
+   * console.log('Score ranges:');
+   * for (const bucket of distribution.buckets) {
+   *   console.log(`${bucket.range}: ${bucket.count} users`);
+   * }
+   * ```
+   */
+  async ersDistribution(period = "30d") {
+    return this.http.get("/api/v1/partner/analytics/ers-distribution", {
+      period
+    });
+  }
+  /**
+   * Get retention metrics
+   *
+   * @param period - Time period for analytics
+   * @returns Retention and churn data
+   *
+   * @example
+   * ```typescript
+   * const retention = await paceful.analytics.retention('30d');
+   *
+   * console.log(`Day 7 retention: ${retention.day7}%`);
+   * console.log(`Day 30 retention: ${retention.day30}%`);
+   * ```
+   */
+  async retention(period = "30d") {
+    return this.http.get("/api/v1/partner/analytics/retention", { period });
+  }
+  /**
+   * Export analytics data as CSV
+   *
+   * @param params - Export parameters
+   * @returns Download URL for the CSV
+   *
+   * @example
+   * ```typescript
+   * const { downloadUrl } = await paceful.analytics.export({
+   *   type: 'user_summary',
+   *   period: '30d'
+   * });
+   * ```
+   */
+  async export(params) {
+    return this.http.post("/api/v1/partner/analytics/export", params);
+  }
+};
+
+// src/modules/webhooks.ts
+var Webhooks = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Register a webhook endpoint for receiving events
+   * Updates existing webhook if same URL already registered
+   *
+   * @param params - Webhook configuration
+   * @returns Webhook registration details including secret
+   *
+   * @example
+   * ```typescript
+   * const webhook = await paceful.webhooks.register({
+   *   url: 'https://yourapp.com/webhooks/paceful',
+   *   events: ['ers.stage_changed', 'mood.critical']
+   * });
+   *
+   * // Store the secret securely for signature verification
+   * console.log('Webhook secret:', webhook.secret);
+   * ```
+   */
+  async register(params) {
+    return this.http.post("/api/v1/partner/webhooks/register", {
+      url: params.url,
+      events: params.events
+    });
+  }
+  /**
+   * List all registered webhooks
+   *
+   * @returns Array of webhook configurations
+   *
+   * @example
+   * ```typescript
+   * const webhooks = await paceful.webhooks.list();
+   *
+   * for (const webhook of webhooks) {
+   *   console.log(`${webhook.url}: ${webhook.events.join(', ')}`);
+   * }
+   * ```
+   */
+  async list() {
+    return this.http.get("/api/v1/partner/webhooks");
+  }
+  /**
+   * Get a specific webhook by ID
+   *
+   * @param webhookId - The webhook ID
+   * @returns Webhook configuration
+   *
+   * @example
+   * ```typescript
+   * const webhook = await paceful.webhooks.get('webhook_abc123');
+   * ```
+   */
+  async get(webhookId) {
+    return this.http.get(`/api/v1/partner/webhooks/${webhookId}`);
+  }
+  /**
+   * Update a webhook's configuration
+   *
+   * @param webhookId - The webhook ID
+   * @param params - Updated configuration
+   * @returns Updated webhook
+   *
+   * @example
+   * ```typescript
+   * await paceful.webhooks.update('webhook_abc123', {
+   *   events: ['ers.stage_changed', 'mood.critical', 'journal.created']
+   * });
+   * ```
+   */
+  async update(webhookId, params) {
+    return this.http.patch(`/api/v1/partner/webhooks/${webhookId}`, params);
+  }
+  /**
+   * Delete a webhook
+   *
+   * @param webhookId - The webhook ID
+   *
+   * @example
+   * ```typescript
+   * await paceful.webhooks.delete('webhook_abc123');
+   * ```
+   */
+  async delete(webhookId) {
+    await this.http.delete(`/api/v1/partner/webhooks/${webhookId}`);
+  }
+  /**
+   * Test a webhook by sending a test event
+   *
+   * @param webhookId - The webhook ID
+   * @returns Test result
+   *
+   * @example
+   * ```typescript
+   * const result = await paceful.webhooks.test('webhook_abc123');
+   *
+   * if (result.success) {
+   *   console.log('Webhook is working!');
+   * } else {
+   *   console.error('Test failed:', result.error);
+   * }
+   * ```
+   */
+  async test(webhookId) {
+    return this.http.post(`/api/v1/partner/webhooks/${webhookId}/test`);
+  }
+  /**
+   * Get delivery history for a webhook
+   *
+   * @param webhookId - The webhook ID
+   * @param params - Query parameters
+   * @returns Delivery history
+   *
+   * @example
+   * ```typescript
+   * const history = await paceful.webhooks.deliveryHistory('webhook_abc123', {
+   *   limit: 20
+   * });
+   *
+   * for (const delivery of history) {
+   *   console.log(`${delivery.event}: ${delivery.status}`);
+   * }
+   * ```
+   */
+  async deliveryHistory(webhookId, params) {
+    return this.http.get(`/api/v1/partner/webhooks/${webhookId}/deliveries`, {
+      limit: params?.limit,
+      status: params?.status
+    });
+  }
+  /**
+   * Rotate the webhook secret
+   *
+   * @param webhookId - The webhook ID
+   * @returns New webhook secret
+   *
+   * @example
+   * ```typescript
+   * const { secret } = await paceful.webhooks.rotateSecret('webhook_abc123');
+   *
+   * // Update your server with the new secret
+   * console.log('New secret:', secret);
+   * ```
+   */
+  async rotateSecret(webhookId) {
+    return this.http.post(`/api/v1/partner/webhooks/${webhookId}/rotate-secret`);
+  }
+  /**
+   * Verify a webhook signature
+   * Call this method to validate incoming webhook requests
+   *
+   * @param payload - Raw request body as string
+   * @param signature - Value of X-Paceful-Signature header
+   * @param secret - Your webhook secret
+   * @returns Whether the signature is valid
+   *
+   * @example
+   * ```typescript
+   * // In your webhook handler:
+   * const isValid = Webhooks.verifySignature(
+   *   rawBody,
+   *   request.headers['x-paceful-signature'],
+   *   process.env.PACEFUL_WEBHOOK_SECRET
+   * );
+   *
+   * if (!isValid) {
+   *   return res.status(401).send('Invalid signature');
+   * }
+   * ```
+   */
+  static verifySignature(payload, signature, secret) {
+    try {
+      const crypto = __require("crypto");
+      const expectedSignature = crypto.createHmac("sha256", secret).update(payload).digest("hex");
+      const sigBuffer = Buffer.from(signature);
+      const expectedBuffer = Buffer.from(expectedSignature);
+      if (sigBuffer.length !== expectedBuffer.length) {
+        return false;
+      }
+      return crypto.timingSafeEqual(sigBuffer, expectedBuffer);
+    } catch {
+      console.warn("Webhook signature verification requires Node.js crypto module");
+      return false;
+    }
+  }
+};
+
+// src/client.ts
+var PacefulClient = class {
+  /**
+   * Create a new Paceful client
+   *
+   * @param config - Configuration options
+   *
+   * @example
+   * ```typescript
+   * import { PacefulClient } from '@paceful/sdk';
+   *
+   * const paceful = new PacefulClient({
+   *   apiKey: process.env.PACEFUL_API_KEY,
+   * });
+   *
+   * // Register a user
+   * const user = await paceful.users.register({
+   *   externalId: 'user_123',
+   *   email: 'user@example.com'
+   * });
+   *
+   * // Log a mood entry
+   * await paceful.mood.log({
+   *   externalId: 'user_123',
+   *   mood: 4,
+   *   note: 'Feeling good today'
+   * });
+   *
+   * // Get ERS score
+   * const ers = await paceful.ers.get('user_123');
+   * console.log(`ERS: ${ers.ersScore}, Stage: ${ers.stage}`);
+   * ```
+   */
+  constructor(config) {
+    this.http = new HttpClient(config);
+    this.users = new Users(this.http);
+    this.mood = new Mood(this.http);
+    this.journal = new Journal(this.http);
+    this.ers = new ERS(this.http);
+    this.analytics = new Analytics(this.http);
+    this.webhooks = new Webhooks(this.http);
+  }
+  /**
+   * Check API connectivity and authentication
+   *
+   * @returns Health check result
+   *
+   * @example
+   * ```typescript
+   * const health = await paceful.healthCheck();
+   * if (health.ok) {
+   *   console.log('API is reachable');
+   * }
+   * ```
+   */
+  async healthCheck() {
+    return this.http.get("/api/v1/partner/health");
+  }
+};
+
+// src/widgets/index.ts
+init_PacefulProvider();
+
+// src/widgets/MoodWidget.tsx
+import { useState, useEffect } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var MOOD_OPTIONS = [
+  { value: 1, label: "Struggling", color: "#7E71B5", subtitle: "Having a hard time" },
+  { value: 2, label: "Low", color: "#5B7FB5", subtitle: "Feeling down" },
+  { value: 3, label: "Okay", color: "#C4973B", subtitle: "Getting by" },
+  { value: 4, label: "Good", color: "#5B8A72", subtitle: "Feeling positive" },
+  { value: 5, label: "Great", color: "#3D6B54", subtitle: "Thriving today" }
+];
+var EMOTION_TAGS = [
+  "anxious",
+  "sad",
+  "lonely",
+  "angry",
+  "numb",
+  "hopeful",
+  "grateful",
+  "calm",
+  "motivated",
+  "confused"
+];
+function MoodWidget({
+  apiKey: propApiKey,
+  userId: propUserId,
+  baseUrl: propBaseUrl,
+  theme = "light",
+  brandColor = "#5B8A72",
+  compact = false,
+  showStreak = false,
+  onComplete,
+  onError,
+  className
+}) {
+  let contextValue = null;
+  try {
+    const { usePaceful: usePaceful2 } = (init_PacefulProvider(), __toCommonJS(PacefulProvider_exports));
+    contextValue = usePaceful2();
+  } catch {
+  }
+  const apiKey = propApiKey || contextValue?.apiKey;
+  const userId = propUserId || contextValue?.userId;
+  const baseUrl = propBaseUrl || contextValue?.baseUrl || "https://paceful-app.vercel.app/api/v1/partner";
+  const [state, setState] = useState("INITIAL");
+  const [selectedMood, setSelectedMood] = useState(null);
+  const [selectedEmotions, setSelectedEmotions] = useState([]);
+  const [streak, setStreak] = useState(0);
+  const isDark = theme === "dark";
+  useEffect(() => {
+    if (showStreak && apiKey && userId && typeof window !== "undefined") {
+      fetch(`${baseUrl}/mood/${userId}/streak`, {
+        headers: { "X-API-Key": apiKey }
+      }).then((res) => res.json()).then((data) => {
+        if (data.success && data.data?.streak) {
+          setStreak(data.data.streak);
+        }
+      }).catch(() => {
+      });
+    }
+  }, [showStreak, apiKey, userId, baseUrl]);
+  const handleMoodSelect = (mood) => {
+    setSelectedMood(mood);
+    if (compact) {
+      handleSubmit(mood, []);
+    } else {
+      setState("EMOTIONS");
+    }
+  };
+  const toggleEmotion = (emotion) => {
+    setSelectedEmotions(
+      (prev) => prev.includes(emotion) ? prev.filter((e) => e !== emotion) : [...prev, emotion]
+    );
+  };
+  const handleSubmit = async (mood, emotions) => {
+    const moodToSubmit = mood ?? selectedMood;
+    const emotionsToSubmit = emotions ?? selectedEmotions;
+    if (!moodToSubmit || !apiKey || !userId) {
+      onError?.(new Error("Missing required data"));
+      return;
+    }
+    setState("SUBMITTING");
+    try {
+      const moodOption = MOOD_OPTIONS.find((m) => m.value === moodToSubmit);
+      const response = await fetch(`${baseUrl}/mood/log`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": apiKey
+        },
+        body: JSON.stringify({
+          externalId: userId,
+          score: moodToSubmit,
+          label: moodOption?.label,
+          emotions: emotionsToSubmit
+        })
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        throw new Error(data.error?.message || "Failed to log mood");
+      }
+      setState("COMPLETE");
+      onComplete?.({
+        logged: true,
+        moodId: data.data?.id || "",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      setTimeout(() => {
+        setState("INITIAL");
+        setSelectedMood(null);
+        setSelectedEmotions([]);
+        if (showStreak) setStreak((s) => s + 1);
+      }, 2e3);
+    } catch (error) {
+      setState("INITIAL");
+      onError?.(error instanceof Error ? error : new Error("Unknown error"));
+    }
+  };
+  const styles = {
+    container: {
+      backgroundColor: isDark ? "#1F1D1A" : "#FFFFFF",
+      borderRadius: 12,
+      padding: 20,
+      fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+      color: isDark ? "#FFFFFF" : "#1F1D1A"
+    },
+    title: {
+      fontSize: 18,
+      fontWeight: 600,
+      marginBottom: 16,
+      textAlign: "center"
+    },
+    moodList: {
+      display: "flex",
+      flexDirection: "column",
+      gap: 8
+    },
+    moodCard: (isSelected) => ({
+      display: "flex",
+      alignItems: "center",
+      gap: 12,
+      border: `1px solid ${isSelected ? brandColor : isDark ? "#3D3D3A" : "#E5E0D9"}`,
+      borderRadius: 8,
+      padding: 12,
+      cursor: "pointer",
+      backgroundColor: isSelected ? isDark ? "#2D2D2A" : "#F9F6F2" : "transparent",
+      transition: "all 0.15s ease"
+    }),
+    moodDot: (color) => ({
+      width: 12,
+      height: 12,
+      borderRadius: "50%",
+      backgroundColor: color,
+      flexShrink: 0
+    }),
+    moodLabel: {
+      fontWeight: 500,
+      fontSize: 15
+    },
+    moodSubtitle: {
+      fontSize: 13,
+      color: isDark ? "#9A938A" : "#6B6560",
+      marginLeft: "auto"
+    },
+    emotionsSection: {
+      marginTop: 20
+    },
+    emotionsTitle: {
+      fontSize: 14,
+      color: isDark ? "#9A938A" : "#6B6560",
+      marginBottom: 12
+    },
+    emotionTags: {
+      display: "flex",
+      flexWrap: "wrap",
+      gap: 8
+    },
+    emotionTag: (isSelected) => ({
+      border: `1px solid ${isSelected ? brandColor : isDark ? "#3D3D3A" : "#E5E0D9"}`,
+      borderRadius: 20,
+      padding: "6px 12px",
+      fontSize: 13,
+      cursor: "pointer",
+      backgroundColor: isSelected ? brandColor : "transparent",
+      color: isSelected ? "#FFFFFF" : isDark ? "#FFFFFF" : "#1F1D1A",
+      transition: "all 0.15s ease"
+    }),
+    submitButton: {
+      marginTop: 20,
+      width: "100%",
+      backgroundColor: brandColor,
+      color: "#FFFFFF",
+      border: "none",
+      borderRadius: 8,
+      padding: 12,
+      fontSize: 15,
+      fontWeight: 500,
+      cursor: "pointer"
+    },
+    footer: {
+      marginTop: 16,
+      textAlign: "center",
+      fontSize: 11,
+      color: "#9A938A"
+    },
+    spinner: {
+      display: "flex",
+      justifyContent: "center",
+      alignItems: "center",
+      padding: 40
+    },
+    checkmark: {
+      display: "flex",
+      flexDirection: "column",
+      alignItems: "center",
+      padding: 40,
+      gap: 12
+    },
+    streakBadge: {
+      display: "inline-flex",
+      alignItems: "center",
+      gap: 4,
+      backgroundColor: isDark ? "#2D2D2A" : "#F9F6F2",
+      borderRadius: 12,
+      padding: "4px 10px",
+      fontSize: 12,
+      color: brandColor,
+      marginBottom: 16
+    }
+  };
+  if (state === "SUBMITTING") {
+    return /* @__PURE__ */ jsxs("div", { style: styles.container, className, children: [
+      /* @__PURE__ */ jsx("div", { style: styles.spinner, children: /* @__PURE__ */ jsx("svg", { width: "32", height: "32", viewBox: "0 0 32 32", children: /* @__PURE__ */ jsx(
+        "circle",
+        {
+          cx: "16",
+          cy: "16",
+          r: "12",
+          stroke: brandColor,
+          strokeWidth: "3",
+          fill: "none",
+          strokeDasharray: "60",
+          strokeLinecap: "round",
+          children: /* @__PURE__ */ jsx(
+            "animateTransform",
+            {
+              attributeName: "transform",
+              type: "rotate",
+              from: "0 16 16",
+              to: "360 16 16",
+              dur: "1s",
+              repeatCount: "indefinite"
+            }
+          )
+        }
+      ) }) }),
+      /* @__PURE__ */ jsx("div", { style: styles.footer, children: "Powered by Paceful" })
+    ] });
+  }
+  if (state === "COMPLETE") {
+    return /* @__PURE__ */ jsxs("div", { style: styles.container, className, children: [
+      /* @__PURE__ */ jsxs("div", { style: styles.checkmark, children: [
+        /* @__PURE__ */ jsxs("svg", { width: "48", height: "48", viewBox: "0 0 48 48", children: [
+          /* @__PURE__ */ jsx("circle", { cx: "24", cy: "24", r: "22", fill: brandColor }),
+          /* @__PURE__ */ jsx(
+            "path",
+            {
+              d: "M14 24 L21 31 L34 18",
+              stroke: "#FFFFFF",
+              strokeWidth: "3",
+              fill: "none",
+              strokeLinecap: "round",
+              strokeLinejoin: "round"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx("span", { style: { fontSize: 18, fontWeight: 500 }, children: "Logged!" })
+      ] }),
+      /* @__PURE__ */ jsx("div", { style: styles.footer, children: "Powered by Paceful" })
+    ] });
+  }
+  if (state === "EMOTIONS") {
+    const selectedMoodOption = MOOD_OPTIONS.find((m) => m.value === selectedMood);
+    return /* @__PURE__ */ jsxs("div", { style: styles.container, className, children: [
+      /* @__PURE__ */ jsxs("div", { style: styles.title, children: [
+        /* @__PURE__ */ jsx("span", { style: { color: selectedMoodOption?.color }, children: selectedMoodOption?.label }),
+        " ",
+        "\u2014 What emotions are present?"
+      ] }),
+      /* @__PURE__ */ jsx("div", { style: styles.emotionTags, children: EMOTION_TAGS.map((emotion) => /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: () => toggleEmotion(emotion),
+          style: styles.emotionTag(selectedEmotions.includes(emotion)),
+          children: emotion
+        },
+        emotion
+      )) }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: () => handleSubmit(),
+          style: styles.submitButton,
+          children: "Log Mood"
+        }
+      ),
+      /* @__PURE__ */ jsx("div", { style: styles.footer, children: "Powered by Paceful" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { style: styles.container, className, children: [
+    showStreak && streak > 0 && /* @__PURE__ */ jsx("div", { style: { textAlign: "center" }, children: /* @__PURE__ */ jsxs("span", { style: styles.streakBadge, children: [
+      "\u{1F525} ",
+      streak,
+      " day streak"
+    ] }) }),
+    /* @__PURE__ */ jsx("div", { style: styles.title, children: "How are you feeling?" }),
+    /* @__PURE__ */ jsx("div", { style: styles.moodList, children: MOOD_OPTIONS.map((mood) => /* @__PURE__ */ jsxs(
+      "div",
+      {
+        onClick: () => handleMoodSelect(mood.value),
+        style: styles.moodCard(selectedMood === mood.value),
+        children: [
+          /* @__PURE__ */ jsx("div", { style: styles.moodDot(mood.color) }),
+          /* @__PURE__ */ jsx("span", { style: styles.moodLabel, children: mood.label }),
+          /* @__PURE__ */ jsx("span", { style: styles.moodSubtitle, children: mood.subtitle })
+        ]
+      },
+      mood.value
+    )) }),
+    /* @__PURE__ */ jsx("div", { style: styles.footer, children: "Powered by Paceful" })
+  ] });
+}
+
+// src/widgets/JournalWidget.tsx
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var JOURNAL_PROMPTS = [
+  "What would you tell yourself from a year ago?",
+  "What's one thing you're grateful for right now?",
+  "What emotion keeps coming back today?",
+  "What did you learn about yourself this week?",
+  "If your future self could see you now, what would they say?"
+];
+var SENTIMENT_COLORS = {
+  Hopeful: "#5B8A72",
+  Reflective: "#5B7FB5",
+  Processing: "#C4973B",
+  Struggling: "#B56B6B"
+};
+function JournalWidget({
+  apiKey: propApiKey,
+  userId: propUserId,
+  baseUrl: propBaseUrl,
+  theme = "light",
+  brandColor = "#5B8A72",
+  showPrompt = true,
+  showAIReflection = true,
+  maxLength = 2e3,
+  placeholder = "What's on your mind?",
+  onComplete,
+  onError,
+  className
+}) {
+  let contextValue = null;
+  try {
+    const { usePaceful: usePaceful2 } = (init_PacefulProvider(), __toCommonJS(PacefulProvider_exports));
+    contextValue = usePaceful2();
+  } catch {
+  }
+  const apiKey = propApiKey || contextValue?.apiKey;
+  const userId = propUserId || contextValue?.userId;
+  const baseUrl = propBaseUrl || contextValue?.baseUrl || "https://paceful-app.vercel.app/api/v1/partner";
+  const [state, setState] = useState2("WRITING");
+  const [content, setContent] = useState2("");
+  const [prompt, setPrompt] = useState2("");
+  const [result, setResult] = useState2(null);
+  const [fadeIn, setFadeIn] = useState2(false);
+  const isDark = theme === "dark";
+  useEffect2(() => {
+    if (showPrompt && typeof window !== "undefined") {
+      const randomIndex = Math.floor(Math.random() * JOURNAL_PROMPTS.length);
+      setPrompt(JOURNAL_PROMPTS[randomIndex]);
+    }
+  }, [showPrompt]);
+  const wordCount = content.trim().split(/\s+/).filter(Boolean).length;
+  const handleSubmit = async () => {
+    if (!content.trim() || !apiKey || !userId) {
+      onError?.(new Error("Missing required data"));
+      return;
+    }
+    setState("SUBMITTING");
+    try {
+      const response = await fetch(`${baseUrl}/journal/entry`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": apiKey
+        },
+        body: JSON.stringify({
+          externalId: userId,
+          content: content.trim()
+        })
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        throw new Error(data.error?.message || "Failed to save journal entry");
+      }
+      const entryResult = {
+        entryId: data.data?.id || "",
+        sentiment: data.data?.sentiment || "Reflective",
+        aiReflection: data.data?.aiReflection || "Thank you for sharing. Taking time to reflect is an important step in understanding yourself better."
+      };
+      setResult(entryResult);
+      setState("COMPLETE");
+      onComplete?.(entryResult);
+      setTimeout(() => setFadeIn(true), 50);
+    } catch (error) {
+      setState("WRITING");
+      onError?.(error instanceof Error ? error : new Error("Unknown error"));
+    }
+  };
+  const handleWriteAnother = () => {
+    setState("WRITING");
+    setContent("");
+    setResult(null);
+    setFadeIn(false);
+    if (showPrompt) {
+      const randomIndex = Math.floor(Math.random() * JOURNAL_PROMPTS.length);
+      setPrompt(JOURNAL_PROMPTS[randomIndex]);
+    }
+  };
+  const styles = {
+    container: {
+      backgroundColor: isDark ? "#1F1D1A" : "#FFFFFF",
+      borderRadius: 12,
+      padding: 20,
+      fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+      color: isDark ? "#FFFFFF" : "#1F1D1A"
+    },
+    prompt: {
+      fontSize: 16,
+      fontWeight: 500,
+      marginBottom: 16,
+      color: isDark ? "#E5E0D9" : "#3D3D3A",
+      lineHeight: 1.4
+    },
+    textareaWrapper: {
+      position: "relative"
+    },
+    textarea: {
+      width: "100%",
+      minHeight: 120,
+      resize: "vertical",
+      border: `1px solid ${isDark ? "#3D3D3A" : "#E5E0D9"}`,
+      borderRadius: 8,
+      padding: 12,
+      fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+      fontSize: 15,
+      lineHeight: 1.5,
+      backgroundColor: isDark ? "#2D2D2A" : "#FFFFFF",
+      color: isDark ? "#FFFFFF" : "#1F1D1A",
+      outline: "none",
+      boxSizing: "border-box"
+    },
+    wordCount: {
+      position: "absolute",
+      bottom: 8,
+      right: 12,
+      fontSize: 12,
+      color: "#9A938A"
+    },
+    submitButton: {
+      marginTop: 16,
+      width: "100%",
+      backgroundColor: brandColor,
+      color: "#FFFFFF",
+      border: "none",
+      borderRadius: 8,
+      padding: 12,
+      fontSize: 15,
+      fontWeight: 500,
+      cursor: content.trim() ? "pointer" : "not-allowed",
+      opacity: content.trim() ? 1 : 0.5
+    },
+    footer: {
+      marginTop: 16,
+      textAlign: "center",
+      fontSize: 11,
+      color: "#9A938A"
+    },
+    submittingText: {
+      textAlign: "center",
+      padding: 40,
+      fontSize: 15,
+      color: isDark ? "#9A938A" : "#6B6560"
+    },
+    reflectionContainer: {
+      opacity: fadeIn ? 1 : 0,
+      transition: "opacity 0.3s ease"
+    },
+    sentimentBadge: (sentiment) => ({
+      display: "inline-block",
+      padding: "4px 10px",
+      borderRadius: 12,
+      fontSize: 12,
+      fontWeight: 500,
+      backgroundColor: SENTIMENT_COLORS[sentiment] || SENTIMENT_COLORS.Reflective,
+      color: "#FFFFFF",
+      marginBottom: 12
+    }),
+    reflectionBox: {
+      borderLeft: `3px solid ${brandColor}`,
+      padding: 16,
+      backgroundColor: isDark ? "#2D2D2A" : "#F9F6F2",
+      borderRadius: "0 8px 8px 0"
+    },
+    reflectionText: {
+      fontStyle: "italic",
+      lineHeight: 1.6,
+      fontSize: 15,
+      color: isDark ? "#E5E0D9" : "#3D3D3A"
+    },
+    writeAnotherButton: {
+      marginTop: 20,
+      width: "100%",
+      backgroundColor: "transparent",
+      color: brandColor,
+      border: `1px solid ${brandColor}`,
+      borderRadius: 8,
+      padding: 12,
+      fontSize: 15,
+      fontWeight: 500,
+      cursor: "pointer"
+    }
+  };
+  if (state === "SUBMITTING") {
+    return /* @__PURE__ */ jsxs2("div", { style: styles.container, className, children: [
+      /* @__PURE__ */ jsxs2("div", { style: styles.submittingText, children: [
+        /* @__PURE__ */ jsx2(
+          "svg",
+          {
+            width: "32",
+            height: "32",
+            viewBox: "0 0 32 32",
+            style: { display: "block", margin: "0 auto 16px" },
+            children: /* @__PURE__ */ jsx2(
+              "circle",
+              {
+                cx: "16",
+                cy: "16",
+                r: "12",
+                stroke: brandColor,
+                strokeWidth: "3",
+                fill: "none",
+                strokeDasharray: "60",
+                strokeLinecap: "round",
+                children: /* @__PURE__ */ jsx2(
+                  "animateTransform",
+                  {
+                    attributeName: "transform",
+                    type: "rotate",
+                    from: "0 16 16",
+                    to: "360 16 16",
+                    dur: "1s",
+                    repeatCount: "indefinite"
+                  }
+                )
+              }
+            )
+          }
+        ),
+        "Reflecting..."
+      ] }),
+      /* @__PURE__ */ jsx2("div", { style: styles.footer, children: "Powered by Paceful" })
+    ] });
+  }
+  if (state === "COMPLETE" && result) {
+    return /* @__PURE__ */ jsxs2("div", { style: styles.container, className, children: [
+      /* @__PURE__ */ jsxs2("div", { style: styles.reflectionContainer, children: [
+        showAIReflection && /* @__PURE__ */ jsxs2(Fragment, { children: [
+          /* @__PURE__ */ jsx2("span", { style: styles.sentimentBadge(result.sentiment), children: result.sentiment }),
+          /* @__PURE__ */ jsx2("div", { style: styles.reflectionBox, children: /* @__PURE__ */ jsx2("p", { style: styles.reflectionText, children: result.aiReflection }) })
+        ] }),
+        !showAIReflection && /* @__PURE__ */ jsxs2("div", { style: { textAlign: "center", padding: 20 }, children: [
+          /* @__PURE__ */ jsxs2("svg", { width: "48", height: "48", viewBox: "0 0 48 48", children: [
+            /* @__PURE__ */ jsx2("circle", { cx: "24", cy: "24", r: "22", fill: brandColor }),
+            /* @__PURE__ */ jsx2(
+              "path",
+              {
+                d: "M14 24 L21 31 L34 18",
+                stroke: "#FFFFFF",
+                strokeWidth: "3",
+                fill: "none",
+                strokeLinecap: "round",
+                strokeLinejoin: "round"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx2("p", { style: { marginTop: 12, fontWeight: 500 }, children: "Entry Saved" })
+        ] }),
+        /* @__PURE__ */ jsx2("button", { onClick: handleWriteAnother, style: styles.writeAnotherButton, children: "Write Another" })
+      ] }),
+      /* @__PURE__ */ jsx2("div", { style: styles.footer, children: "Powered by Paceful" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2("div", { style: styles.container, className, children: [
+    showPrompt && prompt && /* @__PURE__ */ jsx2("div", { style: styles.prompt, children: prompt }),
+    /* @__PURE__ */ jsxs2("div", { style: styles.textareaWrapper, children: [
+      /* @__PURE__ */ jsx2(
+        "textarea",
+        {
+          value: content,
+          onChange: (e) => setContent(e.target.value.slice(0, maxLength)),
+          placeholder,
+          style: styles.textarea
+        }
+      ),
+      /* @__PURE__ */ jsxs2("span", { style: styles.wordCount, children: [
+        wordCount,
+        " words"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx2(
+      "button",
+      {
+        onClick: handleSubmit,
+        disabled: !content.trim(),
+        style: styles.submitButton,
+        children: "Save Entry"
+      }
+    ),
+    /* @__PURE__ */ jsx2("div", { style: styles.footer, children: "Powered by Paceful" })
+  ] });
+}
+
+// src/widgets/ERSDisplay.tsx
+import { useState as useState3, useEffect as useEffect3 } from "react";
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var STAGE_COLORS = {
+  healing: "#7E71B5",
+  rebuilding: "#5B8A72",
+  ready: "#D4A645"
+};
+var DIMENSION_LABELS = [
+  { key: "emotionalStability", label: "Emotional Stability" },
+  { key: "selfAwareness", label: "Self Reflection" },
+  { key: "socialConnection", label: "Engagement" },
+  { key: "purposeClarity", label: "Coping Capacity" },
+  { key: "resilienceGrowth", label: "Social Readiness" }
+];
+function ERSDisplay({
+  apiKey: propApiKey,
+  userId: propUserId,
+  baseUrl: propBaseUrl,
+  theme = "light",
+  brandColor = "#5B8A72",
+  showDimensions = true,
+  showTrend = true,
+  compact = false,
+  onLoad,
+  onError,
+  className
+}) {
+  let contextValue = null;
+  try {
+    const { usePaceful: usePaceful2 } = (init_PacefulProvider(), __toCommonJS(PacefulProvider_exports));
+    contextValue = usePaceful2();
+  } catch {
+  }
+  const apiKey = propApiKey || contextValue?.apiKey;
+  const userId = propUserId || contextValue?.userId;
+  const baseUrl = propBaseUrl || contextValue?.baseUrl || "https://paceful-app.vercel.app/api/v1/partner";
+  const [state, setState] = useState3("LOADING");
+  const [ersData, setErsData] = useState3(null);
+  const isDark = theme === "dark";
+  const ringSize = compact ? 80 : 120;
+  const strokeWidth = compact ? 6 : 8;
+  const radius = (ringSize - strokeWidth) / 2;
+  const circumference = 2 * Math.PI * radius;
+  const fetchERS = async () => {
+    if (!apiKey || !userId) {
+      setState("ERROR");
+      onError?.(new Error("Missing apiKey or userId"));
+      return;
+    }
+    setState("LOADING");
+    try {
+      const response = await fetch(`${baseUrl}/ers/${userId}`, {
+        headers: { "X-API-Key": apiKey }
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        throw new Error(data.error?.message || "Failed to fetch ERS");
+      }
+      const ersResult = {
+        ersScore: data.data?.ersScore || 0,
+        stage: data.data?.stage || "healing",
+        dimensions: data.data?.dimensions || {
+          emotionalStability: 0,
+          selfAwareness: 0,
+          socialConnection: 0,
+          purposeClarity: 0,
+          resilienceGrowth: 0
+        },
+        trend: data.data?.trend
+      };
+      setErsData(ersResult);
+      setState("LOADED");
+      onLoad?.(ersResult);
+    } catch (error) {
+      setState("ERROR");
+      onError?.(error instanceof Error ? error : new Error("Unknown error"));
+    }
+  };
+  useEffect3(() => {
+    if (typeof window !== "undefined") {
+      fetchERS();
+    }
+  }, [apiKey, userId, baseUrl]);
+  const styles = {
+    container: {
+      backgroundColor: isDark ? "#1F1D1A" : "#FFFFFF",
+      borderRadius: 12,
+      padding: compact ? 16 : 20,
+      fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+      color: isDark ? "#FFFFFF" : "#1F1D1A"
+    },
+    ringContainer: {
+      display: "flex",
+      justifyContent: "center",
+      marginBottom: compact ? 12 : 20
+    },
+    ringWrapper: {
+      position: "relative",
+      width: ringSize,
+      height: ringSize
+    },
+    scoreText: {
+      position: "absolute",
+      top: "50%",
+      left: "50%",
+      transform: "translate(-50%, -50%)",
+      textAlign: "center"
+    },
+    scoreNumber: {
+      fontSize: compact ? 24 : 36,
+      fontWeight: 700,
+      lineHeight: 1
+    },
+    stageLabel: {
+      fontSize: 12,
+      textTransform: "uppercase",
+      letterSpacing: 0.5,
+      marginTop: 4,
+      color: isDark ? "#9A938A" : "#6B6560"
+    },
+    trendBadge: (direction) => ({
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      gap: 4,
+      fontSize: 13,
+      color: direction === "up" ? "#5B8A72" : direction === "down" ? "#B56B6B" : "#9A938A",
+      marginBottom: 16
+    }),
+    dimensionsContainer: {
+      display: "flex",
+      flexDirection: "column",
+      gap: 12
+    },
+    dimensionRow: {
+      display: "flex",
+      alignItems: "center",
+      gap: 12
+    },
+    dimensionLabel: {
+      fontSize: 13,
+      color: isDark ? "#9A938A" : "#6B6560",
+      width: 120,
+      flexShrink: 0
+    },
+    dimensionBarBg: {
+      flex: 1,
+      height: 8,
+      backgroundColor: isDark ? "#3D3D3A" : "#E5E0D9",
+      borderRadius: 4,
+      overflow: "hidden"
+    },
+    dimensionBarFill: (value) => ({
+      height: "100%",
+      width: `${value}%`,
+      backgroundColor: brandColor,
+      borderRadius: 4,
+      transition: "width 0.5s ease"
+    }),
+    dimensionScore: {
+      fontSize: 13,
+      fontWeight: 500,
+      width: 32,
+      textAlign: "right"
+    },
+    focusBadge: {
+      fontSize: 10,
+      backgroundColor: "#F5E6E6",
+      color: "#B56B6B",
+      padding: "2px 6px",
+      borderRadius: 4,
+      marginLeft: 8
+    },
+    footer: {
+      marginTop: 16,
+      textAlign: "center",
+      fontSize: 11,
+      color: "#9A938A"
+    },
+    skeleton: {
+      animation: "pulse 1.5s ease-in-out infinite",
+      backgroundColor: isDark ? "#3D3D3A" : "#E5E0D9",
+      borderRadius: 8
+    },
+    errorContainer: {
+      textAlign: "center",
+      padding: 20
+    },
+    errorText: {
+      fontSize: 14,
+      color: isDark ? "#9A938A" : "#6B6560",
+      marginBottom: 12
+    },
+    retryButton: {
+      backgroundColor: "transparent",
+      color: brandColor,
+      border: `1px solid ${brandColor}`,
+      borderRadius: 8,
+      padding: "8px 16px",
+      fontSize: 14,
+      cursor: "pointer"
+    }
+  };
+  if (state === "LOADING") {
+    return /* @__PURE__ */ jsxs3("div", { style: styles.container, className, children: [
+      /* @__PURE__ */ jsx3("style", { children: `@keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.5; } }` }),
+      /* @__PURE__ */ jsx3("div", { style: styles.ringContainer, children: /* @__PURE__ */ jsx3(
+        "div",
+        {
+          style: {
+            ...styles.skeleton,
+            width: ringSize,
+            height: ringSize,
+            borderRadius: "50%"
+          }
+        }
+      ) }),
+      showTrend && /* @__PURE__ */ jsx3("div", { style: { display: "flex", justifyContent: "center", marginBottom: 16 }, children: /* @__PURE__ */ jsx3("div", { style: { ...styles.skeleton, width: 120, height: 20 } }) }),
+      showDimensions && !compact && /* @__PURE__ */ jsx3("div", { style: styles.dimensionsContainer, children: [...Array(5)].map((_, i) => /* @__PURE__ */ jsxs3("div", { style: styles.dimensionRow, children: [
+        /* @__PURE__ */ jsx3("div", { style: { ...styles.skeleton, width: 100, height: 16 } }),
+        /* @__PURE__ */ jsx3("div", { style: { ...styles.skeleton, flex: 1, height: 8 } })
+      ] }, i)) }),
+      /* @__PURE__ */ jsx3("div", { style: styles.footer, children: "Powered by Paceful" })
+    ] });
+  }
+  if (state === "ERROR") {
+    return /* @__PURE__ */ jsxs3("div", { style: styles.container, className, children: [
+      /* @__PURE__ */ jsxs3("div", { style: styles.errorContainer, children: [
+        /* @__PURE__ */ jsx3("p", { style: styles.errorText, children: "Unable to load score" }),
+        /* @__PURE__ */ jsx3("button", { onClick: fetchERS, style: styles.retryButton, children: "Retry" })
+      ] }),
+      /* @__PURE__ */ jsx3("div", { style: styles.footer, children: "Powered by Paceful" })
+    ] });
+  }
+  if (!ersData) return null;
+  const progress = ersData.ersScore / 100 * circumference;
+  const stageColor = STAGE_COLORS[ersData.stage];
+  return /* @__PURE__ */ jsxs3("div", { style: styles.container, className, children: [
+    /* @__PURE__ */ jsx3("div", { style: styles.ringContainer, children: /* @__PURE__ */ jsxs3("div", { style: styles.ringWrapper, children: [
+      /* @__PURE__ */ jsxs3("svg", { width: ringSize, height: ringSize, children: [
+        /* @__PURE__ */ jsx3(
+          "circle",
+          {
+            cx: ringSize / 2,
+            cy: ringSize / 2,
+            r: radius,
+            stroke: isDark ? "#3D3D3A" : "#E5E0D9",
+            strokeWidth,
+            fill: "none"
+          }
+        ),
+        /* @__PURE__ */ jsx3(
+          "circle",
+          {
+            cx: ringSize / 2,
+            cy: ringSize / 2,
+            r: radius,
+            stroke: stageColor,
+            strokeWidth,
+            fill: "none",
+            strokeLinecap: "round",
+            strokeDasharray: circumference,
+            strokeDashoffset: circumference - progress,
+            transform: `rotate(-90 ${ringSize / 2} ${ringSize / 2})`,
+            style: { transition: "stroke-dashoffset 0.5s ease" }
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs3("div", { style: styles.scoreText, children: [
+        /* @__PURE__ */ jsx3("div", { style: styles.scoreNumber, children: Math.round(ersData.ersScore) }),
+        /* @__PURE__ */ jsx3("div", { style: styles.stageLabel, children: ersData.stage })
+      ] })
+    ] }) }),
+    showTrend && ersData.trend && /* @__PURE__ */ jsxs3("div", { style: styles.trendBadge(ersData.trend.direction), children: [
+      ersData.trend.direction === "up" && /* @__PURE__ */ jsxs3(Fragment2, { children: [
+        /* @__PURE__ */ jsx3("svg", { width: "12", height: "12", viewBox: "0 0 12 12", children: /* @__PURE__ */ jsx3("path", { d: "M6 2 L10 6 L7 6 L7 10 L5 10 L5 6 L2 6 Z", fill: "currentColor" }) }),
+        "+",
+        ersData.trend.weeklyChange.toFixed(1),
+        " from last week"
+      ] }),
+      ersData.trend.direction === "down" && /* @__PURE__ */ jsxs3(Fragment2, { children: [
+        /* @__PURE__ */ jsx3("svg", { width: "12", height: "12", viewBox: "0 0 12 12", children: /* @__PURE__ */ jsx3("path", { d: "M6 10 L10 6 L7 6 L7 2 L5 2 L5 6 L2 6 Z", fill: "currentColor" }) }),
+        ersData.trend.weeklyChange.toFixed(1),
+        " from last week"
+      ] }),
+      ersData.trend.direction === "stable" && /* @__PURE__ */ jsxs3(Fragment2, { children: [
+        /* @__PURE__ */ jsx3("span", { style: { fontSize: 16 }, children: "\u2014" }),
+        "No change"
+      ] })
+    ] }),
+    showDimensions && !compact && /* @__PURE__ */ jsx3("div", { style: styles.dimensionsContainer, children: DIMENSION_LABELS.map(({ key, label }) => {
+      const value = ersData.dimensions[key] || 0;
+      return /* @__PURE__ */ jsxs3("div", { style: styles.dimensionRow, children: [
+        /* @__PURE__ */ jsx3("span", { style: styles.dimensionLabel, children: label }),
+        /* @__PURE__ */ jsx3("div", { style: styles.dimensionBarBg, children: /* @__PURE__ */ jsx3("div", { style: styles.dimensionBarFill(value) }) }),
+        /* @__PURE__ */ jsx3("span", { style: styles.dimensionScore, children: Math.round(value) }),
+        value < 50 && /* @__PURE__ */ jsx3("span", { style: styles.focusBadge, children: "Focus" })
+      ] }, key);
+    }) }),
+    /* @__PURE__ */ jsx3("div", { style: styles.footer, children: "Powered by Paceful" })
+  ] });
+}
+export {
+  Analytics,
+  ERS,
+  ERSDisplay,
+  Journal,
+  JournalWidget,
+  Mood,
+  MoodWidget,
+  PacefulAuthError,
+  PacefulClient,
+  PacefulError,
+  PacefulNetworkError,
+  PacefulNotFoundError,
+  PacefulProvider,
+  PacefulRateLimitError,
+  PacefulValidationError,
+  Users,
+  Webhooks,
+  PacefulClient as default,
+  usePaceful
+};