@cstar.help/js 0.11.0 → 0.12.1

package/dist/chat/index.js

@@ -98,6 +98,14 @@ var RealtimeManager = class {
   getClient() {
     return this.client;
   }
+  /**
+   * The current Supabase JWT (set by init/refresh). Returned so callers can
+   * decode the `sub` claim to learn the customerId — required after a
+   * session-mode login where the SDK doesn't have customerId at hand.
+   */
+  getCurrentToken() {
+    return this.currentToken;
+  }
   /** Whether the realtime manager is initialized and has a token. */
   get isReady() {
     return this.client !== null && this.currentToken !== null;
@@ -239,6 +247,43 @@ var PresenceManager = class {
   }
 };
 
+// src/chat/errors.ts
+var ChatClientError = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "ChatClientError";
+    this.code = opts.code ?? "UNKNOWN";
+    this.statusCode = opts.statusCode;
+    this.requestId = opts.requestId ?? null;
+  }
+};
+var ChatClientAuthError = class extends ChatClientError {
+  constructor(opts) {
+    super(opts.message, opts);
+    this.name = "ChatClientAuthError";
+  }
+};
+var ChatClientRateLimitError = class extends ChatClientError {
+  constructor(opts) {
+    super(opts.message, opts);
+    this.name = "ChatClientRateLimitError";
+    this.retryAfter = opts.retryAfter ?? null;
+  }
+};
+var ChatClientServerError = class extends ChatClientError {
+  constructor(opts) {
+    super(opts.message, opts);
+    this.name = "ChatClientServerError";
+  }
+};
+var ChatClientNetworkError = class extends ChatClientError {
+  constructor(opts) {
+    super(opts.message, { code: "NETWORK_ERROR", statusCode: 0, requestId: null });
+    this.name = "ChatClientNetworkError";
+    this.originalError = opts.originalError;
+  }
+};
+
 // src/chat/index.ts
 var DEFAULT_BASE_URL = "https://www.cstar.help";
 var DEFAULT_POLLING_INTERVAL = 3e3;
@@ -247,6 +292,7 @@ var ChatClient = class {
     this.sessionToken = null;
     this.teamId = null;
     this.customerId = null;
+    this.authMode = null;
     this.pollingTimers = /* @__PURE__ */ new Map();
     this.realtimeManager = null;
     this.presenceManager = null;
@@ -295,6 +341,70 @@ var ChatClient = class {
     }
     return response.data;
   }
