@firstflow/react 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1754 @@
+// src/analytics/events.ts
+var ISSUE_SUBMITTED = "issue_submitted";
+var FEEDBACK_SUBMITTED = "feedback_submitted";
+var SURVEY_COMPLETED = "survey_completed";
+var EXPERIENCE_SHOWN = "experience_shown";
+var EXPERIENCE_CLICKED = "experience_clicked";
+var CHAT_MESSAGE_SENT = "chat_message_sent";
+
+// src/analytics/identity.ts
+var ANON_KEY = "ff_anon";
+var SESSION_KEY = "ff_sess";
+function uuid() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+function getStorage(key, storage) {
+  if (typeof window === "undefined" || !storage) return uuid();
+  try {
+    let value = storage.getItem(key);
+    if (!value) {
+      value = uuid();
+      storage.setItem(key, value);
+    }
+    return value;
+  } catch {
+    return uuid();
+  }
+}
+function getAnonymousId() {
+  return getStorage(ANON_KEY, typeof window !== "undefined" ? window.localStorage : null);
+}
+function getSessionId() {
+  return getStorage(SESSION_KEY, typeof window !== "undefined" ? window.sessionStorage : null);
+}
+
+// src/analytics/device.ts
+function getDeviceType() {
+  if (typeof window === "undefined") return "desktop";
+  const w = window.innerWidth;
+  if (w <= 768) return "mobile";
+  if (w <= 1024) return "tablet";
+  return "desktop";
+}
+
+// src/analytics/jitsu.ts
+var DEFAULT_JITSU_HOST = "https://cmmiyu46c00003b6unusxjf0j.analytics.firstflow.dev";
+var DEFAULT_JITSU_KEY = "P5qcd1d4Bd98EdxS4EfnucLohE2Ch37K:U4OECTXofJVzR5jhjaCpaYj478871PFU";
+function uuid2() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+function sendTrack(config, event, properties = {}) {
+  const host = config.jitsuHost || DEFAULT_JITSU_HOST;
+  const key = config.jitsuWriteKey || DEFAULT_JITSU_KEY;
+  const payload = {
+    messageId: uuid2(),
+    type: "track",
+    event,
+    anonymousId: getAnonymousId(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    properties: {
+      agent_id: config.agentId,
+      session_id: getSessionId(),
+      device_type: getDeviceType(),
+      ...properties
+    }
+  };
+  const auth = "Basic " + btoa(key);
+  fetch(`${host.replace(/\/$/, "")}/api/s/track`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: auth
+    },
+    body: JSON.stringify(payload),
+    keepalive: true
+  }).catch(() => {
+  });
+}
+
+// src/analytics/analytics.ts
+var DEFAULT_JITSU_HOST2 = "https://cmmiyu46c00003b6unusxjf0j.analytics.firstflow.dev";
+var DEFAULT_JITSU_KEY2 = "P5qcd1d4Bd98EdxS4EfnucLohE2Ch37K:U4OECTXofJVzR5jhjaCpaYj478871PFU";
+function createAnalytics(config) {
+  const agentId = config.agentId;
+  const jitsuHost = config.jitsuHost ?? DEFAULT_JITSU_HOST2;
+  const jitsuWriteKey = config.jitsuWriteKey ?? DEFAULT_JITSU_KEY2;
+  const transportConfig = { jitsuHost, jitsuWriteKey, agentId };
+  return {
+    track(eventName, properties = {}) {
+      sendTrack(transportConfig, eventName, properties);
+    },
+    identify(userId, traits = {}) {
+      if (userId) {
+        sendTrack(transportConfig, "user_identified", { user_id: userId, ...traits });
+      }
+    },
+    page(name, properties = {}) {
+      sendTrack(transportConfig, "page_view", { page_name: name ?? void 0, ...properties });
+    }
+  };
+}
+
+// src/config/defaults.ts
+var DEFAULT_PROMPT_TEXT = "Something wrong? Report an issue and we'll look into it.";
+var DEFAULT_FIELDS = [
+  { id: "name", label: "Name", type: "text", required: true },
+  { id: "email", label: "Email", type: "text", required: true },
+  { id: "subject", label: "Subject", type: "text", required: true },
+  { id: "description", label: "Description", type: "textarea", required: true },
+  { id: "session_id", label: "Session ID", type: "text", required: false }
+];
+
+// src/config/normalizer.ts
+function normalizeField(raw) {
+  const id = raw.id?.trim();
+  if (!id) return null;
+  if (raw.allowed === false) return null;
+  const type = raw.type === "textarea" || raw.type === "select" ? raw.type : "text";
+  return {
+    id,
+    type,
+    label: raw.label?.trim() ?? id,
+    required: raw.required === true,
+    options: type === "select" && Array.isArray(raw.options) ? raw.options : void 0
+  };
+}
+function normalizeConfig(agentId, apiUrl, raw) {
+  const enabled = raw?.enabled === true;
+  const promptText = typeof raw?.promptText === "string" && raw.promptText.trim() ? raw.promptText.trim() : DEFAULT_PROMPT_TEXT;
+  let fields = DEFAULT_FIELDS;
+  if (Array.isArray(raw?.fields) && raw.fields.length > 0) {
+    const normalized = raw.fields.map(normalizeField).filter((f) => f !== null);
+    if (normalized.length > 0) fields = normalized;
+  }
+  return {
+    agentId,
+    apiUrl: apiUrl.replace(/\/$/, ""),
+    enabled,
+    promptText,
+    fields
+  };
+}
+
+// src/validation/validate.ts
+var CONTEXT_KEYS = /* @__PURE__ */ new Set([
+  "conversationId",
+  "messageId",
+  "sessionId",
+  "agentId",
+  "model"
+]);
+function isContextKey(key) {
+  return CONTEXT_KEYS.has(key);
+}
+function validatePayload(data, fields) {
+  const errors = {};
+  const fieldIds = new Set(fields.map((f) => f.id));
+  for (const field of fields) {
+    const value = data[field.id];
+    const str = typeof value === "string" ? value.trim() : "";
+    if (field.required && !str) {
+      errors[field.id] = `${field.label ?? field.id} is required`;
+      continue;
+    }
+    if (!field.required && !str) continue;
+    if (field.type === "select" && field.options?.length) {
+      if (!field.options.includes(str)) {
+        errors[field.id] = `Please choose a valid option`;
+      }
+    }
+  }
+  return {
+    valid: Object.keys(errors).length === 0,
+    errors: Object.keys(errors).length > 0 ? errors : void 0
+  };
+}
+function getFormFieldsOnly(data, fields) {
+  const fieldIds = new Set(fields.map((f) => f.id));
+  const out = {};
+  for (const key of Object.keys(data)) {
+    if (isContextKey(key)) continue;
+    if (fieldIds.has(key)) out[key] = data[key];
+  }
+  return out;
+}
+
+// src/api/IssueReporter.ts
+function extractContextMetadata(data, formFieldIds) {
+  const ctx = {};
+  for (const key of Object.keys(data)) {
+    if (formFieldIds.has(key)) continue;
+    const v = data[key];
+    if (v !== void 0) ctx[key] = v;
+  }
+  return ctx;
+}
+function buildPayload(formValues, contextMetadata) {
+  return { ...formValues, ...contextMetadata };
+}
+function createIssueReporter(options) {
+  const { agentId, apiUrl, config: rawConfig, analytics: analyticsOpt } = options;
+  const analytics = analyticsOpt ?? createAnalytics({ agentId });
+  let config = normalizeConfig(agentId, apiUrl, rawConfig);
+  let openHandler;
+  const instance = {
+    getConfig() {
+      return config;
+    },
+    setConfig(next) {
+      config = next;
+    },
+    async reportIssue(data) {
+      const formValues = getFormFieldsOnly(
+        data,
+        config.fields
+      );
+      const result = validatePayload(formValues, config.fields);
+      if (!result.valid) {
+        throw new Error(
+          result.errors ? Object.entries(result.errors).map(([k, v]) => `${k}: ${v}`).join(", ") : "Validation failed"
+        );
+      }
+      const formFieldIds = new Set(config.fields.map((f) => f.id));
+      const contextMetadata = extractContextMetadata(data, formFieldIds);
+      const payload = buildPayload(formValues, contextMetadata);
+      analytics.track(ISSUE_SUBMITTED, {
+        payload: JSON.stringify(payload),
+        metadata: JSON.stringify({})
+      });
+    },
+    open(options2) {
+      openHandler?.(options2);
+    },
+    setOpenHandler(handler) {
+      openHandler = handler;
+    },
+    destroy() {
+      openHandler = void 0;
+    }
+  };
+  return instance;
+}
+
+// src/config/feedbackNormalizer.ts
+var DEFAULT_TAGS = ["Insightful", "Actionable", "Clear"];
+var DEFAULT_HEADING = "Tell us more";
+var DEFAULT_PLACEHOLDER = "Anything else you'd like to add? (optional)";
+function normalizeSide(raw) {
+  const tags = Array.isArray(raw?.tags) && raw.tags.length > 0 ? [...new Set(raw.tags.map((t) => String(t).trim()).filter(Boolean))] : [...DEFAULT_TAGS];
+  return {
+    tags,
+    heading: typeof raw?.heading === "string" && raw.heading.trim() ? raw.heading.trim() : DEFAULT_HEADING,
+    placeholder: typeof raw?.placeholder === "string" && raw.placeholder.trim() ? raw.placeholder.trim() : DEFAULT_PLACEHOLDER,
+    showTags: raw?.showTags === true,
+    showComment: raw?.showComment === true
+  };
+}
+function normalizeFeedbackConfig(raw) {
+  const enabled = raw?.enabled === true;
+  return {
+    enabled,
+    like: normalizeSide(raw?.like),
+    dislike: normalizeSide(raw?.dislike)
+  };
+}
+function defaultFeedbackConfig() {
+  return normalizeFeedbackConfig({ enabled: false });
+}
+
+// src/api/MessageFeedback.ts
+var METADATA_MAX_BYTES = 32768;
+function normalizeMetadata(meta) {
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) return void 0;
+  if (Object.keys(meta).length === 0) return void 0;
+  try {
+    const s = JSON.stringify(meta);
+    if (s.length > METADATA_MAX_BYTES) {
+      console.warn(
+        `[Firstflow] feedback metadata omitted (serialized length ${s.length} > ${METADATA_MAX_BYTES})`
+      );
+      return void 0;
+    }
+    return JSON.parse(s);
+  } catch {
+    console.warn("[Firstflow] feedback metadata must be JSON-serializable; omitted");
+    return void 0;
+  }
+}
+function buildJitsuPayload(payload) {
+  const payloadObj = {
+    conversation_id: payload.conversationId.trim(),
+    message_id: payload.messageId.trim(),
+    rating: payload.rating,
+    submitted_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (payload.comment != null && String(payload.comment).trim()) {
+    payloadObj.comment = String(payload.comment).trim();
+  }
+  if (payload.messagePreview != null && String(payload.messagePreview).trim()) {
+    payloadObj.message_preview = String(payload.messagePreview).trim().slice(0, 2e3);
+  }
+  if (payload.tags != null && payload.tags.length > 0) {
+    payloadObj.tags = payload.tags;
+  }
+  if (typeof payload.showTags === "boolean") {
+    payloadObj.showTags = payload.showTags;
+  }
+  if (typeof payload.showComment === "boolean") {
+    payloadObj.showComment = payload.showComment;
+  }
+  const metadata = normalizeMetadata(payload.metadata) ?? {};
+  return {
+    payload: JSON.stringify(payloadObj),
+    metadata: JSON.stringify(metadata),
+    rating: payload.rating
+    // top-level for ClickHouse summary queries
+  };
+}
+function createMessageFeedback(options) {
+  const { agentId, analytics: analyticsOpt, config: rawConfig } = options;
+  const analytics = analyticsOpt ?? createAnalytics({ agentId });
+  let config = normalizeFeedbackConfig(rawConfig ?? void 0);
+  return {
+    getConfig() {
+      return config;
+    },
+    setConfig(next) {
+      config = next;
+    },
+    isEnabled() {
+      return config.enabled === true;
+    },
+    async submit(payload) {
+      const cid = payload.conversationId?.trim();
+      const mid = payload.messageId?.trim();
+      if (!cid) throw new Error("conversationId is required");
+      if (!mid) throw new Error("messageId is required");
+      if (payload.rating !== "like" && payload.rating !== "dislike") {
+        throw new Error('rating must be "like" or "dislike"');
+      }
+      analytics.track(
+        FEEDBACK_SUBMITTED,
+        buildJitsuPayload({ ...payload, conversationId: cid, messageId: mid })
+      );
+    },
+    destroy() {
+      config = defaultFeedbackConfig();
+    }
+  };
+}
+
+// src/api/Firstflow.ts
+var internalIssueMap = /* @__PURE__ */ new WeakMap();
+var internalFeedbackMap = /* @__PURE__ */ new WeakMap();
+function createIssueFacade(inner) {
+  return {
+    open(options) {
+      inner.open(options);
+    },
+    async submit(data) {
+      await inner.reportIssue(data);
+    },
+    getConfig() {
+      return inner.getConfig();
+    },
+    destroy() {
+      inner.destroy();
+    }
+  };
+}
+function createFeedbackFacade(inner) {
+  return {
+    submit(payload) {
+      return inner.submit(payload);
+    },
+    getConfig() {
+      return inner.getConfig();
+    },
+    isEnabled() {
+      return inner.isEnabled();
+    }
+  };
+}
+function getInternalIssueReporter(firstflow) {
+  const inner = internalIssueMap.get(firstflow);
+  if (!inner) throw new Error("Invalid Firstflow instance");
+  return inner;
+}
+function getInternalMessageFeedback(firstflow) {
+  const inner = internalFeedbackMap.get(firstflow);
+  if (!inner) throw new Error("Invalid Firstflow instance");
+  return inner;
+}
+function createFirstflow(options) {
+  const { agentId, apiUrl, jitsuHost, jitsuWriteKey, feedbackConfig } = options;
+  const analytics = createAnalytics({ agentId, jitsuHost, jitsuWriteKey });
+  const inner = createIssueReporter({ agentId, apiUrl, analytics });
+  const feedbackInner = createMessageFeedback({
+    agentId,
+    analytics,
+    config: feedbackConfig ?? void 0
+  });
+  const firstflow = {
+    get agentId() {
+      return agentId;
+    },
+    get apiUrl() {
+      return apiUrl;
+    },
+    analytics,
+    issue: createIssueFacade(inner),
+    feedback: createFeedbackFacade(feedbackInner)
+  };
+  internalIssueMap.set(firstflow, inner);
+  internalFeedbackMap.set(firstflow, feedbackInner);
+  return firstflow;
+}
+
+// src/context/FirstflowContext.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+
+// src/context/IssueReporterContext.tsx
+import {
+  createContext,
+  useCallback as useCallback3,
+  useContext,
+  useEffect as useEffect3,
+  useRef,
+  useState as useState2
+} from "react";
+
+// src/components/IssueModal.tsx
+import { useEffect as useEffect2 } from "react";
+import { createPortal } from "react-dom";
+
+// src/components/FormEngine.tsx
+import { useCallback as useCallback2 } from "react";
+
+// src/hooks/useIssueForm.ts
+import { useCallback, useEffect, useState } from "react";
+function emptyValues(fields) {
+  const init = {};
+  fields.forEach((f) => {
+    init[f.id] = "";
+  });
+  return init;
+}
+function useIssueForm() {
+  const { reporter, openOptionsRef } = useIssueReporterContext();
+  const config = reporter.getConfig();
+  const fields = config.fields;
+  const [values, setValuesState] = useState(() => emptyValues(fields));
+  const [errors, setErrors] = useState({});
+  const [submitting, setSubmitting] = useState(false);
+  const [submitted, setSubmitted] = useState(false);
+  const [submitError, setSubmitError] = useState(null);
+  const fieldsKey = fields.map((f) => f.id).join("\0");
+  useEffect(() => {
+    setValuesState(emptyValues(fields));
+    setErrors({});
+    setSubmitted(false);
+    setSubmitError(null);
+  }, [fieldsKey, reporter]);
+  const setValue = useCallback((fieldId, value) => {
+    setValuesState((prev) => ({ ...prev, [fieldId]: value }));
+    setErrors((prev) => prev[fieldId] ? { ...prev, [fieldId]: "" } : prev);
+  }, []);
+  const setValues = useCallback((next) => {
+    setValuesState(next);
+  }, []);
+  const validate = useCallback(() => {
+    const result = validatePayload(
+      values,
+      fields
+    );
+    if (!result.valid) {
+      setErrors(result.errors ?? {});
+      return false;
+    }
+    setErrors({});
+    return true;
+  }, [values, fields]);
+  const submit = useCallback(async () => {
+    if (!validate()) return;
+    setSubmitting(true);
+    setSubmitError(null);
+    const context = openOptionsRef.current ?? {};
+    try {
+      await reporter.reportIssue({ ...values, ...context });
+      setSubmitted(true);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      setSubmitError(msg);
+      throw e;
+    } finally {
+      setSubmitting(false);
+    }
+  }, [validate, values, reporter, openOptionsRef]);
+  const reset = useCallback(() => {
+    setValuesState(emptyValues(fields));
+    setErrors({});
+    setSubmitted(false);
+    setSubmitError(null);
+  }, [fields]);
+  const clearSubmitError = useCallback(() => setSubmitError(null), []);
+  return {
+    values,
+    setValue,
+    setValues,
+    errors,
+    submitting,
+    submitted,
+    submitError,
+    validate,
+    submit,
+    reset,
+    clearSubmitError,
+    isEnabled: config.enabled,
+    config,
+    fields,
+    promptText: config.promptText
+  };
+}
+
+// src/components/FormEngine.module.css
+var FormEngine_default = {};
+
+// src/components/FormEngine.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function FormEngine({
+  onSubmitSuccess,
+  onCancel,
+  submitLabel = "Submit",
+  cancelLabel = "Cancel"
+}) {
+  const {
+    values,
+    setValue,
+    errors,
+    submitting,
+    submit,
+    submitError,
+    isEnabled,
+    fields,
+    promptText
+  } = useIssueForm();
+  const handleSubmit = useCallback2(
+    async (e) => {
+      e.preventDefault();
+      try {
+        await submit();
+        onSubmitSuccess?.();
+      } catch {
+      }
+    },
+    [submit, onSubmitSuccess]
+  );
+  if (!isEnabled) return null;
+  return /* @__PURE__ */ jsxs("form", { onSubmit: handleSubmit, className: FormEngine_default.form, children: [
+    promptText ? /* @__PURE__ */ jsx("p", { className: FormEngine_default.prompt, children: promptText }) : null,
+    fields.map((field) => /* @__PURE__ */ jsxs("div", { className: FormEngine_default.field, children: [
+      /* @__PURE__ */ jsxs("label", { htmlFor: field.id, className: FormEngine_default.label, children: [
+        field.label,
+        field.required ? " *" : ""
+      ] }),
+      field.type === "textarea" ? /* @__PURE__ */ jsx(
+        "textarea",
+        {
+          id: field.id,
+          className: errors[field.id] ? `${FormEngine_default.textarea} ${FormEngine_default.textareaError}` : FormEngine_default.textarea,
+          value: values[field.id] ?? "",
+          onChange: (e) => setValue(field.id, e.target.value),
+          required: field.required
+        }
+      ) : field.type === "select" ? /* @__PURE__ */ jsxs(
+        "select",
+        {
+          id: field.id,
+          className: errors[field.id] ? `${FormEngine_default.select} ${FormEngine_default.selectError}` : FormEngine_default.select,
+          value: values[field.id] ?? "",
+          onChange: (e) => setValue(field.id, e.target.value),
+          required: field.required,
+          children: [
+            /* @__PURE__ */ jsx("option", { value: "", children: "Select\u2026" }),
+            (field.options ?? []).map((opt) => /* @__PURE__ */ jsx("option", { value: opt, children: opt }, opt))
+          ]
+        }
+      ) : /* @__PURE__ */ jsx(
+        "input",
+        {
+          id: field.id,
+          type: "text",
+          className: errors[field.id] ? `${FormEngine_default.input} ${FormEngine_default.inputError}` : FormEngine_default.input,
+          value: values[field.id] ?? "",
+          onChange: (e) => setValue(field.id, e.target.value),
+          required: field.required
+        }
+      ),
+      errors[field.id] ? /* @__PURE__ */ jsx("span", { className: FormEngine_default.errorText, children: errors[field.id] }) : null
+    ] }, field.id)),
+    submitError ? /* @__PURE__ */ jsx("p", { className: FormEngine_default.submitError, children: submitError }) : null,
+    /* @__PURE__ */ jsxs("div", { className: FormEngine_default.actions, children: [
+      onCancel ? /* @__PURE__ */ jsx("button", { type: "button", onClick: onCancel, disabled: submitting, children: cancelLabel }) : null,
+      /* @__PURE__ */ jsx("button", { type: "submit", disabled: submitting, children: submitting ? "Sending\u2026" : submitLabel })
+    ] })
+  ] });
+}
+
+// src/components/IssueModal.module.css
+var IssueModal_default = {};
+
+// src/components/IssueModal.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function IssueModal() {
+  const { isModalOpen, closeModal } = useIssueReporterContext();
+  useEffect2(() => {
+    if (!isModalOpen) return;
+    const onKeyDown = (e) => {
+      if (e.key === "Escape") closeModal();
+    };
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [isModalOpen, closeModal]);
+  if (!isModalOpen) return null;
+  const content = /* @__PURE__ */ jsx2(
+    "div",
+    {
+      className: IssueModal_default.overlay,
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-labelledby": "ff-issue-modal-title",
+      onClick: (e) => e.target === e.currentTarget && closeModal(),
+      children: /* @__PURE__ */ jsxs2("div", { className: IssueModal_default.panel, onClick: (e) => e.stopPropagation(), children: [
+        /* @__PURE__ */ jsx2(
+          "button",
+          {
+            type: "button",
+            className: IssueModal_default.close,
+            onClick: closeModal,
+            "aria-label": "Close",
+            children: "\xD7"
+          }
+        ),
+        /* @__PURE__ */ jsx2("h2", { id: "ff-issue-modal-title", className: IssueModal_default.title, children: "Report an issue" }),
+        /* @__PURE__ */ jsx2(
+          FormEngine,
+          {
+            onSubmitSuccess: closeModal,
+            onCancel: closeModal,
+            submitLabel: "Submit",
+            cancelLabel: "Cancel"
+          }
+        )
+      ] })
+    }
+  );
+  return createPortal(content, document.body);
+}
+
+// src/context/IssueReporterContext.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var IssueReporterContext = createContext(
+  null
+);
+function IssueReporterProvider({
+  reporter,
+  children
+}) {
+  const [isModalOpen, setIsModalOpen] = useState2(false);
+  const openOptionsRef = useRef(void 0);
+  const openModal = useCallback3((options) => {
+    openOptionsRef.current = options;
+    setIsModalOpen(true);
+  }, []);
+  const closeModal = useCallback3(() => {
+    setIsModalOpen(false);
+    openOptionsRef.current = void 0;
+  }, []);
+  useEffect3(() => {
+    reporter.setOpenHandler(openModal);
+    return () => {
+      reporter.setOpenHandler(void 0);
+    };
+  }, [reporter, openModal]);
+  const value = {
+    reporter,
+    isModalOpen,
+    openModal,
+    closeModal,
+    openOptionsRef
+  };
+  return /* @__PURE__ */ jsxs3(IssueReporterContext.Provider, { value, children: [
+    children,
+    /* @__PURE__ */ jsx3(IssueModal, {})
+  ] });
+}
+function useIssueReporterContext() {
+  const ctx = useContext(IssueReporterContext);
+  if (ctx == null) {
+    throw new Error(
+      "useIssueReporterContext must be used within IssueReporterProvider"
+    );
+  }
+  return ctx;
+}
+
+// src/context/FirstflowContext.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var FirstflowContext = createContext2(null);
+var FirstflowConfigContext = createContext2(null);
+function FirstflowProvider({ firstflow, children, config = null }) {
+  const internalIssue = getInternalIssueReporter(firstflow);
+  return /* @__PURE__ */ jsx4(FirstflowConfigContext.Provider, { value: config ?? null, children: /* @__PURE__ */ jsx4(FirstflowContext.Provider, { value: firstflow, children: /* @__PURE__ */ jsx4(IssueReporterProvider, { reporter: internalIssue, children }) }) });
+}
+function useFirstflow() {
+  const ctx = useContext2(FirstflowContext);
+  if (ctx == null) {
+    throw new Error("useFirstflow must be used within FirstflowProvider");
+  }
+  return ctx;
+}
+function useFirstflowConfig() {
+  return useContext2(FirstflowConfigContext);
+}
+
+// src/hooks/useCreateFirstflow.ts
+import { useEffect as useEffect4, useState as useState3 } from "react";
+
+// src/config/fetcher.ts
+function extractAgentRecord(json) {
+  if (!json || typeof json !== "object") return null;
+  const o = json;
+  const data = o.data;
+  if (data?.agent && typeof data.agent === "object") {
+    return data.agent;
+  }
+  if (o.agent && typeof o.agent === "object") {
+    return o.agent;
+  }
+  if ("issues_config" in o || "feedback_config" in o) {
+    return o;
+  }
+  return null;
+}
+function extractExperiencesFromResponse(json) {
+  if (!json || typeof json !== "object") return [];
+  const data = json.data;
+  const raw = data?.experiences;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((x) => x != null && typeof x === "object");
+}
+async function fetchSdkAgentConfig(apiUrl, agentId) {
+  const url = `${apiUrl.replace(/\/$/, "")}/agents/${agentId}/config`;
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Failed to load config: ${res.status}`);
+  const json = await res.json();
+  const experiences = extractExperiencesFromResponse(json);
+  const agent = extractAgentRecord(json);
+  if (!agent) {
+    return experiences.length ? { experiences } : {};
+  }
+  return {
+    issues_config: agent.issues_config,
+    feedback_config: agent.feedback_config,
+    experiences
+  };
+}
+
+// src/hooks/useCreateFirstflow.ts
+function useCreateFirstflow(agentId, apiUrl, options = {}) {
+  const { fetchConfig = false } = options;
+  const [firstflow, setFirstflow] = useState3(null);
+  const [loading, setLoading] = useState3(true);
+  const [error, setError] = useState3(null);
+  const [config, setConfig] = useState3(null);
+  useEffect4(() => {
+    if (!agentId || !apiUrl) {
+      setFirstflow(createFirstflow({ agentId: agentId || "", apiUrl: apiUrl || "" }));
+      setConfig(null);
+      setLoading(false);
+      return;
+    }
+    if (!fetchConfig) {
+      setFirstflow(createFirstflow({ agentId, apiUrl }));
+      setConfig(null);
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    setConfig(null);
+    (async () => {
+      try {
+        const sdk = await fetchSdkAgentConfig(apiUrl, agentId);
+        if (cancelled) return;
+        const inst = createFirstflow({ agentId, apiUrl });
+        getInternalIssueReporter(inst).setConfig(normalizeConfig(agentId, apiUrl, sdk.issues_config));
+        getInternalMessageFeedback(inst).setConfig(normalizeFeedbackConfig(sdk.feedback_config));
+        setFirstflow(inst);
+        setConfig(sdk);
+      } catch (e) {
+        if (!cancelled) {
+          setError(e instanceof Error ? e : new Error(String(e)));
+          setConfig(null);
+        }
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [agentId, apiUrl, fetchConfig]);
+  return { firstflow, loading, error, config };
+}
+
+// src/hooks/useFeedback.ts
+import { useCallback as useCallback4, useEffect as useEffect5, useMemo, useRef as useRef2, useState as useState4 } from "react";
+function storageKey(agentId, messageId) {
+  return `ff_feedback_${agentId}_${messageId}`;
+}
+function isMessageScope(o) {
+  return o != null && typeof o.conversationId === "string" && typeof o.messageId === "string" && typeof o.messagePreview === "string";
+}
+function useFeedback(options) {
+  const firstflow = useFirstflow();
+  const scoped = isMessageScope(options);
+  const [rating, setRatingState] = useState4(null);
+  const [selectedTags, setSelectedTags] = useState4([]);
+  const [comment, setCommentState] = useState4("");
+  const [submitting, setSubmitting] = useState4(false);
+  const [error, setError] = useState4(null);
+  const [submitted, setSubmitted] = useState4(false);
+  const isEnabled = firstflow.feedback.isEnabled();
+  const config = isEnabled ? firstflow.feedback.getConfig() : null;
+  const sideConfig = useMemo(() => {
+    if (!scoped || !config || !rating) return null;
+    return rating === "like" ? config.like : config.dislike;
+  }, [scoped, config, rating]);
+  const ratingRef = useRef2(rating);
+  ratingRef.current = rating;
+  const conversationId = scoped ? options.conversationId : "";
+  const messageId = scoped ? options.messageId : "";
+  const messagePreview = scoped ? options.messagePreview : "";
+  const metadata = scoped ? options.metadata : void 0;
+  useEffect5(() => {
+    if (!scoped) return;
+    setRatingState(null);
+    setSelectedTags([]);
+    setCommentState("");
+    setError(null);
+    setSubmitted(false);
+    if (!isEnabled) return;
+    try {
+      const raw = localStorage.getItem(storageKey(firstflow.agentId, messageId));
+      if (!raw) return;
+      const parsed = JSON.parse(raw);
+      if (parsed.rating === "like" || parsed.rating === "dislike") {
+        setRatingState(parsed.rating);
+        setSelectedTags(Array.isArray(parsed.tags) ? parsed.tags : []);
+        setCommentState(typeof parsed.comment === "string" ? parsed.comment : "");
+      }
+    } catch {
+    }
+  }, [scoped, firstflow.agentId, isEnabled, messageId]);
+  const setRating = useCallback4(
+    (r) => {
+      if (!scoped) return;
+      if (r !== ratingRef.current) {
+        setSelectedTags([]);
+        setCommentState("");
+      }
+      setRatingState(r);
+      setError(null);
+      setSubmitted(false);
+    },
+    [scoped]
+  );
+  const toggleTag = useCallback4(
+    (tag) => {
+      if (!scoped) return;
+      setSelectedTags((prev) => prev.includes(tag) ? prev.filter((t) => t !== tag) : [...prev, tag]);
+      setError(null);
+    },
+    [scoped]
+  );
+  const setComment = useCallback4(
+    (c) => {
+      if (!scoped) return;
+      setCommentState(c);
+    },
+    [scoped]
+  );
+  const clearError = useCallback4(() => setError(null), []);
+  const submit = useCallback4(async () => {
+    if (!scoped || !isEnabled || !rating) return;
+    setSubmitting(true);
+    setError(null);
+    const cfg = firstflow.feedback.getConfig();
+    const sideCfg = rating === "like" ? cfg.like : cfg.dislike;
+    const showTags = sideCfg.showTags === true;
+    const showComment = sideCfg.showComment === true;
+    const payload = {
+      conversationId,
+      messageId,
+      rating,
+      showTags,
+      showComment,
+      tags: showTags && selectedTags.length ? [...new Set(selectedTags)] : void 0,
+      comment: showComment && comment.trim() ? comment.trim() : void 0,
+      messagePreview: messagePreview.slice(0, 2e3),
+      metadata
+    };
+    try {
+      await firstflow.feedback.submit(payload);
+      try {
+        localStorage.setItem(
+          storageKey(firstflow.agentId, messageId),
+          JSON.stringify({ rating, tags: selectedTags, comment })
+        );
+      } catch {
+      }
+      setSubmitted(true);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to send feedback");
+    } finally {
+      setSubmitting(false);
+    }
+  }, [
+    scoped,
+    isEnabled,
+    rating,
+    conversationId,
+    messageId,
+    messagePreview,
+    metadata,
+    selectedTags,
+    comment,
+    firstflow,
+    isEnabled
+  ]);
+  if (!scoped) {
+    return firstflow.feedback;
+  }
+  return {
+    rating,
+    selectedTags,
+    comment,
+    submitting,
+    submitted,
+    error,
+    setRating,
+    toggleTag,
+    setComment,
+    submit,
+    clearError,
+    isEnabled,
+    config,
+    sideConfig
+  };
+}
+
+// src/hooks/useExperienceMessageNode.ts
+import { useCallback as useCallback5, useEffect as useEffect6, useMemo as useMemo2, useRef as useRef3 } from "react";
+
+// src/experience/flowMessageNode.ts
+function normalizeFlowMessageStyle(style) {
+  if (style === "inline") return "message";
+  return style;
+}
+function normalizeFlowQuickReplyItem(entry) {
+  if (typeof entry === "string") return { label: entry };
+  if (entry && typeof entry === "object" && "label" in entry && typeof entry.label === "string") {
+    const o = entry;
+    return { label: o.label, prompt: o.prompt };
+  }
+  return { label: "" };
+}
+function normalizeFlowQuickReplyList(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map((x) => normalizeFlowQuickReplyItem(x));
+}
+var EXPERIENCE_MESSAGE_ANALYTICS_ACTION = {
+  cta_primary: "cta_primary",
+  cta_dismiss: "cta_dismiss",
+  quick_reply: "quick_reply",
+  carousel_cta: "carousel_cta"
+};
+var EXPERIENCE_MESSAGE_BLOCKS_VERSION = 4;
+function buildExperienceMessageBlocks(config) {
+  const blocks = [];
+  const content = config.messageContent?.trim();
+  if (content) {
+    blocks.push({ type: "text", body: content });
+  }
+  const style = config.messageStyle;
+  if (style === "carousel" && config.carouselCards && config.carouselCards.length > 0) {
+    blocks.push({ type: "carousel", cards: config.carouselCards });
+  }
+  if (style === "quick_replies") {
+    const qr = normalizeFlowQuickReplyList(config.quickReplies).filter((q) => q.label.trim());
+    if (qr.length > 0) {
+      blocks.push({ type: "quick_replies", options: qr });
+    }
+  }
+  const ctaType = config.ctaType ?? "none";
+  const ctaText = config.ctaText?.trim();
+  const skipCtaBlocks = style === "quick_replies";
+  if (!skipCtaBlocks && (ctaType === "button" || ctaType === "link" || ctaType === "button_dismiss") && ctaText) {
+    const promptTrim = config.ctaPrompt?.trim();
+    blocks.push({
+      type: "cta_primary",
+      label: ctaText,
+      ctaType,
+      url: config.ctaUrl?.trim() || void 0,
+      promptText: ctaType === "button" || ctaType === "button_dismiss" ? promptTrim || void 0 : void 0
+    });
+  }
+  const dismissText = config.dismissText?.trim();
+  if (!skipCtaBlocks && (ctaType === "dismiss" || ctaType === "button_dismiss") && dismissText) {
+    blocks.push({ type: "cta_dismiss", label: dismissText });
+  }
+  return blocks;
+}
+function buildExperienceMessageUi(blocks, messageStyle) {
+  return {
+    hasText: blocks.some((b) => b.type === "text"),
+    hasCarousel: blocks.some((b) => b.type === "carousel"),
+    hasQuickReplies: blocks.some((b) => b.type === "quick_replies"),
+    hasPrimaryCta: blocks.some((b) => b.type === "cta_primary"),
+    hasDismissCta: blocks.some((b) => b.type === "cta_dismiss"),
+    messageStyle: normalizeFlowMessageStyle(messageStyle)
+  };
+}
+function buildExperienceCarouselCtaAction(config, cardId, actionId) {
+  const id = actionId === "secondary" ? "secondary" : "primary";
+  const card = config.carouselCards?.find((c) => c.id === cardId);
+  if (!card) {
+    return { kind: "carousel_cta", cardId, actionId: id };
+  }
+  const isSecondary = id === "secondary";
+  const label = isSecondary ? card.secondaryButtonText?.trim() : card.buttonText?.trim();
+  const buttonAction = isSecondary ? card.secondaryButtonAction ?? "prompt" : card.buttonAction ?? "prompt";
+  const linkUrl = isSecondary ? card.secondaryButtonUrl?.trim() || void 0 : card.buttonUrl?.trim() || void 0;
+  const promptText = isSecondary ? card.secondaryButtonPrompt?.trim() || void 0 : card.buttonPrompt?.trim() || void 0;
+  return {
+    kind: "carousel_cta",
+    cardId,
+    actionId: id,
+    buttonAction,
+    label,
+    linkUrl,
+    promptText
+  };
+}
+
+// src/hooks/useExperienceMessageNode.ts
+var shownImpressionKeys = /* @__PURE__ */ new Set();
+function buildClickAnalyticsBase(firstflowAgentId, experienceId, nodeId, conversationId, messageStyle, metadata, action) {
+  const base = {
+    ...metadata ?? {},
+    agent_id: firstflowAgentId,
+    experience_id: experienceId,
+    node_id: nodeId,
+    message_style: normalizeFlowMessageStyle(messageStyle) ?? null,
+    action: EXPERIENCE_MESSAGE_ANALYTICS_ACTION[action.kind]
+  };
+  if (conversationId) base.conversation_id = conversationId;
+  if (action.kind === "cta_primary") {
+    base.cta_type = action.ctaType;
+    base.cta_label = action.label;
+    if (action.url) base.cta_url = action.url;
+    if (action.promptText) base.cta_prompt = action.promptText;
+  } else if (action.kind === "cta_dismiss") {
+    base.dismiss_label = action.label;
+  } else if (action.kind === "quick_reply") {
+    base.quick_reply_label = action.label;
+    base.quick_reply_index = action.index;
+    if (action.promptText) base.quick_reply_prompt = action.promptText;
+  } else if (action.kind === "carousel_cta") {
+    base.card_id = action.cardId;
+    base.carousel_action_id = action.actionId ?? "primary";
+    if (action.buttonAction) base.carousel_button_action = action.buttonAction;
+    if (action.label) base.carousel_button_label = action.label;
+    if (action.linkUrl) base.carousel_link_url = action.linkUrl;
+    if (action.promptText) base.carousel_prompt = action.promptText;
+  }
+  return base;
+}
+function buildShownAnalyticsBase(firstflowAgentId, experienceId, nodeId, conversationId, messageStyle, metadata) {
+  return {
+    ...metadata ?? {},
+    agent_id: firstflowAgentId,
+    experience_id: experienceId,
+    node_id: nodeId,
+    message_style: normalizeFlowMessageStyle(messageStyle) ?? null,
+    ...conversationId ? { conversation_id: conversationId } : {}
+  };
+}
+function useExperienceMessageNode(options) {
+  const firstflow = useFirstflow();
+  const {
+    config,
+    nodeId,
+    experienceId,
+    conversationId,
+    metadata,
+    trackShownOnMount = true,
+    impressionKey: impressionKeyOpt,
+    dedupeShown = true,
+    onAction,
+    mapAnalytics
+  } = options;
+  const blocks = useMemo2(() => buildExperienceMessageBlocks(config), [config]);
+  const ui = useMemo2(
+    () => buildExperienceMessageUi(blocks, config.messageStyle),
+    [blocks, config.messageStyle]
+  );
+  const impressionKey = impressionKeyOpt ?? `${firstflow.agentId}\0${experienceId}\0${nodeId}\0${conversationId ?? ""}`;
+  const reportShown = useCallback5(() => {
+    if (dedupeShown && shownImpressionKeys.has(impressionKey)) {
+      return;
+    }
+    const base = buildShownAnalyticsBase(
+      firstflow.agentId,
+      experienceId,
+      nodeId,
+      conversationId,
+      config.messageStyle,
+      metadata
+    );
+    let finalProps = base;
+    try {
+      finalProps = mapAnalytics?.(EXPERIENCE_SHOWN, { ...base }) ?? base;
+    } catch (e) {
+      console.warn("[Firstflow] useExperienceMessageNode mapAnalytics (experience_shown)", e);
+      finalProps = base;
+    }
+    try {
+      firstflow.analytics.track(EXPERIENCE_SHOWN, finalProps);
+      if (dedupeShown) {
+        shownImpressionKeys.add(impressionKey);
+      }
+    } catch (e) {
+      console.warn("[Firstflow] useExperienceMessageNode analytics.track (experience_shown)", e);
+    }
+  }, [
+    dedupeShown,
+    impressionKey,
+    firstflow,
+    experienceId,
+    nodeId,
+    conversationId,
+    config.messageStyle,
+    metadata,
+    mapAnalytics
+  ]);
+  const reportShownRef = useRef3(reportShown);
+  reportShownRef.current = reportShown;
+  useEffect6(() => {
+    if (!trackShownOnMount) return;
+    reportShownRef.current();
+  }, [trackShownOnMount, impressionKey]);
+  const emitClick = useCallback5(
+    (action) => {
+      try {
+        onAction?.(action);
+      } catch (e) {
+        console.warn("[Firstflow] useExperienceMessageNode onAction", e);
+      }
+      const base = buildClickAnalyticsBase(
+        firstflow.agentId,
+        experienceId,
+        nodeId,
+        conversationId,
+        config.messageStyle,
+        metadata,
+        action
+      );
+      let finalProps = base;
+      try {
+        finalProps = mapAnalytics?.(EXPERIENCE_CLICKED, { ...base }) ?? base;
+      } catch (e) {
+        console.warn("[Firstflow] useExperienceMessageNode mapAnalytics (experience_clicked)", e);
+        finalProps = base;
+      }
+      try {
+        firstflow.analytics.track(EXPERIENCE_CLICKED, finalProps);
+      } catch (e) {
+        console.warn("[Firstflow] useExperienceMessageNode analytics.track (experience_clicked)", e);
+      }
+    },
+    [
+      onAction,
+      firstflow,
+      experienceId,
+      nodeId,
+      conversationId,
+      config.messageStyle,
+      metadata,
+      mapAnalytics
+    ]
+  );
+  const handlers = useMemo2(() => {
+    return {
+      onPrimaryCta: () => {
+        const b = blocks.find((x) => x.type === "cta_primary");
+        if (!b) return;
+        emitClick({
+          kind: "cta_primary",
+          ctaType: b.ctaType,
+          label: b.label,
+          url: b.url,
+          promptText: b.promptText
+        });
+      },
+      onDismissCta: () => {
+        const b = blocks.find((x) => x.type === "cta_dismiss");
+        if (!b) return;
+        emitClick({ kind: "cta_dismiss", label: b.label });
+      },
+      onQuickReply: (label, index) => {
+        const items = normalizeFlowQuickReplyList(config.quickReplies).filter((q) => q.label.trim());
+        const item = items[index];
+        emitClick({
+          kind: "quick_reply",
+          label: item?.label ?? label,
+          index,
+          promptText: item?.prompt?.trim() || void 0
+        });
+      },
+      onCarouselCta: (cardId, actionId) => {
+        emitClick(buildExperienceCarouselCtaAction(config, cardId, actionId));
+      }
+    };
+  }, [blocks, config, emitClick]);
+  return {
+    config,
+    blocks,
+    blocksVersion: EXPERIENCE_MESSAGE_BLOCKS_VERSION,
+    ui,
+    handlers,
+    reportShown
+  };
+}
+
+// src/hooks/useExperienceAnnouncementNode.ts
+import { useCallback as useCallback6, useEffect as useEffect7, useMemo as useMemo3, useRef as useRef4 } from "react";
+
+// src/experience/flowAnnouncementNode.ts
+var EXPERIENCE_ANNOUNCEMENT_ANALYTICS_ACTION = {
+  cta_click: "cta_click",
+  dismiss: "dismiss",
+  auto_hidden: "auto_hidden"
+};
+var EXPERIENCE_ANNOUNCEMENT_BLOCKS_VERSION = 1;
+var STYLES = /* @__PURE__ */ new Set([
+  "chat_bubble",
+  "card",
+  "banner",
+  "tooltip",
+  "spotlight"
+]);
+var THEMES = /* @__PURE__ */ new Set(["info", "success", "warning", "promo", "neutral"]);
+var POSITIONS = /* @__PURE__ */ new Set([
+  "top",
+  "bottom",
+  "top-left",
+  "top-right",
+  "bottom-left",
+  "bottom-right",
+  "center"
+]);
+function asStyle(v) {
+  return typeof v === "string" && STYLES.has(v) ? v : void 0;
+}
+function asTheme(v) {
+  return typeof v === "string" && THEMES.has(v) ? v : void 0;
+}
+function asPosition(v) {
+  return typeof v === "string" && POSITIONS.has(v) ? v : void 0;
+}
+function toBool(v) {
+  if (typeof v === "boolean") return v;
+  return void 0;
+}
+function toPositiveInt(v) {
+  if (typeof v === "number" && Number.isFinite(v) && v > 0) return Math.floor(v);
+  if (typeof v === "string" && v.trim() !== "") {
+    const n = parseInt(v, 10);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return void 0;
+}
+function normalizeFlowAnnouncementNodeConfig(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const r = raw;
+  return {
+    announcementStyle: asStyle(r.announcementStyle),
+    announcementTheme: asTheme(r.announcementTheme),
+    announcementTitle: r.announcementTitle != null ? String(r.announcementTitle) : void 0,
+    announcementBody: r.announcementBody != null ? String(r.announcementBody) : void 0,
+    announcementEmoji: r.announcementEmoji != null ? String(r.announcementEmoji) : void 0,
+    ctaText: r.ctaText != null ? String(r.ctaText) : void 0,
+    ctaUrl: r.ctaUrl != null ? String(r.ctaUrl) : void 0,
+    announcementDismissible: toBool(r.announcementDismissible),
+    announcementAutoHide: toBool(r.announcementAutoHide),
+    announcementAutoHideDelay: toPositiveInt(r.announcementAutoHideDelay),
+    announcementPosition: asPosition(r.announcementPosition)
+  };
+}
+function buildExperienceAnnouncementContent(config) {
+  const content = {};
+  const title = config.announcementTitle?.trim();
+  if (title) content.title = title;
+  const body = config.announcementBody?.trim();
+  if (body) content.body = body;
+  const emoji = config.announcementEmoji?.trim();
+  if (emoji) content.emoji = emoji;
+  const ctaLabel = config.ctaText?.trim();
+  if (ctaLabel) {
+    content.ctaLabel = ctaLabel;
+    const url = config.ctaUrl?.trim();
+    if (url) content.ctaUrl = url;
+  }
+  return content;
+}
+function buildExperienceAnnouncementUi(config, content) {
+  const delay = config.announcementAutoHideDelay ?? 0;
+  const autoHide = Boolean(config.announcementAutoHide && delay > 0);
+  return {
+    hasTitle: Boolean(content.title),
+    hasBody: Boolean(content.body),
+    hasEmoji: Boolean(content.emoji),
+    hasCta: Boolean(content.ctaLabel),
+    isDismissible: Boolean(config.announcementDismissible),
+    autoHide,
+    autoHideDelay: autoHide ? delay : 0,
+    position: config.announcementPosition,
+    style: config.announcementStyle,
+    theme: config.announcementTheme
+  };
+}
+
+// src/hooks/useExperienceAnnouncementNode.ts
+var shownImpressionKeys2 = /* @__PURE__ */ new Set();
+function buildClickAnalyticsBase2(firstflowAgentId, experienceId, nodeId, conversationId, config, metadata, action) {
+  const base = {
+    ...metadata ?? {},
+    agent_id: firstflowAgentId,
+    experience_id: experienceId,
+    node_id: nodeId,
+    announcement_style: config.announcementStyle ?? null,
+    announcement_theme: config.announcementTheme ?? null,
+    action: EXPERIENCE_ANNOUNCEMENT_ANALYTICS_ACTION[action.kind]
+  };
+  if (conversationId) base.conversation_id = conversationId;
+  if (action.kind === "cta_click") {
+    base.cta_label = action.label;
+    if (action.url) base.cta_url = action.url;
+  }
+  return base;
+}
+function buildShownAnalyticsBase2(firstflowAgentId, experienceId, nodeId, conversationId, config, metadata) {
+  return {
+    ...metadata ?? {},
+    agent_id: firstflowAgentId,
+    experience_id: experienceId,
+    node_id: nodeId,
+    announcement_style: config.announcementStyle ?? null,
+    announcement_theme: config.announcementTheme ?? null,
+    ...conversationId ? { conversation_id: conversationId } : {}
+  };
+}
+function useExperienceAnnouncementNode(options) {
+  const firstflow = useFirstflow();
+  const {
+    config: configInput,
+    nodeId,
+    experienceId,
+    conversationId,
+    metadata,
+    trackShownOnMount = true,
+    impressionKey: impressionKeyOpt,
+    dedupeShown = true,
+    onAction,
+    mapAnalytics
+  } = options;
+  const config = useMemo3(
+    () => normalizeFlowAnnouncementNodeConfig(configInput),
+    [configInput]
+  );
+  const content = useMemo3(() => buildExperienceAnnouncementContent(config), [config]);
+  const ui = useMemo3(() => buildExperienceAnnouncementUi(config, content), [config, content]);
+  const impressionKey = impressionKeyOpt ?? `${firstflow.agentId}\0${experienceId}\0${nodeId}\0${conversationId ?? ""}`;
+  const timerRef = useRef4(null);
+  const clearAutoHideTimer = useCallback6(() => {
+    if (timerRef.current != null) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+  }, []);
+  const emitClick = useCallback6(
+    (action) => {
+      try {
+        onAction?.(action);
+      } catch (e) {
+        console.warn("[Firstflow] useExperienceAnnouncementNode onAction", e);
+      }
+      const base = buildClickAnalyticsBase2(
+        firstflow.agentId,
+        experienceId,
+        nodeId,
+        conversationId,
+        config,
+        metadata,
+        action
+      );
+      let finalProps = base;
+      try {
+        finalProps = mapAnalytics?.(EXPERIENCE_CLICKED, { ...base }) ?? base;
+      } catch (e) {
+        console.warn(
+          "[Firstflow] useExperienceAnnouncementNode mapAnalytics (experience_clicked)",
+          e
+        );
+        finalProps = base;
+      }
+      try {
+        firstflow.analytics.track(EXPERIENCE_CLICKED, finalProps);
+      } catch (e) {
+        console.warn(
+          "[Firstflow] useExperienceAnnouncementNode analytics.track (experience_clicked)",
+          e
+        );
+      }
+    },
+    [onAction, firstflow, experienceId, nodeId, conversationId, config, metadata, mapAnalytics]
+  );
+  const emitClickRef = useRef4(emitClick);
+  emitClickRef.current = emitClick;
+  useEffect7(() => {
+    if (!ui.autoHide || ui.autoHideDelay <= 0) return;
+    timerRef.current = setTimeout(() => {
+      timerRef.current = null;
+      emitClickRef.current({ kind: "auto_hidden" });
+    }, ui.autoHideDelay);
+    return () => {
+      if (timerRef.current != null) {
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+    };
+  }, [ui.autoHide, ui.autoHideDelay, impressionKey]);
+  const reportShown = useCallback6(() => {
+    if (dedupeShown && shownImpressionKeys2.has(impressionKey)) {
+      return;
+    }
+    const base = buildShownAnalyticsBase2(
+      firstflow.agentId,
+      experienceId,
+      nodeId,
+      conversationId,
+      config,
+      metadata
+    );
+    let finalProps = base;
+    try {
+      finalProps = mapAnalytics?.(EXPERIENCE_SHOWN, { ...base }) ?? base;
+    } catch (e) {
+      console.warn(
+        "[Firstflow] useExperienceAnnouncementNode mapAnalytics (experience_shown)",
+        e
+      );
+      finalProps = base;
+    }
+    try {
+      firstflow.analytics.track(EXPERIENCE_SHOWN, finalProps);
+      if (dedupeShown) {
+        shownImpressionKeys2.add(impressionKey);
+      }
+    } catch (e) {
+      console.warn(
+        "[Firstflow] useExperienceAnnouncementNode analytics.track (experience_shown)",
+        e
+      );
+    }
+  }, [
+    dedupeShown,
+    impressionKey,
+    firstflow,
+    experienceId,
+    nodeId,
+    conversationId,
+    config,
+    metadata,
+    mapAnalytics
+  ]);
+  const reportShownRef = useRef4(reportShown);
+  reportShownRef.current = reportShown;
+  useEffect7(() => {
+    if (!trackShownOnMount) return;
+    reportShownRef.current();
+  }, [trackShownOnMount, impressionKey]);
+  const dismiss = useCallback6(() => {
+    clearAutoHideTimer();
+    emitClick({ kind: "dismiss" });
+  }, [clearAutoHideTimer, emitClick]);
+  const ctaClick = useCallback6(() => {
+    if (!content.ctaLabel) return;
+    clearAutoHideTimer();
+    emitClick({
+      kind: "cta_click",
+      label: content.ctaLabel,
+      url: content.ctaUrl
+    });
+  }, [content.ctaLabel, content.ctaUrl, clearAutoHideTimer, emitClick]);
+  const cancelAutoHide = useCallback6(() => {
+    clearAutoHideTimer();
+  }, [clearAutoHideTimer]);
+  const handlers = useMemo3(
+    () => ({
+      dismiss,
+      ctaClick,
+      cancelAutoHide,
+      reportShown
+    }),
+    [dismiss, ctaClick, cancelAutoHide, reportShown]
+  );
+  return {
+    config,
+    content,
+    ui,
+    blocksVersion: EXPERIENCE_ANNOUNCEMENT_BLOCKS_VERSION,
+    handlers
+  };
+}
+
+// src/components/MessageFeedback.module.css
+var MessageFeedback_default = {};
+
+// src/components/MessageFeedback.tsx
+import { Fragment, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function ThumbsIcon({ up, active }) {
+  if (up) {
+    return /* @__PURE__ */ jsx5("svg", { width: "22", height: "22", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", "aria-hidden": true, children: /* @__PURE__ */ jsx5("path", { d: "M14 9V5a3 3 0 0 0-3-3l-4 9v11h11.28a2 2 0 0 0 2-1.7l1.38-9a2 2 0 0 0-2-2.3zM7 22H4a2 2 0 0 1-2-2v-7a2 2 0 0 1 2-2h3" }) });
+  }
+  return /* @__PURE__ */ jsx5("svg", { width: "22", height: "22", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", "aria-hidden": true, children: /* @__PURE__ */ jsx5("path", { d: "M10 15v4a3 3 0 0 0 3 3l4-9V2H5.72a2 2 0 0 0-2 1.7l-1.38 9a2 2 0 0 0 2 2.3zm7.13-14h2.67A2.31 2.31 0 0 1 22 4v7a2.31 2.31 0 0 1-2.34 2H17" }) });
+}
+function MessageFeedback({
+  conversationId,
+  messageId,
+  messagePreview,
+  className,
+  metadata,
+  variant = "default",
+  inlineFormSurface = "light"
+}) {
+  const inline = variant === "inline";
+  const {
+    rating,
+    selectedTags,
+    comment,
+    submitting,
+    submitted,
+    error,
+    setRating,
+    toggleTag,
+    setComment,
+    submit,
+    isEnabled,
+    sideConfig
+  } = useFeedback({
+    conversationId,
+    messageId,
+    messagePreview,
+    metadata
+  });
+  if (!isEnabled) return null;
+  const thumbs = /* @__PURE__ */ jsxs4("div", { className: MessageFeedback_default.thumbs, children: [
+    /* @__PURE__ */ jsx5(
+      "button",
+      {
+        type: "button",
+        className: `${MessageFeedback_default.thumbBtn} ${MessageFeedback_default.thumbBtnLike} ${rating === "like" ? MessageFeedback_default.thumbBtnActiveLike : ""}`,
+        onClick: () => setRating("like"),
+        "aria-pressed": rating === "like",
+        "aria-label": "Thumbs up",
+        children: /* @__PURE__ */ jsx5(ThumbsIcon, { up: true, active: rating === "like" })
+      }
+    ),
+    /* @__PURE__ */ jsx5(
+      "button",
+      {
+        type: "button",
+        className: `${MessageFeedback_default.thumbBtn} ${rating === "dislike" ? MessageFeedback_default.thumbBtnActiveDislike : ""}`,
+        onClick: () => setRating("dislike"),
+        "aria-pressed": rating === "dislike",
+        "aria-label": "Thumbs down",
+        children: /* @__PURE__ */ jsx5(ThumbsIcon, { up: false, active: rating === "dislike" })
+      }
+    )
+  ] });
+  const formBlock = rating && sideConfig ? /* @__PURE__ */ jsxs4(Fragment, { children: [
+    /* @__PURE__ */ jsx5("p", { className: MessageFeedback_default.sectionHeading, children: sideConfig.heading.toUpperCase() }),
+    sideConfig.showTags ? /* @__PURE__ */ jsx5("div", { className: MessageFeedback_default.tags, children: sideConfig.tags.map((tag) => /* @__PURE__ */ jsx5(
+      "button",
+      {
+        type: "button",
+        className: `${MessageFeedback_default.tag} ${selectedTags.includes(tag) ? MessageFeedback_default.tagSelected : ""}`,
+        onClick: () => toggleTag(tag),
+        children: tag
+      },
+      tag
+    )) }) : null,
+    sideConfig.showComment ? /* @__PURE__ */ jsx5(
+      "textarea",
+      {
+        className: MessageFeedback_default.textarea,
+        placeholder: sideConfig.placeholder,
+        value: comment,
+        onChange: (e) => setComment(e.target.value),
+        "aria-label": "Optional comment"
+      }
+    ) : null,
+    /* @__PURE__ */ jsx5("button", { type: "button", className: MessageFeedback_default.submitBtn, disabled: submitting, onClick: () => void submit(), children: submitting ? "Sending\u2026" : "Send feedback" }),
+    submitted && !error && /* @__PURE__ */ jsx5("p", { className: MessageFeedback_default.hint, children: "Thanks \u2014 you can change your choice above and send again anytime." }),
+    error && /* @__PURE__ */ jsx5("p", { className: MessageFeedback_default.error, children: error })
+  ] }) : null;
+  if (inline) {
+    const thumbCardClass = [MessageFeedback_default.card, MessageFeedback_default.cardInline, className].filter(Boolean).join(" ");
+    const formClass = [
+      MessageFeedback_default.inlineFormBelow,
+      inlineFormSurface === "dark" ? MessageFeedback_default.inlineFormBelowDark : ""
+    ].filter(Boolean).join(" ");
+    return /* @__PURE__ */ jsxs4(Fragment, { children: [
+      /* @__PURE__ */ jsx5("div", { className: thumbCardClass, "data-ff-feedback-variant": "inline", "data-ff-inline-thumbs": "", children: thumbs }),
+      formBlock && /* @__PURE__ */ jsx5("div", { className: formClass, "data-ff-inline-form": "", children: formBlock })
+    ] });
+  }
+  const cardClass = [MessageFeedback_default.card, className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs4("div", { className: cardClass, "data-ff-feedback-variant": "default", children: [
+    /* @__PURE__ */ jsx5("p", { className: MessageFeedback_default.previewLabel, children: "PREVIEW" }),
+    /* @__PURE__ */ jsx5("div", { className: MessageFeedback_default.previewBox, children: messagePreview || "\u2014" }),
+    thumbs,
+    formBlock
+  ] });
+}
+
+// src/mount.tsx
+import { createRoot } from "react-dom/client";
+
+// src/components/InlineIssueForm.module.css
+var InlineIssueForm_default = {};
+
+// src/components/InlineIssueForm.tsx
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function InlineIssueForm() {
+  const { reporter } = useIssueReporterContext();
+  const config = reporter.getConfig();
+  if (!config.enabled) return null;
+  return /* @__PURE__ */ jsxs5("div", { className: InlineIssueForm_default.wrapper, children: [
+    /* @__PURE__ */ jsx6("h3", { className: InlineIssueForm_default.title, children: "Report an issue" }),
+    /* @__PURE__ */ jsx6(FormEngine, {})
+  ] });
+}
+
+// src/mount.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function mount(firstflow, target) {
+  const root = createRoot(target);
+  root.render(
+    /* @__PURE__ */ jsx7(FirstflowProvider, { firstflow, children: /* @__PURE__ */ jsx7(InlineIssueForm, {}) })
+  );
+  return () => root.unmount();
+}
+
+// src/hooks/useIssueReporter.ts
+import { useCallback as useCallback7 } from "react";
+function useIssueReporter() {
+  const { reporter, isModalOpen, openModal, closeModal } = useIssueReporterContext();
+  const open = useCallback7(
+    (options) => {
+      openModal(options);
+    },
+    [openModal]
+  );
+  const reportIssue = useCallback7(
+    async (data) => {
+      await reporter.reportIssue(data);
+    },
+    [reporter]
+  );
+  const submit = reportIssue;
+  return {
+    reporter,
+    open,
+    reportIssue,
+    submit,
+    config: reporter.getConfig(),
+    isModalOpen,
+    closeModal
+  };
+}
+
+// src/issue.ts
+var issue_exports = {};
+export {
+  CHAT_MESSAGE_SENT,
+  EXPERIENCE_ANNOUNCEMENT_ANALYTICS_ACTION,
+  EXPERIENCE_ANNOUNCEMENT_BLOCKS_VERSION,
+  EXPERIENCE_CLICKED,
+  EXPERIENCE_MESSAGE_ANALYTICS_ACTION,
+  EXPERIENCE_MESSAGE_BLOCKS_VERSION,
+  EXPERIENCE_SHOWN,
+  FEEDBACK_SUBMITTED,
+  FirstflowProvider,
+  FormEngine,
+  ISSUE_SUBMITTED,
+  InlineIssueForm,
+  issue_exports as Issue,
+  IssueModal,
+  IssueReporterProvider,
+  MessageFeedback,
+  SURVEY_COMPLETED,
+  buildExperienceAnnouncementContent,
+  buildExperienceAnnouncementUi,
+  buildExperienceCarouselCtaAction,
+  buildExperienceMessageBlocks,
+  buildExperienceMessageUi,
+  createFirstflow,
+  createIssueReporter,
+  fetchSdkAgentConfig,
+  mount,
+  normalizeFlowAnnouncementNodeConfig,
+  normalizeFlowMessageStyle,
+  normalizeFlowQuickReplyItem,
+  normalizeFlowQuickReplyList,
+  useCreateFirstflow,
+  useExperienceAnnouncementNode,
+  useExperienceMessageNode,
+  useFeedback,
+  useFirstflow,
+  useFirstflowConfig,
+  useIssueForm,
+  useIssueReporter,
+  useIssueReporterContext
+};