+  /**
+   * Sign in with cStar's hosted password auth. The SDK keeps the resulting
+   * Supabase access token and uses it as Bearer for every subsequent call.
+   * Real-time bootstraps automatically (same flow as `identify()`).
+   *
+   * Use this when your customers don't have a session in your app and you
+   * want cStar to handle login. For the case where your app already has a
+   * Supabase session, use `loginWithSession({ accessToken })` instead.
+   */
+  async loginWithCredentials(params) {
+    const teamId = await this.resolveTeamIdFromSlug();
+    const response = await this.fetch("/api/widget/auth/login", {
+      method: "POST",
+      body: { email: params.email, password: params.password, teamId }
+    });
+    if (!response.accessToken) {
+      throw new ChatClientAuthError({
+        message: "Login succeeded but no session was issued",
+        code: "NO_SESSION",
+        statusCode: 200,
+        requestId: null
+      });
+    }
+    await this.loginWithSession({
+      accessToken: response.accessToken,
+      teamId,
+      customerName: response.customer.name ?? response.customer.email
+    });
+    return {
+      customer: {
+        id: this.customerId ?? response.customer.id,
+        email: response.customer.email,
+        name: response.customer.name
+      },
+      teamId
+    };
+  }
+  /**
+   * Use an existing Supabase access token for widget calls. Skip the cStar
+   * login flow entirely; the SDK uses the supplied token as Bearer and
+   * bootstraps real-time the same way `identify()` does.
+   *
+   * The widget API verifies the token via the `widget-session` strategy on
+   * every request — there is no client-side validation here.
+   */
+  async loginWithSession(params) {
+    this.sessionToken = params.accessToken;
+    if (params.teamId) {
+      this.teamId = params.teamId;
+    }
+    this.authMode = "session";
+    if (this.realtimeEnabled) {
+      const customerName = params.customerName ?? "";
+      this.realtimeInitPromise = this.initRealtimeFromSession(customerName);
+    }
+  }
+  /**
+   * Returns the auth mode the client is currently using, or `null` before
+   * any authenticated call has resolved one. Useful for branching UI
+   * (e.g. to show a "Sign out" button only in session mode).
+   */
+  getAuthMode() {
+    return this.authMode;
+  }
   /**
    * Subscribe to new messages on a ticket.
    * Uses real-time delivery when available, falls back to polling.
@@ -348,8 +458,20 @@ var ChatClient = class {
     this.sessionToken = null;
     this.teamId = null;
     this.customerId = null;
+    this.authMode = null;
   }
-  /** @internal Make an authenticated request to the widget API. */
+  /**
+   * @internal Make an authenticated request to the widget API.
+   *
+   * On any non-2xx response, throws a typed subclass of `ChatClientError`
+   * (`ChatClientAuthError`, `ChatClientRateLimitError`, etc.) so consumers
+   * can branch on error class instead of parsing message strings.
+   *
+   * On the way out, reads the `X-Cstar-Auth-Mode` response header (set by
+   * widgetHandler on every response) and caches it on the client. After
+   * the first authenticated round-trip, `getAuthMode()` returns the
+   * server-confirmed mode.
+   */
   async fetch(path, options) {
     const url = this.buildUrl(path, options.query);
     const headers = {
@@ -358,17 +480,104 @@ var ChatClient = class {
     if (this.sessionToken) {
       headers["Authorization"] = `Bearer ${this.sessionToken}`;
     }
-    const response = await globalThis.fetch(url, {
-      method: options.method,
-      headers,
-      body: options.body ? JSON.stringify(options.body) : void 0
-    });
+    let response;
+    try {
+      response = await globalThis.fetch(url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : void 0
+      });
+    } catch (networkErr) {
+      throw new ChatClientNetworkError({
+        message: networkErr instanceof Error ? networkErr.message : "Network request failed",
+        originalError: networkErr
+      });
+    }
+    const responseHeaders = response.headers && typeof response.headers.get === "function" ? response.headers : null;
+    const headerMode = responseHeaders?.get("X-Cstar-Auth-Mode") ?? null;
+    if (headerMode === "hmac" || headerMode === "session") {
+      this.authMode = headerMode;
+    }
+    const requestId = responseHeaders?.get("X-Request-Id") ?? null;
     if (!response.ok) {
-      const errorBody = await response.json().catch(() => ({ error: { message: "Request failed" } }));
-      throw new Error(errorBody.error?.message ?? `Widget API error: ${response.status}`);
+      const errorBody = await response.json().catch(() => ({ error: { code: "UNKNOWN", message: "Request failed" } }));
+      const code = errorBody.error?.code ?? "UNKNOWN";
+      const message = errorBody.error?.message ?? `Widget API error: ${response.status}`;
+      if (response.status === 401 || response.status === 403) {
+        throw new ChatClientAuthError({
+          message,
+          code,
+          statusCode: response.status,
+          requestId
+        });
+      }
+      if (response.status === 429) {
+        const retryAfterHeader = responseHeaders?.get("Retry-After") ?? null;
+        const retryAfter = retryAfterHeader ? parseInt(retryAfterHeader, 10) : null;
+        throw new ChatClientRateLimitError({
+          message,
+          code,
+          statusCode: response.status,
+          requestId,
+          retryAfter: Number.isFinite(retryAfter ?? NaN) ? retryAfter : null
+        });
+      }
+      if (response.status >= 500) {
+        throw new ChatClientServerError({
+          message,
+          code,
+          statusCode: response.status,
+          requestId
+        });
+      }
+      throw new ChatClientError(message, {
+        code,
+        statusCode: response.status,
+        requestId
+      });
     }
     return response.json();
   }
+  /**
+   * Look up the team UUID from the configured `teamSlug`. Used by
+   * `loginWithCredentials`. HMAC integrators (`identify()`) never hit
+   * this path — verify-identity accepts the slug directly.
+   *
+   * @internal
+   */
+  async resolveTeamIdFromSlug() {
+    const response = await this.fetch(
+      "/api/widget/team-by-slug",
+      {
+        method: "GET",
+        query: { teamSlug: this.teamSlug }
+      }
+    );
+    return response.data.teamId;
+  }
+  /** @internal Bootstrap realtime from a session login (no precomputed customerId). */
+  async initRealtimeFromSession(customerName) {
+    try {
+      this.realtimeManager = new RealtimeManager({
+        fetchToken: () => this.fetchRealtimeToken()
+      });
+      const ready = await this.realtimeManager.init();
+      if (!ready) return;
+      this.realtimeReady = true;
+      const token = this.realtimeManager.getCurrentToken();
+      const customerId = token ? decodeJwtSub(token) : null;
+      if (customerId) {
+        this.customerId = customerId;
+        this.presenceManager = new PresenceManager({ customerId, customerName });
+        const client = this.realtimeManager.getClient();
+        if (client) {
+          this.presenceManager.setClient(client);
+        }
+      }
+    } catch {
+      this.realtimeReady = false;
+    }
+  }
   /** @internal Get the stored team ID for requests that need it. */
   getTeamId() {
     return this.teamId;
@@ -664,6 +873,25 @@ var MessagesApi = class {
     return response.data.message;
   }
 };
+function decodeJwtSub(jwt) {
+  try {
+    const parts = jwt.split(".");
+    if (parts.length !== 3) return null;
+    const payloadB64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = payloadB64 + "=".repeat((4 - payloadB64.length % 4) % 4);
+    const payload = JSON.parse(
+      typeof atob === "function" ? atob(padded) : Buffer.from(padded, "base64").toString("utf-8")
+    );
+    return typeof payload.sub === "string" ? payload.sub : null;
+  } catch {
+    return null;
+  }
+}
 export {
-  ChatClient
+  ChatClient,
+  ChatClientAuthError,
+  ChatClientError,
+  ChatClientNetworkError,
+  ChatClientRateLimitError,
+  ChatClientServerError
 };

package/dist/quickhelp/index.cjs

@@ -0,0 +1,102 @@
+"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/quickhelp/index.ts
+var quickhelp_exports = {};
+__export(quickhelp_exports, {
+  QuickHelpClient: () => QuickHelpClient,
+  QuickHelpError: () => QuickHelpError
+});
+module.exports = __toCommonJS(quickhelp_exports);
+var DEFAULT_BASE_URL = "https://www.cstar.help";
+var QuickHelpClient = class {
+  constructor(config) {
+    if (!config?.teamId) {
+      throw new Error("QuickHelpClient: teamId is required");
+    }
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.teamId = config.teamId;
+  }
+  /**
+   * Fetch the sanitized public config (title, subtitle, placeholder,
+   * theme overrides). Never includes agent id or escalation contact
+   * info — those leak only through the agent's own replies.
+   *
+   * Returns `null` if Quick Help is disabled on the team (404).
+   */
+  async config() {
+    const url = `${this.baseUrl}/api/quickhelp/config/${encodeURIComponent(this.teamId)}`;
+    const res = await globalThis.fetch(url, { method: "GET" });
+    if (res.status === 404) return null;
+    if (!res.ok) {
+      const body2 = await res.json().catch(() => null);
+      throw new Error(body2?.error?.message ?? `Quick Help config failed: ${res.status}`);
+    }
+    const body = await res.json();
+    return body.data;
+  }
+  /**
+   * Ask a question and get an answer. On first turn, omit `sessionId`;
+   * the server mints one and you MUST pass it back on follow-ups. On
+   * rate-limit (429) the returned Error has a `retryAfterSeconds`
+   * property set from the response body.
+   */
+  async ask(params) {
+    const url = `${this.baseUrl}/api/quickhelp/ask`;
+    const res = await globalThis.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        team_id: this.teamId,
+        session_id: params.sessionId ?? null,
+        question: params.question
+      })
+    });
+    const body = await res.json().catch(() => null);
+    if (!res.ok || !body?.success || !body.data) {
+      const message = body?.error?.message ?? `Quick Help ask failed: ${res.status}`;
+      const err = new QuickHelpError(message, {
+        status: res.status,
+        code: body?.error?.code,
+        retryAfterSeconds: parseRetryAfter(res.headers.get("retry-after"))
+      });
+      throw err;
+    }
+    return body.data;
+  }
+};
+var QuickHelpError = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "QuickHelpError";
+    this.status = opts.status;
+    this.code = opts.code;
+    this.retryAfterSeconds = opts.retryAfterSeconds;
+  }
+};
+function parseRetryAfter(header) {
+  if (!header) return void 0;
+  const n = Number(header);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QuickHelpClient,
+  QuickHelpError
+});

package/dist/quickhelp/index.d.cts

@@ -0,0 +1,97 @@
+/** Options for the QuickHelpClient. No auth — Quick Help is anonymous by design. */
+interface QuickHelpConfig {
+    /** Your team's UUID. Required. */
+    teamId: string;
+    /** Override the base URL (defaults to https://www.cstar.help). */
+    baseUrl?: string;
+}
+/** Sanitized config the server returns to anonymous visitors. */
+interface QuickHelpPublicConfig {
+    headerTitle: string;
+    headerSubtitle: string;
+    placeholderText: string;
+    theme: 'light' | 'dark' | null;
+    primaryColor: string | null;
+    fontHeading: string | null;
+    fontBody: string | null;
+    borderRadius: string | null;
+}
+type QuickHelpTurnOutcome = 'answered' | 'escalated' | 'needs_clarification';
+interface QuickHelpAskParams {
+    /** The visitor's question. Max 2000 chars. */
+    question: string;
+    /**
+     * The session id from a previous `ask()` call, if this is a follow-up
+     * turn. Omit or pass null on the first turn; the server mints a new
+     * id and returns it in `sessionId`.
+     */
+    sessionId?: string | null;
+}
+interface QuickHelpAskResult {
+    sessionId: string;
+    answer: string;
+    turnOutcome: QuickHelpTurnOutcome;
+    turnNumber: number;
+}
+
+/**
+ * Quick Help — anonymous AI Q&A client.
+ *
+ * No API key. No login. The Quick Help widget is the exact same product
+ * cStar's marketing site dogfoods on its homepage, just driven
+ * programmatically. Sessions live entirely in memory on the caller side;
+ * the server hands back a `sessionId` on the first turn and expects you
+ * to pass it back on follow-ups so the orchestrator can see prior
+ * transcript.
+ *
+ * ```typescript
+ * import { QuickHelpClient } from '@cstar.help/js/quickhelp';
+ *
+ * const qh = new QuickHelpClient({ teamId: 'your-team-uuid' });
+ *
+ * const turn1 = await qh.ask({ question: 'How do I reset my password?' });
+ * console.log(turn1.answer);
+ *
+ * const turn2 = await qh.ask({
+ *   question: 'Can you walk me through that?',
+ *   sessionId: turn1.sessionId
+ * });
+ * ```
+ */
+declare class QuickHelpClient {
+    private readonly baseUrl;
+    private readonly teamId;
+    constructor(config: QuickHelpConfig);
+    /**
+     * Fetch the sanitized public config (title, subtitle, placeholder,
+     * theme overrides). Never includes agent id or escalation contact
+     * info — those leak only through the agent's own replies.
+     *
+     * Returns `null` if Quick Help is disabled on the team (404).
+     */
+    config(): Promise<QuickHelpPublicConfig | null>;
+    /**
+     * Ask a question and get an answer. On first turn, omit `sessionId`;
+     * the server mints one and you MUST pass it back on follow-ups. On
+     * rate-limit (429) the returned Error has a `retryAfterSeconds`
+     * property set from the response body.
+     */
+    ask(params: QuickHelpAskParams): Promise<QuickHelpAskResult>;
+}
+/**
+ * Thrown by `QuickHelpClient.ask` when the request fails. Carries the
+ * HTTP status + error code + Retry-After (on 429) so callers can back
+ * off intelligently.
+ */
+declare class QuickHelpError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    readonly retryAfterSeconds?: number;
+    constructor(message: string, opts: {
+        status: number;
+        code?: string;
+        retryAfterSeconds?: number;
+    });
+}
+
+export { type QuickHelpAskParams, type QuickHelpAskResult, QuickHelpClient, type QuickHelpConfig, QuickHelpError, type QuickHelpPublicConfig, type QuickHelpTurnOutcome };

package/dist/quickhelp/index.d.ts

@@ -0,0 +1,97 @@
+/** Options for the QuickHelpClient. No auth — Quick Help is anonymous by design. */
+interface QuickHelpConfig {
+    /** Your team's UUID. Required. */
+    teamId: string;
+    /** Override the base URL (defaults to https://www.cstar.help). */
+    baseUrl?: string;
+}
+/** Sanitized config the server returns to anonymous visitors. */
+interface QuickHelpPublicConfig {
+    headerTitle: string;
+    headerSubtitle: string;
+    placeholderText: string;
+    theme: 'light' | 'dark' | null;
+    primaryColor: string | null;
+    fontHeading: string | null;
+    fontBody: string | null;
+    borderRadius: string | null;
+}
+type QuickHelpTurnOutcome = 'answered' | 'escalated' | 'needs_clarification';
+interface QuickHelpAskParams {
+    /** The visitor's question. Max 2000 chars. */
+    question: string;
+    /**
+     * The session id from a previous `ask()` call, if this is a follow-up
+     * turn. Omit or pass null on the first turn; the server mints a new
+     * id and returns it in `sessionId`.
+     */
+    sessionId?: string | null;
+}
+interface QuickHelpAskResult {
+    sessionId: string;
+    answer: string;
+    turnOutcome: QuickHelpTurnOutcome;
+    turnNumber: number;
+}
+
+/**
+ * Quick Help — anonymous AI Q&A client.
+ *
+ * No API key. No login. The Quick Help widget is the exact same product
+ * cStar's marketing site dogfoods on its homepage, just driven
+ * programmatically. Sessions live entirely in memory on the caller side;
+ * the server hands back a `sessionId` on the first turn and expects you
+ * to pass it back on follow-ups so the orchestrator can see prior
+ * transcript.
+ *
+ * ```typescript
+ * import { QuickHelpClient } from '@cstar.help/js/quickhelp';
+ *
+ * const qh = new QuickHelpClient({ teamId: 'your-team-uuid' });
+ *
+ * const turn1 = await qh.ask({ question: 'How do I reset my password?' });
+ * console.log(turn1.answer);
+ *
+ * const turn2 = await qh.ask({
+ *   question: 'Can you walk me through that?',
+ *   sessionId: turn1.sessionId
+ * });
+ * ```
+ */
+declare class QuickHelpClient {
+    private readonly baseUrl;
+    private readonly teamId;
+    constructor(config: QuickHelpConfig);
+    /**
+     * Fetch the sanitized public config (title, subtitle, placeholder,
+     * theme overrides). Never includes agent id or escalation contact
+     * info — those leak only through the agent's own replies.
+     *
+     * Returns `null` if Quick Help is disabled on the team (404).
+     */
+    config(): Promise<QuickHelpPublicConfig | null>;
+    /**
+     * Ask a question and get an answer. On first turn, omit `sessionId`;
+     * the server mints one and you MUST pass it back on follow-ups. On
+     * rate-limit (429) the returned Error has a `retryAfterSeconds`
+     * property set from the response body.
+     */
+    ask(params: QuickHelpAskParams): Promise<QuickHelpAskResult>;
+}
+/**
+ * Thrown by `QuickHelpClient.ask` when the request fails. Carries the
+ * HTTP status + error code + Retry-After (on 429) so callers can back
+ * off intelligently.
+ */
+declare class QuickHelpError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    readonly retryAfterSeconds?: number;
+    constructor(message: string, opts: {
+        status: number;
+        code?: string;
+        retryAfterSeconds?: number;
+    });
+}
+
+export { type QuickHelpAskParams, type QuickHelpAskResult, QuickHelpClient, type QuickHelpConfig, QuickHelpError, type QuickHelpPublicConfig, type QuickHelpTurnOutcome };

package/dist/quickhelp/index.js

@@ -0,0 +1,76 @@
+// src/quickhelp/index.ts
+var DEFAULT_BASE_URL = "https://www.cstar.help";
+var QuickHelpClient = class {
+  constructor(config) {
+    if (!config?.teamId) {
+      throw new Error("QuickHelpClient: teamId is required");
+    }
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.teamId = config.teamId;
+  }
+  /**
+   * Fetch the sanitized public config (title, subtitle, placeholder,
+   * theme overrides). Never includes agent id or escalation contact
+   * info — those leak only through the agent's own replies.
+   *
+   * Returns `null` if Quick Help is disabled on the team (404).
+   */
+  async config() {
+    const url = `${this.baseUrl}/api/quickhelp/config/${encodeURIComponent(this.teamId)}`;
+    const res = await globalThis.fetch(url, { method: "GET" });
+    if (res.status === 404) return null;
+    if (!res.ok) {
+      const body2 = await res.json().catch(() => null);
+      throw new Error(body2?.error?.message ?? `Quick Help config failed: ${res.status}`);
+    }
+    const body = await res.json();
+    return body.data;
+  }
+  /**
+   * Ask a question and get an answer. On first turn, omit `sessionId`;
+   * the server mints one and you MUST pass it back on follow-ups. On
+   * rate-limit (429) the returned Error has a `retryAfterSeconds`
+   * property set from the response body.
+   */
+  async ask(params) {
+    const url = `${this.baseUrl}/api/quickhelp/ask`;
+    const res = await globalThis.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        team_id: this.teamId,
+        session_id: params.sessionId ?? null,
+        question: params.question
+      })
+    });
+    const body = await res.json().catch(() => null);
+    if (!res.ok || !body?.success || !body.data) {
+      const message = body?.error?.message ?? `Quick Help ask failed: ${res.status}`;
+      const err = new QuickHelpError(message, {
+        status: res.status,
+        code: body?.error?.code,
+        retryAfterSeconds: parseRetryAfter(res.headers.get("retry-after"))
+      });
+      throw err;
+    }
+    return body.data;
+  }
+};
+var QuickHelpError = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "QuickHelpError";
+    this.status = opts.status;
+    this.code = opts.code;
+    this.retryAfterSeconds = opts.retryAfterSeconds;
+  }
+};
+function parseRetryAfter(header) {
+  if (!header) return void 0;
+  const n = Number(header);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+export {
+  QuickHelpClient,
+  QuickHelpError
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cstar.help/js",
-	"version": "0.11.0",
+	"version": "0.12.1",
 	"description": "Official TypeScript SDK for the cStar customer support platform",
 	"type": "module",
 	"main": "./dist/index.cjs",
@@ -76,6 +76,16 @@
 				"types": "./dist/proactive/index.d.cts",
 				"default": "./dist/proactive/index.cjs"
 			}
+		},
+		"./quickhelp": {
+			"import": {
+				"types": "./dist/quickhelp/index.d.ts",
+				"default": "./dist/quickhelp/index.js"
+			},
+			"require": {
+				"types": "./dist/quickhelp/index.d.cts",
+				"default": "./dist/quickhelp/index.cjs"
+			}
 		}
 	},
 	"files": [