@firstflow/react 0.0.1 → 0.0.101

package/dist/chunk-WTTDFCFD.mjs

@@ -0,0 +1,2157 @@
+// 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";
+var EXPERIENCE_ANALYTICS_TYPE = {
+  FLOW_MESSAGE: "flow_message",
+  FLOW_ANNOUNCEMENT: "flow_announcement",
+  SURVEY: "survey"
+};
+
+// src/issue/defaults.ts
+var DEFAULT_PROMPT_TEXT = "Something wrong? Report an issue and we'll look into it.";
+var DEFAULT_ISSUE_TITLE = "Report an issue";
+var DEFAULT_ISSUE_TRIGGER_LABEL = "Report issue";
+var DEFAULT_ISSUE_SUBMIT_LABEL = "Submit";
+var DEFAULT_ISSUE_CANCEL_LABEL = "Cancel";
+var DEFAULT_ISSUE_CANCEL_ENABLED = true;
+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/issue/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 title = typeof raw?.title === "string" && raw.title.trim() ? raw.title.trim() : DEFAULT_ISSUE_TITLE;
+  const triggerLabel = typeof raw?.triggerLabel === "string" && raw.triggerLabel.trim() ? raw.triggerLabel.trim() : DEFAULT_ISSUE_TRIGGER_LABEL;
+  const submitLabel = typeof raw?.submitLabel === "string" && raw.submitLabel.trim() ? raw.submitLabel.trim() : DEFAULT_ISSUE_SUBMIT_LABEL;
+  const cancelLabel = typeof raw?.cancelLabel === "string" && raw.cancelLabel.trim() ? raw.cancelLabel.trim() : DEFAULT_ISSUE_CANCEL_LABEL;
+  const cancelEnabled = typeof raw?.cancelEnabled === "boolean" ? raw.cancelEnabled : DEFAULT_ISSUE_CANCEL_ENABLED;
+  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,
+    title,
+    triggerLabel,
+    submitLabel,
+    cancelLabel,
+    cancelEnabled,
+    promptText,
+    fields
+  };
+}
+
+// src/issue/validate.ts
+var CONTEXT_KEYS = /* @__PURE__ */ new Set([
+  "conversationId",
+  "messageId",
+  "sessionId",
+  "agentId",
+  "model"
+]);
+function isContextKey(key3) {
+  return CONTEXT_KEYS.has(key3);
+}
+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 key3 of Object.keys(data)) {
+    if (isContextKey(key3)) continue;
+    if (fieldIds.has(key3)) out[key3] = data[key3];
+  }
+  return out;
+}
+
+// src/analytics/identity.ts
+var ANON_KEY = "__ff_anon_id";
+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(key3, storage) {
+  if (typeof window === "undefined" || !storage) return uuid();
+  try {
+    let value = storage.getItem(key3);
+    if (!value) {
+      value = uuid();
+      storage.setItem(key3, 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);
+}
+function removeStorageKey(key3, storage) {
+  if (typeof window === "undefined" || !storage) return;
+  try {
+    storage.removeItem(key3);
+  } catch {
+  }
+}
+function clearAnonymousId() {
+  removeStorageKey(ANON_KEY, typeof window !== "undefined" ? window.localStorage : null);
+}
+function clearSessionId() {
+  removeStorageKey(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);
+  });
+}
+var RESERVED_KEYS = /* @__PURE__ */ new Set([
+  "anonymousId",
+  "agent_id",
+  "session_id",
+  "device_type",
+  "user_id",
+  "userId"
+]);
+function sanitizeTraits(traits) {
+  if (!traits) return {};
+  const out = {};
+  for (const [key3, value] of Object.entries(traits)) {
+    if (RESERVED_KEYS.has(key3)) continue;
+    out[key3] = value;
+  }
+  return out;
+}
+function coerceTraitValueToString(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value === "boolean") return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function traitsRecordToStringMap(traits) {
+  const out = {};
+  for (const [k, v] of Object.entries(traits)) {
+    const s = coerceTraitValueToString(v);
+    if (s !== null) out[k] = s;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function buildTraitsStringMap(config) {
+  const merged = { ...sanitizeTraits(config.traits) };
+  const uid = config.userId?.trim();
+  if (uid) merged.user_id = uid;
+  return traitsRecordToStringMap(merged);
+}
+function buildJitsuTrackPayload(config, event, properties = {}) {
+  const traits = buildTraitsStringMap(config);
+  const payload = {
+    messageId: uuid2(),
+    type: "track",
+    event,
+    anonymousId: getAnonymousId(),
+    ...config.userId ? { userId: config.userId } : {},
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    properties: {
+      agent_id: config.agentId,
+      session_id: getSessionId(),
+      device_type: getDeviceType(),
+      ...properties
+    }
+  };
+  if (traits) payload.traits = traits;
+  return payload;
+}
+function sendTrack(config, event, properties = {}) {
+  const host = config.jitsuHost || DEFAULT_JITSU_HOST;
+  const key3 = config.jitsuWriteKey || DEFAULT_JITSU_KEY;
+  const payload = buildJitsuTrackPayload(config, event, properties);
+  const auth = "Basic " + btoa(key3);
+  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 identity = {
+    userId: config.userId,
+    traits: config.traits ?? {}
+  };
+  function transportConfig() {
+    return {
+      jitsuHost,
+      jitsuWriteKey,
+      agentId,
+      userId: identity.userId,
+      traits: identity.traits
+    };
+  }
+  return {
+    track(eventName, properties = {}) {
+      sendTrack(transportConfig(), eventName, properties);
+    },
+    identify(userId, traits = {}) {
+      this.setUser(userId, traits);
+      if (!userId) return;
+      sendTrack(transportConfig(), "user_identified", {});
+    },
+    page(name, properties = {}) {
+      sendTrack(transportConfig(), "page_view", { page_name: name ?? void 0, ...properties });
+    },
+    setUser(userId, traits = {}) {
+      identity.userId = userId || void 0;
+      identity.traits = { ...traits ?? {} };
+    },
+    getUser() {
+      return {
+        userId: identity.userId,
+        traits: { ...identity.traits ?? {} }
+      };
+    }
+  };
+}
+
+// src/issue/IssueReporter.ts
+function extractContextMetadata(data, formFieldIds) {
+  const ctx = {};
+  for (const key3 of Object.keys(data)) {
+    if (formFieldIds.has(key3)) continue;
+    const v = data[key3];
+    if (v !== void 0) ctx[key3] = 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/types.ts
+var EXPERIENCE_SETTINGS_DEFAULT = {
+  trigger: { show_on: "chat_opens", delay_seconds: 0 },
+  device: "all",
+  audience: { type: "all" },
+  schedule: { start_type: "now", expiration_type: "none" },
+  frequency: { type: "once" },
+  priority: 0
+};
+
+// src/experience/eligibility.ts
+function makeKey(experienceId) {
+  return `ff_exp_${experienceId}_freq`;
+}
+var FREQ_KEY_PREFIX = "ff_exp_";
+function getStorageSafely(scope) {
+  try {
+    if (typeof window === "undefined") return null;
+    return scope === "session" ? window.sessionStorage : window.localStorage;
+  } catch {
+    return null;
+  }
+}
+function createStorageAdapter() {
+  const memLocal = /* @__PURE__ */ new Map();
+  const memSession = /* @__PURE__ */ new Map();
+  return {
+    get(experienceId, scope) {
+      const key3 = makeKey(experienceId);
+      const mem = scope === "session" ? memSession : memLocal;
+      try {
+        const storage = getStorageSafely(scope);
+        const raw = storage ? storage.getItem(key3) : null;
+        if (!raw) return mem.get(key3) ?? null;
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.count !== "number" || typeof parsed?.window_start !== "string") {
+          return mem.get(key3) ?? null;
+        }
+        return parsed;
+      } catch {
+        return mem.get(key3) ?? null;
+      }
+    },
+    set(experienceId, rec, scope) {
+      const key3 = makeKey(experienceId);
+      const mem = scope === "session" ? memSession : memLocal;
+      try {
+        const storage = getStorageSafely(scope);
+        if (storage) storage.setItem(key3, JSON.stringify(rec));
+        else mem.set(key3, rec);
+      } catch {
+        mem.set(key3, rec);
+      }
+    },
+    clear(experienceId, scope) {
+      const key3 = makeKey(experienceId);
+      const mem = scope === "session" ? memSession : memLocal;
+      try {
+        const storage = getStorageSafely(scope);
+        if (storage) storage.removeItem(key3);
+      } catch {
+      }
+      mem.delete(key3);
+    }
+  };
+}
+function clearFrequencyRecords() {
+  if (typeof window === "undefined") return;
+  const clearStorage = (storage) => {
+    try {
+      const keys = [];
+      for (let i = 0; i < storage.length; i++) {
+        const key3 = storage.key(i);
+        if (key3 && key3.startsWith(FREQ_KEY_PREFIX)) keys.push(key3);
+      }
+      for (const key3 of keys) storage.removeItem(key3);
+    } catch {
+    }
+  };
+  clearStorage(window.localStorage);
+  clearStorage(window.sessionStorage);
+}
+function isStatusEligible(status) {
+  return status === "active";
+}
+function isDeviceEligible(device) {
+  if (device === "all") return true;
+  if (typeof navigator === "undefined") return true;
+  const ua = navigator.userAgent.toLowerCase();
+  const isMobile = /android|iphone|ipad|ipod|mobile/.test(ua);
+  return device === "mobile" ? isMobile : !isMobile;
+}
+function asMs(value) {
+  if (!value) return null;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+}
+function isScheduleEligible(schedule, now = Date.now()) {
+  if (schedule.start_type === "scheduled") {
+    const startMs = asMs(schedule.starts_at);
+    if (startMs != null && now < startMs) return false;
+  }
+  if (schedule.expiration_type === "scheduled") {
+    const endMs = asMs(schedule.expires_at);
+    if (endMs != null && now >= endMs) return false;
+  }
+  return true;
+}
+function periodToMs(period) {
+  if (period === "day") return 864e5;
+  if (period === "week") return 6048e5;
+  return Infinity;
+}
+function getScopeForFrequency(frequency) {
+  if (frequency.type === "limited" && (frequency.period ?? "session") === "session") {
+    return "session";
+  }
+  return "local";
+}
+function isFrequencyEligible(experienceId, frequency, storage, now = Date.now()) {
+  if (frequency.type === "always") return true;
+  const scope = getScopeForFrequency(frequency);
+  const rec = storage.get(experienceId, scope);
+  if (!rec) return true;
+  if (frequency.type === "once") {
+    return rec.count === 0;
+  }
+  const limit = frequency.limit ?? 1;
+  const period = frequency.period ?? "session";
+  const windowMs = periodToMs(period);
+  if (windowMs !== Infinity) {
+    const windowStart = Date.parse(rec.window_start);
+    if (Number.isFinite(windowStart) && now - windowStart > windowMs) {
+      return true;
+    }
+  }
+  return rec.count < limit;
+}
+function markExperienceShown(experienceId, frequency, storage, now = Date.now()) {
+  if (frequency.type === "always") return;
+  const scope = getScopeForFrequency(frequency);
+  const rec = storage.get(experienceId, scope);
+  if (!rec) {
+    storage.set(
+      experienceId,
+      { count: 1, window_start: new Date(now).toISOString() },
+      scope
+    );
+    return;
+  }
+  const period = frequency.type === "limited" ? frequency.period ?? "session" : "lifetime";
+  const windowMs = periodToMs(period);
+  const windowStart = Date.parse(rec.window_start);
+  const windowExpired = windowMs !== Infinity && Number.isFinite(windowStart) && now - windowStart > windowMs;
+  if (windowExpired) {
+    storage.set(
+      experienceId,
+      { count: 1, window_start: new Date(now).toISOString() },
+      scope
+    );
+    return;
+  }
+  storage.set(
+    experienceId,
+    {
+      count: rec.count + 1,
+      window_start: rec.window_start || new Date(now).toISOString()
+    },
+    scope
+  );
+}
+function isTriggerCompatible(trigger) {
+  if (trigger.show_on === "chat_opens") return true;
+  return true;
+}
+function isAbsent(value) {
+  return value == null;
+}
+function resolveFromObject(input, path) {
+  if (!input) return void 0;
+  let current = input;
+  for (const seg of path) {
+    if (!current || typeof current !== "object" || Array.isArray(current))
+      return void 0;
+    current = current[seg];
+  }
+  return current;
+}
+function resolveTrait(trait, user) {
+  const key3 = String(trait ?? "").trim();
+  if (!key3) return void 0;
+  const segments = key3.split(".").slice(0, 3);
+  const fromRoot = resolveFromObject(
+    user,
+    segments
+  );
+  if (fromRoot !== void 0) return fromRoot;
+  const traitSegments = segments[0] === "traits" ? segments.slice(1) : segments;
+  return resolveFromObject(user.traits ?? {}, traitSegments);
+}
+function evaluateNumeric(actual, expected, operator) {
+  if (typeof actual !== "number" || typeof expected !== "number") return false;
+  if (!Number.isFinite(actual) || !Number.isFinite(expected)) return false;
+  switch (operator) {
+    case "gt":
+      return actual > expected;
+    case "gte":
+      return actual >= expected;
+    case "lt":
+      return actual < expected;
+    case "lte":
+      return actual <= expected;
+    default:
+      return false;
+  }
+}
+function evaluateRule(rule, user) {
+  const actual = resolveTrait(rule.trait, user);
+  switch (rule.operator) {
+    case "exists":
+      return !isAbsent(actual);
+    case "not_exists":
+      return isAbsent(actual);
+    case "equals":
+      return actual === rule.value;
+    case "not_equals":
+      return actual !== rule.value;
+    case "contains":
+      return typeof actual === "string" && typeof rule.value === "string" ? actual.includes(rule.value) : false;
+    case "not_contains":
+      return typeof actual === "string" && typeof rule.value === "string" ? !actual.includes(rule.value) : false;
+    case "in":
+      return Array.isArray(rule.value) ? rule.value.includes(actual) : false;
+    case "not_in":
+      return Array.isArray(rule.value) ? !rule.value.includes(actual) : false;
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+      return evaluateNumeric(actual, rule.value, rule.operator);
+    default:
+      return false;
+  }
+}
+function evaluateAudience(audience, user, membershipMap = {}) {
+  if (audience.type === "all") return true;
+  if (audience.type === "segment") {
+    const seg = String(audience.segment_id ?? "").trim();
+    if (!seg) return false;
+    return membershipMap[seg] === true;
+  }
+  if (audience.type === "rules") {
+    if (!user) return false;
+    if (audience.operator === "AND") {
+      return audience.rules.every((rule) => evaluateRule(rule, user));
+    }
+    if (audience.operator === "OR") {
+      return audience.rules.some((rule) => evaluateRule(rule, user));
+    }
+    return false;
+  }
+  return false;
+}
+function sortByPriorityDescThenStable(items) {
+  return [...items].sort((a, b) => {
+    const pa = a.settings?.priority ?? 0;
+    const pb = b.settings?.priority ?? 0;
+    if (pb !== pa) return pb - pa;
+    const aKey = String(a.experienceId ?? a.id ?? "");
+    const bKey = String(b.experienceId ?? b.id ?? "");
+    return aKey.localeCompare(bKey);
+  });
+}
+function runEligibilityFilter(experiences, storage, context = {}) {
+  const blocked = new Set(context.overrides?.blockedExperiences ?? []);
+  const forced = new Set(context.overrides?.forcedExperiences ?? []);
+  const user = context.user ?? null;
+  const membershipMap = context.membershipMap ?? {};
+  const passing = experiences.filter((exp) => {
+    const settings = exp.settings ?? EXPERIENCE_SETTINGS_DEFAULT;
+    if (blocked.has(exp.experienceId)) return false;
+    if (forced.has(exp.experienceId)) {
+      return isFrequencyEligible(exp.experienceId, settings.frequency, storage);
+    }
+    return isStatusEligible(exp.status) && isDeviceEligible(settings.device) && isScheduleEligible(settings.schedule) && isFrequencyEligible(exp.experienceId, settings.frequency, storage) && evaluateAudience(settings.audience, user, membershipMap) && isTriggerCompatible(settings.trigger);
+  });
+  return sortByPriorityDescThenStable(passing);
+}
+
+// src/platform/auth.ts
+function normalizeApiKey(apiKey) {
+  return String(apiKey ?? "").trim();
+}
+function getApiKeyFingerprint(apiKey) {
+  const key3 = normalizeApiKey(apiKey);
+  if (!key3) return "no-key";
+  return `key-${key3.length}-${key3.slice(-6)}`;
+}
+function getSdkAuthHeaders(apiKey) {
+  const key3 = normalizeApiKey(apiKey);
+  if (!key3) return {};
+  return {
+    Authorization: `Bearer ${key3}`
+  };
+}
+
+// src/platform/fetcher.ts
+var CONFIG_TTL_MS = 5 * 60 * 1e3;
+var configCache = /* @__PURE__ */ new Map();
+var inflight = /* @__PURE__ */ new Map();
+function cacheKey(apiUrl, agentId, apiKey) {
+  return `${apiUrl.replace(/\/$/, "")}::${agentId}::${getApiKeyFingerprint(apiKey)}`;
+}
+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 normalizeWidgetUiFromAgent(agent) {
+  const nested = agent.widget_ui ?? agent.widgetUi;
+  if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+    const o = nested;
+    const c = o.primary_color ?? o.primaryColor;
+    if (typeof c === "string" && c.trim()) {
+      return { primaryColor: c.trim() };
+    }
+  }
+  const top = agent.primary_color ?? agent.primaryColor;
+  if (typeof top === "string" && top.trim()) {
+    return { primaryColor: top.trim() };
+  }
+  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, apiKey) {
+  const key3 = cacheKey(apiUrl, agentId, apiKey);
+  const now = Date.now();
+  const cached = configCache.get(key3);
+  if (cached && cached.expiresAt > now) {
+    return cached.value;
+  }
+  if (cached && cached.expiresAt <= now) {
+    void fetchSdkAgentConfigFresh(apiUrl, agentId, apiKey).catch(() => {
+    });
+    return cached.value;
+  }
+  return fetchSdkAgentConfigFresh(apiUrl, agentId, apiKey);
+}
+async function fetchSdkAgentConfigFresh(apiUrl, agentId, apiKey) {
+  const key3 = cacheKey(apiUrl, agentId, apiKey);
+  const existing = inflight.get(key3);
+  if (existing) return existing;
+  const req = (async () => {
+    const url = `${apiUrl.replace(/\/$/, "")}/agents/${agentId}/config`;
+    const res = await fetch(url, {
+      headers: getSdkAuthHeaders(apiKey)
+    });
+    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) {
+      const value2 = experiences.length ? { experiences } : {};
+      configCache.set(key3, { value: value2, expiresAt: Date.now() + CONFIG_TTL_MS });
+      return value2;
+    }
+    const value = {
+      issues_config: agent.issues_config,
+      feedback_config: agent.feedback_config,
+      experiences,
+      widget_ui: normalizeWidgetUiFromAgent(agent)
+    };
+    configCache.set(key3, { value, expiresAt: Date.now() + CONFIG_TTL_MS });
+    return value;
+  })();
+  inflight.set(key3, req);
+  try {
+    return await req;
+  } finally {
+    inflight.delete(key3);
+  }
+}
+function clearSdkAgentConfigCache(apiUrl, agentId, apiKey) {
+  if (apiUrl && agentId) {
+    if (apiKey != null) {
+      configCache.delete(cacheKey(apiUrl, agentId, apiKey));
+      return;
+    }
+    const prefix = `${apiUrl.replace(/\/$/, "")}::${agentId}::`;
+    for (const key3 of configCache.keys()) {
+      if (key3.startsWith(prefix)) configCache.delete(key3);
+    }
+    return;
+  }
+  configCache.clear();
+}
+
+// src/platform/firstflow-public-api-url.ts
+var FIRSTFLOW_PUBLIC_API_BASE_URL = "http://localhost:3002";
+
+// src/feedback/feedbackNormalizer.ts
+var DEFAULT_TAGS = ["Insightful", "Actionable", "Clear"];
+var DEFAULT_PLACEHOLDER = "Anything else you'd like to add? (optional)";
+var DEFAULT_CONFIRMATION_MESSAGE = "Thanks for your feedback!";
+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,
+    placeholder: typeof raw?.placeholder === "string" && raw.placeholder.trim() ? raw.placeholder.trim() : DEFAULT_PLACEHOLDER,
+    showTags: raw?.showTags === true,
+    showComment: raw?.showComment === true,
+    confirmationMessage: typeof raw?.confirmationMessage === "string" && raw.confirmationMessage.trim() ? raw.confirmationMessage.trim() : DEFAULT_CONFIRMATION_MESSAGE
+  };
+}
+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/feedback/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 buildAnalyticsFeedbackPayload(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"');
+      }
+      const sideCfg = payload.rating === "like" ? config.like : config.dislike;
+      const enforcedPayload = {
+        ...payload,
+        conversationId: cid,
+        messageId: mid,
+        showTags: sideCfg.showTags,
+        showComment: sideCfg.showComment,
+        tags: sideCfg.showTags ? payload.tags : void 0,
+        comment: sideCfg.showComment ? payload.comment : void 0
+      };
+      analytics.track(FEEDBACK_SUBMITTED, buildAnalyticsFeedbackPayload(enforcedPayload));
+    },
+    destroy() {
+      config = defaultFeedbackConfig();
+    }
+  };
+}
+
+// src/survey/surveyNormalizer.ts
+var SURVEY_NODE_TYPES = /* @__PURE__ */ new Set([
+  "nps",
+  "multiple_choice",
+  "slider",
+  "opinion_scale",
+  "open_question",
+  "concept_test",
+  "interview_prompt",
+  "text_block",
+  "thank_you"
+]);
+function asObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = value.map((x) => String(x).trim()).filter(Boolean);
+  return out.length ? out : void 0;
+}
+function isRequired(type, config) {
+  if (type === "text_block" || type === "thank_you") return false;
+  return config.questionRequired === true || config.required === true;
+}
+function mapQuestion(node) {
+  const typeRaw = typeof node.type === "string" ? node.type : "";
+  if (!SURVEY_NODE_TYPES.has(typeRaw)) return null;
+  const type = typeRaw;
+  const config = asObject(node.data?.config) ?? {};
+  const id = asString(config.id) ?? asString(node.id) ?? "";
+  if (!id) return null;
+  const questionText = asString(config.questionText)?.trim() || (type === "text_block" ? "Text block" : type === "thank_you" ? "Thank you" : "");
+  return {
+    id,
+    nodeId: asString(node.id) ?? id,
+    type,
+    questionText,
+    required: isRequired(type, config),
+    options: asStringArray(config.surveyOptions),
+    minValue: asNumber(config.surveyMinValue),
+    maxValue: asNumber(config.surveyMaxValue),
+    minLabel: asString(config.surveyMinLabel),
+    maxLabel: asString(config.surveyMaxLabel),
+    step: asNumber(config.surveyStep),
+    scaleType: asString(config.surveyScaleType),
+    placeholder: asString(config.surveyPlaceholder),
+    multiline: config.surveyMultiline === true,
+    showConfetti: type === "thank_you" ? typeof config.showConfetti === "boolean" ? config.showConfetti : void 0 : void 0
+  };
+}
+function mapQuestionFromWorkflowOrLegacyNode(raw) {
+  const node = asObject(raw);
+  if (!node) return null;
+  const nodeId = asString(node.id)?.trim();
+  if (!nodeId) return null;
+  const data = asObject(node.data);
+  const icon = data && typeof data.icon === "string" ? data.icon.toLowerCase() : "";
+  const nodeTypeRaw = typeof node.type === "string" ? node.type.toLowerCase() : "";
+  let type = null;
+  if (icon === "survey") {
+    return null;
+  }
+  if (icon && SURVEY_NODE_TYPES.has(icon)) {
+    type = icon;
+  } else if (nodeTypeRaw && SURVEY_NODE_TYPES.has(nodeTypeRaw)) {
+    type = nodeTypeRaw;
+  }
+  if (!type) return null;
+  const config = asObject(data?.config) ?? {};
+  const id = asString(config.id)?.trim() ?? nodeId;
+  const questionText = asString(config.questionText)?.trim() || (type === "text_block" ? "Text block" : type === "thank_you" ? "Thank you" : "");
+  return {
+    id,
+    nodeId,
+    type,
+    questionText,
+    required: isRequired(type, config),
+    options: asStringArray(config.surveyOptions),
+    minValue: asNumber(config.surveyMinValue),
+    maxValue: asNumber(config.surveyMaxValue),
+    minLabel: asString(config.surveyMinLabel),
+    maxLabel: asString(config.surveyMaxLabel),
+    step: asNumber(config.surveyStep),
+    scaleType: asString(config.surveyScaleType),
+    placeholder: asString(config.surveyPlaceholder),
+    multiline: config.surveyMultiline === true,
+    showConfetti: type === "thank_you" ? typeof config.showConfetti === "boolean" ? config.showConfetti : void 0 : void 0
+  };
+}
+function isSurveyWorkflowNode(node) {
+  const data = asObject(node.data);
+  if (!data) return false;
+  const icon = typeof data.icon === "string" ? data.icon.toLowerCase() : "";
+  const title = typeof data.title === "string" ? data.title.toLowerCase() : "";
+  const config = asObject(data.config);
+  const hasList = Array.isArray(config?.surveyQuestions) && (config?.surveyQuestions).length > 0;
+  return icon === "survey" || title === "survey" || hasList;
+}
+function mapDashboardSurveyQuestion(raw, parentNodeId) {
+  const q = asObject(raw);
+  if (!q) return null;
+  const typeRaw = asString(q.type) ?? "";
+  if (!SURVEY_NODE_TYPES.has(typeRaw)) return null;
+  const type = typeRaw;
+  const id = asString(q.id) ?? "";
+  if (!id) return null;
+  const questionText = asString(q.questionText)?.trim() || (type === "text_block" ? "Text block" : type === "thank_you" ? "Thank you" : "");
+  const required = type === "text_block" || type === "thank_you" ? false : q.required === true || q.questionRequired === true;
+  return {
+    id,
+    nodeId: parentNodeId,
+    type,
+    questionText,
+    required,
+    options: asStringArray(q.options) ?? asStringArray(q.surveyOptions),
+    minValue: asNumber(q.minValue) ?? asNumber(q.surveyMinValue),
+    maxValue: asNumber(q.maxValue) ?? asNumber(q.surveyMaxValue),
+    minLabel: asString(q.minLabel) ?? asString(q.surveyMinLabel),
+    maxLabel: asString(q.maxLabel) ?? asString(q.surveyMaxLabel),
+    step: asNumber(q.step) ?? asNumber(q.surveyStep),
+    scaleType: asString(q.scaleType) ?? asString(q.surveyScaleType),
+    placeholder: asString(q.placeholder) ?? asString(q.surveyPlaceholder),
+    multiline: q.multiline === true || q.surveyMultiline === true,
+    showConfetti: type === "thank_you" ? typeof q.showConfetti === "boolean" ? q.showConfetti : void 0 : void 0
+  };
+}
+function extractSurveyQuestionsFromRuntimeFlow(flow) {
+  if (!flow) return [];
+  const nodesRaw = Array.isArray(flow.nodes) ? flow.nodes : [];
+  for (const raw of nodesRaw) {
+    const node = asObject(raw);
+    if (!node) continue;
+    if (!isSurveyWorkflowNode(node)) continue;
+    const nodeId = asString(node.id);
+    if (!nodeId) continue;
+    const data = asObject(node.data);
+    const config = asObject(data?.config);
+    const list = Array.isArray(config?.surveyQuestions) ? config?.surveyQuestions : [];
+    const batch = [];
+    for (const item of list) {
+      const mapped = mapDashboardSurveyQuestion(item, nodeId);
+      if (mapped) batch.push(mapped);
+    }
+    if (batch.length > 0) return batch;
+  }
+  return [];
+}
+function normalizeSurveyExperiences(experiences) {
+  if (!Array.isArray(experiences)) return [];
+  const out = [];
+  for (const raw of experiences) {
+    const exp = asObject(raw);
+    if (!exp) continue;
+    if (asString(exp.type) !== "survey") continue;
+    const experienceId = asString(exp.id)?.trim();
+    if (!experienceId) continue;
+    const flow = asObject(exp.flow);
+    const fromSurveyNode = extractSurveyQuestionsFromRuntimeFlow(flow);
+    const nodesRaw = Array.isArray(flow?.nodes) ? flow?.nodes : [];
+    const fromWorkflowChain = nodesRaw.map((node) => mapQuestionFromWorkflowOrLegacyNode(node)).filter((q) => q != null);
+    const questions = fromSurveyNode.length > 0 ? fromSurveyNode : fromWorkflowChain.length > 0 ? fromWorkflowChain : nodesRaw.map((node) => mapQuestion(asObject(node) ?? {})).filter((q) => q != null);
+    out.push({
+      experienceId,
+      name: asString(exp.name) ?? null,
+      status: asString(exp.status) ?? null,
+      settings: asObject(exp.settings) ?? null,
+      questions
+    });
+  }
+  return out;
+}
+
+// src/survey/Survey.ts
+var METADATA_MAX_BYTES2 = 32768;
+function normalizeMetadata2(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_BYTES2) return void 0;
+    return JSON.parse(s);
+  } catch {
+    return void 0;
+  }
+}
+function createSurveyModule(options) {
+  const { agentId, analytics: analyticsOpt, experiences } = options;
+  const analytics = analyticsOpt ?? createAnalytics({ agentId });
+  const storage = createStorageAdapter();
+  const applyAll = (raw) => runEligibilityFilter(normalizeSurveyExperiences(raw ?? void 0), storage);
+  let surveys = applyAll(experiences ?? void 0);
+  return {
+    getSurveys() {
+      return surveys;
+    },
+    getSurvey(experienceId) {
+      return surveys.find((s) => s.experienceId === experienceId) ?? null;
+    },
+    setExperiences(nextExperiences) {
+      surveys = applyAll(nextExperiences);
+    },
+    isEnabled(experienceId) {
+      if (!experienceId) return surveys.length > 0;
+      return surveys.some((s) => s.experienceId === experienceId);
+    },
+    async submit(payload) {
+      const expId = String(payload.experienceId ?? "").trim();
+      if (!expId) throw new Error("experienceId is required");
+      const metadata = normalizeMetadata2(payload.metadata) ?? {};
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      analytics.track(SURVEY_COMPLETED, {
+        agent_id: agentId,
+        experience_id: expId,
+        survey_id: expId,
+        conversation_id: payload.conversationId?.trim() || void 0,
+        submitted_at: completedAt,
+        payload: JSON.stringify({
+          experience_id: expId,
+          survey_id: expId,
+          conversation_id: payload.conversationId?.trim() || void 0,
+          completed_at: completedAt,
+          answers: payload.answers ?? {}
+        }),
+        metadata: JSON.stringify(metadata)
+      });
+    },
+    destroy() {
+      surveys = [];
+    }
+  };
+}
+
+// src/platform/Firstflow.ts
+import deepEqual from "fast-deep-equal";
+
+// src/platform/overrides.ts
+var OVERRIDES_TTL_MS = 6e4;
+var cache = /* @__PURE__ */ new Map();
+var inflight2 = /* @__PURE__ */ new Map();
+var EMPTY_OVERRIDES = {
+  blockedExperiences: [],
+  forcedExperiences: []
+};
+function key(apiUrl, agentId, userId, apiKey) {
+  return `${apiUrl.replace(/\/$/, "")}::${agentId}::${userId}::${getApiKeyFingerprint(apiKey)}`;
+}
+function normalizeArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((v) => typeof v === "string" && v.trim().length > 0);
+}
+function parseOverrides(json) {
+  if (!json || typeof json !== "object") return EMPTY_OVERRIDES;
+  const root = json;
+  const data = root.data && typeof root.data === "object" ? root.data : root;
+  return {
+    blockedExperiences: normalizeArray(
+      data.blockedExperiences ?? data.blocked_experiences
+    ),
+    forcedExperiences: normalizeArray(
+      data.forcedExperiences ?? data.forced_experiences
+    )
+  };
+}
+async function fetchAudienceOverrides(apiUrl, agentId, userId, apiKey) {
+  const uid = String(userId ?? "").trim();
+  if (!uid) return EMPTY_OVERRIDES;
+  const k = key(apiUrl, agentId, uid, apiKey);
+  const now = Date.now();
+  const cached = cache.get(k);
+  if (cached && cached.expiresAt > now) return cached.value;
+  if (cached && cached.expiresAt <= now) {
+    void fetchAudienceOverridesFresh(apiUrl, agentId, uid, apiKey).catch(
+      () => {
+      }
+    );
+    return cached.value;
+  }
+  return fetchAudienceOverridesFresh(apiUrl, agentId, uid, apiKey);
+}
+async function fetchAudienceOverridesFresh(apiUrl, agentId, userId, apiKey) {
+  const uid = String(userId).trim();
+  if (!uid) return EMPTY_OVERRIDES;
+  const k = key(apiUrl, agentId, uid, apiKey);
+  const existing = inflight2.get(k);
+  if (existing) return existing;
+  const req = (async () => {
+    try {
+      const base = apiUrl.replace(/\/$/, "");
+      const url = `${base}/agents/${agentId}/overrides?userId=${encodeURIComponent(uid)}`;
+      const res = await fetch(url, {
+        headers: getSdkAuthHeaders(apiKey)
+      });
+      if (!res.ok) throw new Error(`Failed to load overrides: ${res.status}`);
+      const json = await res.json();
+      const value = parseOverrides(json);
+      cache.set(k, { value, expiresAt: Date.now() + OVERRIDES_TTL_MS });
+      return value;
+    } catch {
+      return cache.get(k)?.value ?? EMPTY_OVERRIDES;
+    }
+  })();
+  inflight2.set(k, req);
+  try {
+    return await req;
+  } finally {
+    inflight2.delete(k);
+  }
+}
+function clearAudienceOverridesCache(apiUrl, agentId, userId, apiKey) {
+  if (apiUrl && agentId && userId) {
+    if (apiKey != null) {
+      cache.delete(key(apiUrl, agentId, userId, apiKey));
+      return;
+    }
+    const prefix = `${apiUrl.replace(/\/$/, "")}::${agentId}::${userId}::`;
+    for (const entryKey of cache.keys()) {
+      if (entryKey.startsWith(prefix)) cache.delete(entryKey);
+    }
+    return;
+  }
+  cache.clear();
+}
+
+// src/platform/membership.ts
+var MEMBERSHIP_TTL_MS = 6e4;
+var cache2 = /* @__PURE__ */ new Map();
+var inflight3 = /* @__PURE__ */ new Map();
+function key2(apiUrl, agentId, userId, apiKey) {
+  return `${apiUrl.replace(/\/$/, "")}::${agentId}::${userId}::${getApiKeyFingerprint(apiKey)}`;
+}
+function parseMembership(json) {
+  if (!json || typeof json !== "object") return {};
+  const root = json;
+  const data = root.data && typeof root.data === "object" ? root.data : root;
+  const out = {};
+  for (const [segmentId, value] of Object.entries(data)) {
+    const normalizedId = String(segmentId ?? "").trim();
+    if (!normalizedId) continue;
+    out[normalizedId] = value === true;
+  }
+  return out;
+}
+async function fetchAudienceMembership(apiUrl, agentId, userId, apiKey) {
+  const uid = String(userId ?? "").trim();
+  if (!uid) return {};
+  const k = key2(apiUrl, agentId, uid, apiKey);
+  const now = Date.now();
+  const cached = cache2.get(k);
+  if (cached && cached.expiresAt > now) return cached.value;
+  if (cached && cached.expiresAt <= now) {
+    void fetchAudienceMembershipFresh(apiUrl, agentId, uid, apiKey).catch(
+      () => {
+      }
+    );
+    return cached.value;
+  }
+  return fetchAudienceMembershipFresh(apiUrl, agentId, uid, apiKey);
+}
+async function fetchAudienceMembershipFresh(apiUrl, agentId, userId, apiKey) {
+  const uid = String(userId).trim();
+  if (!uid) return {};
+  const k = key2(apiUrl, agentId, uid, apiKey);
+  const existing = inflight3.get(k);
+  if (existing) return existing;
+  const req = (async () => {
+    try {
+      const base = apiUrl.replace(/\/$/, "");
+      const url = `${base}/agents/${agentId}/audience-membership?userId=${encodeURIComponent(uid)}`;
+      const res = await fetch(url, {
+        headers: getSdkAuthHeaders(apiKey)
+      });
+      if (!res.ok) throw new Error(`Failed to load audience membership: ${res.status}`);
+      const json = await res.json();
+      const value = parseMembership(json);
+      cache2.set(k, { value, expiresAt: Date.now() + MEMBERSHIP_TTL_MS });
+      return value;
+    } catch {
+      return cache2.get(k)?.value ?? {};
+    }
+  })();
+  inflight3.set(k, req);
+  try {
+    return await req;
+  } finally {
+    inflight3.delete(k);
+  }
+}
+function clearAudienceMembershipCache(apiUrl, agentId, userId, apiKey) {
+  if (apiUrl && agentId && userId) {
+    if (apiKey != null) {
+      cache2.delete(key2(apiUrl, agentId, userId, apiKey));
+      return;
+    }
+    const prefix = `${apiUrl.replace(/\/$/, "")}::${agentId}::${userId}::`;
+    for (const entryKey of cache2.keys()) {
+      if (entryKey.startsWith(prefix)) cache2.delete(entryKey);
+    }
+    return;
+  }
+  cache2.clear();
+}
+
+// src/experience/experienceNormalizer.ts
+function asObject2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function asString2(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function normalizeAudience(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return { type: "all" };
+  }
+  const raw = value;
+  const t = asString2(raw.type);
+  if (t === "all") return { type: "all" };
+  if (t === "segment") {
+    return {
+      type: "segment",
+      segment_id: asString2(raw.segment_id) ?? void 0
+    };
+  }
+  if (t === "rules") {
+    const op = raw.operator === "OR" ? "OR" : "AND";
+    const allowedOps = /* @__PURE__ */ new Set([
+      "equals",
+      "not_equals",
+      "contains",
+      "not_contains",
+      "in",
+      "not_in",
+      "gt",
+      "gte",
+      "lt",
+      "lte",
+      "exists",
+      "not_exists"
+    ]);
+    const rules = Array.isArray(raw.rules) ? raw.rules.filter((r) => {
+      if (!r || typeof r !== "object") return false;
+      const rr = r;
+      return typeof rr.trait === "string" && typeof rr.operator === "string" && allowedOps.has(rr.operator);
+    }) : [];
+    return {
+      type: "rules",
+      operator: op,
+      rules: rules.map((r) => ({
+        trait: r.trait,
+        operator: r.operator,
+        value: r.value
+      }))
+    };
+  }
+  return { type: "all" };
+}
+function normalizeSettings(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  return {
+    ...EXPERIENCE_SETTINGS_DEFAULT,
+    ...raw,
+    audience: normalizeAudience(raw.audience)
+  };
+}
+function normalizeExperienceRows(experiences) {
+  if (!Array.isArray(experiences)) return [];
+  const out = [];
+  for (const raw of experiences) {
+    const exp = asObject2(raw);
+    if (!exp) continue;
+    const experienceId = asString2(exp.id)?.trim();
+    if (!experienceId) continue;
+    out.push({
+      experienceId,
+      name: asString2(exp.name) ?? null,
+      status: asString2(exp.status) ?? null,
+      type: asString2(exp.type) ?? null,
+      settings: normalizeSettings(exp.settings),
+      flow: asObject2(exp.flow) ?? null
+    });
+  }
+  return out;
+}
+
+// src/platform/Firstflow.ts
+var internalIssueMap = /* @__PURE__ */ new WeakMap();
+var internalFeedbackMap = /* @__PURE__ */ new WeakMap();
+var internalSurveyMap = /* @__PURE__ */ new WeakMap();
+var internalRuntimeMap = /* @__PURE__ */ new WeakMap();
+var EMPTY_OVERRIDES2 = {
+  blockedExperiences: [],
+  forcedExperiences: []
+};
+function normalizeAudienceMembership(map) {
+  if (!map) return {};
+  const next = {};
+  for (const [segmentId, value] of Object.entries(map)) {
+    const normalizedId = String(segmentId ?? "").trim();
+    if (!normalizedId) continue;
+    next[normalizedId] = value === true;
+  }
+  return next;
+}
+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 getInternalSurvey(firstflow) {
+  const inner = internalSurveyMap.get(firstflow);
+  if (!inner) throw new Error("Invalid Firstflow instance");
+  return inner;
+}
+function getInternalRuntimeState(firstflow) {
+  const inner = internalRuntimeMap.get(firstflow);
+  if (!inner) throw new Error("Invalid Firstflow instance");
+  return inner;
+}
+function subscribeInternalRuntime(firstflow, listener) {
+  const state = getInternalRuntimeState(firstflow);
+  state.listeners.add(listener);
+  return () => {
+    state.listeners.delete(listener);
+  };
+}
+function getRuntimeSnapshot(firstflow) {
+  const state = getInternalRuntimeState(firstflow);
+  const cached = state.runtimeSnapshotCache;
+  if (cached && cached.version === state.version) {
+    return cached.snapshot;
+  }
+  const snapshot = {
+    version: state.version,
+    user: state.user,
+    audienceMembership: { ...state.audienceMembership },
+    overrides: {
+      blockedExperiences: [...state.overrides.blockedExperiences],
+      forcedExperiences: [...state.overrides.forcedExperiences]
+    },
+    experienceRows: state.experienceRows
+  };
+  state.runtimeSnapshotCache = { version: state.version, snapshot };
+  return snapshot;
+}
+function notifyRuntime(state) {
+  state.version += 1;
+  for (const listener of state.listeners) listener();
+}
+function syncExperiencesFromRaw(firstflow, rawExperiences, options = {}) {
+  const runtime = getInternalRuntimeState(firstflow);
+  const survey = getInternalSurvey(firstflow);
+  const nextRows = normalizeExperienceRows(rawExperiences);
+  if (deepEqual(nextRows, runtime.experienceRows)) return false;
+  runtime.experienceRows = nextRows;
+  survey.setExperiences(rawExperiences);
+  if (options.notify !== false) notifyRuntime(runtime);
+  return true;
+}
+function applySdkAgentPayloadInternal(firstflow, sdkPayload, options = {}) {
+  const runtime = getInternalRuntimeState(firstflow);
+  const issue = getInternalIssueReporter(firstflow);
+  const feedback = getInternalMessageFeedback(firstflow);
+  const nextIssueConfig = normalizeConfig(
+    firstflow.agentId,
+    firstflow.apiUrl,
+    sdkPayload.issues_config
+  );
+  const nextFeedbackConfig = normalizeFeedbackConfig(
+    sdkPayload.feedback_config
+  );
+  let didChange = false;
+  if (!deepEqual(nextIssueConfig, runtime.issueConfigSnapshot)) {
+    runtime.issueConfigSnapshot = nextIssueConfig;
+    issue.setConfig(nextIssueConfig);
+    didChange = true;
+  }
+  if (!deepEqual(nextFeedbackConfig, runtime.feedbackConfigSnapshot)) {
+    runtime.feedbackConfigSnapshot = nextFeedbackConfig;
+    feedback.setConfig(nextFeedbackConfig);
+    didChange = true;
+  }
+  if (syncExperiencesFromRaw(firstflow, sdkPayload.experiences, { notify: false })) {
+    didChange = true;
+  }
+  const nextWidgetUi = sdkPayload.widget_ui ?? null;
+  if (!deepEqual(nextWidgetUi, runtime.widgetUi)) {
+    runtime.widgetUi = nextWidgetUi;
+    didChange = true;
+  }
+  if (didChange && options.notify !== false) {
+    notifyRuntime(runtime);
+  }
+  return didChange;
+}
+function applySdkAgentPayload(firstflow, sdkPayload) {
+  applySdkAgentPayloadInternal(firstflow, sdkPayload);
+}
+function createFirstflow(options) {
+  const apiUrl = FIRSTFLOW_PUBLIC_API_BASE_URL.replace(/\/$/, "");
+  const { agentId, apiKey, user, autoFetchAudienceMembership = true } = options;
+  const analytics = createAnalytics({
+    agentId,
+    userId: user?.id,
+    traits: user?.traits
+  });
+  const inner = createIssueReporter({
+    agentId,
+    apiUrl,
+    analytics
+  });
+  const feedbackInner = createMessageFeedback({
+    agentId,
+    analytics
+  });
+  const surveyInner = createSurveyModule({ agentId, analytics });
+  const initialIssueConfig = inner.getConfig();
+  const initialFeedbackConfig = feedbackInner.getConfig();
+  const runtime = {
+    user: user ?? null,
+    audienceMembership: {},
+    overrides: EMPTY_OVERRIDES2,
+    experienceRows: [],
+    issueConfigSnapshot: initialIssueConfig,
+    feedbackConfigSnapshot: initialFeedbackConfig,
+    widgetUi: null,
+    listeners: /* @__PURE__ */ new Set(),
+    version: 0,
+    audienceFetchTimer: null,
+    runtimeSnapshotCache: null
+  };
+  const notify = () => {
+    notifyRuntime(runtime);
+  };
+  const fetchAudienceRuntimeForUser = async (userId) => {
+    const uid = String(userId ?? "").trim();
+    const [overrides, membership] = await Promise.all([
+      fetchAudienceOverrides(apiUrl, agentId, uid, apiKey),
+      autoFetchAudienceMembership ? fetchAudienceMembership(apiUrl, agentId, uid, apiKey) : Promise.resolve({})
+    ]);
+    let didChange = false;
+    if (!deepEqual(overrides, runtime.overrides)) {
+      runtime.overrides = overrides;
+      didChange = true;
+    }
+    if (autoFetchAudienceMembership) {
+      const nextMembership = normalizeAudienceMembership(membership);
+      if (!deepEqual(nextMembership, runtime.audienceMembership)) {
+        runtime.audienceMembership = nextMembership;
+        didChange = true;
+      }
+    }
+    if (didChange) {
+      notify();
+    }
+  };
+  const scheduleAudienceRuntimeFetch = (userId, delayMs = 300) => {
+    if (runtime.audienceFetchTimer) clearTimeout(runtime.audienceFetchTimer);
+    runtime.audienceFetchTimer = setTimeout(() => {
+      runtime.audienceFetchTimer = null;
+      void fetchAudienceRuntimeForUser(userId);
+    }, delayMs);
+  };
+  const firstflow = {
+    get agentId() {
+      return agentId;
+    },
+    get apiUrl() {
+      return apiUrl;
+    },
+    getWidgetUi() {
+      const w = runtime.widgetUi;
+      if (!w) return null;
+      return Object.freeze({ ...w });
+    },
+    analytics,
+    issue: createIssueFacade(inner),
+    feedback: createFeedbackFacade(feedbackInner),
+    survey: {
+      getSurveys() {
+        return surveyInner.getSurveys();
+      },
+      getSurvey(experienceId) {
+        return surveyInner.getSurvey(experienceId);
+      },
+      setExperiences(experiences) {
+        syncExperiencesFromRaw(firstflow, experiences);
+      },
+      isEnabled(experienceId) {
+        return surveyInner.isEnabled(experienceId);
+      },
+      submit(payload) {
+        return surveyInner.submit(payload);
+      }
+    },
+    getUser() {
+      return runtime.user ? { ...runtime.user, traits: { ...runtime.user.traits ?? {} } } : null;
+    },
+    setUser(nextUser) {
+      const previousUserId = runtime.user?.id ?? null;
+      runtime.user = nextUser ?? null;
+      if (nextUser?.id) {
+        analytics.identify(nextUser.id, nextUser.traits ?? {});
+        if (previousUserId !== nextUser.id) {
+          scheduleAudienceRuntimeFetch(nextUser.id);
+        }
+      } else {
+        analytics.setUser(void 0, {});
+        runtime.overrides = EMPTY_OVERRIDES2;
+        if (autoFetchAudienceMembership) {
+          runtime.audienceMembership = {};
+        }
+      }
+      notify();
+    },
+    setAudienceMembership(map) {
+      runtime.audienceMembership = {
+        ...runtime.audienceMembership,
+        ...normalizeAudienceMembership(map)
+      };
+      notify();
+    },
+    getAudienceMembership() {
+      return { ...runtime.audienceMembership };
+    },
+    async refreshConfig() {
+      const uid = runtime.user?.id;
+      const [sdk, overrides, membership] = await Promise.all([
+        fetchSdkAgentConfigFresh(apiUrl, agentId, apiKey),
+        fetchAudienceOverrides(apiUrl, agentId, uid, apiKey),
+        autoFetchAudienceMembership ? fetchAudienceMembership(apiUrl, agentId, uid, apiKey) : Promise.resolve({})
+      ]);
+      let didChange = applySdkAgentPayloadInternal(firstflow, sdk, {
+        notify: false
+      });
+      if (!deepEqual(overrides, runtime.overrides)) {
+        runtime.overrides = overrides;
+        didChange = true;
+      }
+      if (autoFetchAudienceMembership) {
+        const nextMembership = normalizeAudienceMembership(membership);
+        if (!deepEqual(nextMembership, runtime.audienceMembership)) {
+          runtime.audienceMembership = nextMembership;
+          didChange = true;
+        }
+      }
+      if (didChange) {
+        notify();
+      }
+    },
+    reset() {
+      clearAnonymousId();
+      clearSessionId();
+      clearFrequencyRecords();
+      runtime.user = null;
+      runtime.audienceMembership = {};
+      runtime.overrides = EMPTY_OVERRIDES2;
+      runtime.widgetUi = null;
+      analytics.setUser(void 0, {});
+      clearAudienceOverridesCache();
+      clearAudienceMembershipCache();
+      clearSdkAgentConfigCache();
+      notify();
+    }
+  };
+  if (runtime.user?.id) {
+    analytics.identify(runtime.user.id, runtime.user.traits ?? {});
+    scheduleAudienceRuntimeFetch(runtime.user.id, 0);
+  }
+  internalIssueMap.set(firstflow, inner);
+  internalFeedbackMap.set(firstflow, feedbackInner);
+  internalSurveyMap.set(firstflow, surveyInner);
+  internalRuntimeMap.set(firstflow, runtime);
+  return firstflow;
+}
+
+// src/issue/hooks/useFirstflowIssueForm.ts
+import { useCallback as useCallback2, useEffect as useEffect3, useState as useState2 } from "react";
+
+// src/issue/IssueReporterContext.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect as useEffect2,
+  useRef,
+  useState
+} from "react";
+
+// src/components/IssueForm.tsx
+import { useEffect } from "react";
+
+// #style-inject:#style-inject
+function styleInject(css, { insertAt } = {}) {
+  if (!css || typeof document === "undefined") return;
+  const head = document.head || document.getElementsByTagName("head")[0];
+  const style = document.createElement("style");
+  style.type = "text/css";
+  if (insertAt === "top") {
+    if (head.firstChild) {
+      head.insertBefore(style, head.firstChild);
+    } else {
+      head.appendChild(style);
+    }
+  } else {
+    head.appendChild(style);
+  }
+  if (style.styleSheet) {
+    style.styleSheet.cssText = css;
+  } else {
+    style.appendChild(document.createTextNode(css));
+  }
+}
+
+// src/components/IssueForm.css
+styleInject(".ffIssueBackdrop {\n  position: fixed;\n  inset: 0;\n  background: rgba(0, 0, 0, 0.5);\n  display: grid;\n  place-items: center;\n  z-index: 1000;\n}\n.ffIssuePanel {\n  width: min(560px, calc(100vw - 24px));\n  border-radius: 14px;\n  background: #fff;\n  border: 1px solid #e6e6e6;\n  padding: 16px;\n  color: #121212;\n}\n.ffIssueTitle {\n  margin: 0 0 8px;\n  font-size: 18px;\n}\n.ffIssuePrompt {\n  margin: 0 0 12px;\n  font-size: 14px;\n  color: #525252;\n}\n.ffIssueField {\n  margin-bottom: 10px;\n}\n.ffIssueLabel {\n  display: block;\n  font-size: 12px;\n  margin-bottom: 4px;\n  color: #3f3f3f;\n}\n.ffIssueInput,\n.ffIssueTextarea,\n.ffIssueSelect {\n  width: 100%;\n  border: 1px solid #d4d4d4;\n  border-radius: 8px;\n  padding: 8px 10px;\n  font-size: 14px;\n}\n.ffIssueTextarea {\n  min-height: 84px;\n  resize: vertical;\n}\n.ffIssueErrorText {\n  margin-top: 4px;\n  font-size: 12px;\n  color: #b91c1c;\n}\n.ffIssueActions {\n  margin-top: 12px;\n  display: flex;\n  justify-content: flex-end;\n  gap: 8px;\n}\n.ffIssueButton {\n  border-radius: 8px;\n  border: 1px solid #d4d4d4;\n  padding: 8px 12px;\n  background: #fff;\n  color: #111;\n  cursor: pointer;\n}\n.ffIssuePrimary {\n  background: #111;\n  color: #fff;\n  border-color: #111;\n}\n.ffIssueStatusError {\n  margin-top: 8px;\n  font-size: 12px;\n  color: #b91c1c;\n}\n.ffIssueStatusSuccess {\n  margin-top: 8px;\n  font-size: 12px;\n  color: #166534;\n}\n");
+
+// src/components/IssueForm.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var styles = {
+  backdrop: "ffIssueBackdrop",
+  panel: "ffIssuePanel",
+  title: "ffIssueTitle",
+  prompt: "ffIssuePrompt",
+  field: "ffIssueField",
+  label: "ffIssueLabel",
+  input: "ffIssueInput",
+  textarea: "ffIssueTextarea",
+  select: "ffIssueSelect",
+  errorText: "ffIssueErrorText",
+  actions: "ffIssueActions",
+  button: "ffIssueButton",
+  primary: "ffIssuePrimary",
+  statusError: "ffIssueStatusError",
+  statusSuccess: "ffIssueStatusSuccess"
+};
+function renderField(field, value, error, onChange) {
+  if (field.type === "textarea") {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        "textarea",
+        {
+          className: styles.textarea,
+          value,
+          onChange: (event) => onChange(field.id, event.target.value)
+        }
+      ),
+      error ? /* @__PURE__ */ jsx("div", { className: styles.errorText, children: error }) : null
+    ] });
+  }
+  if (field.type === "select") {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(
+        "select",
+        {
+          className: styles.select,
+          value,
+          onChange: (event) => onChange(field.id, event.target.value),
+          children: [
+            /* @__PURE__ */ jsx("option", { value: "", children: "Select an option" }),
+            (field.options ?? []).map((option) => /* @__PURE__ */ jsx("option", { value: option, children: option }, `${field.id}:${option}`))
+          ]
+        }
+      ),
+      error ? /* @__PURE__ */ jsx("div", { className: styles.errorText, children: error }) : null
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        className: styles.input,
+        value,
+        onChange: (event) => onChange(field.id, event.target.value)
+      }
+    ),
+    error ? /* @__PURE__ */ jsx("div", { className: styles.errorText, children: error }) : null
+  ] });
+}
+function IssueReporter({ showTrigger = true }) {
+  const { isModalOpen, openModal, closeModal } = useIssueReporterContext();
+  const {
+    fields,
+    values,
+    errors,
+    setValue,
+    submit,
+    submitting,
+    submitted,
+    submitError,
+    clearSubmitError,
+    reset,
+    title,
+    promptText,
+    triggerLabel,
+    submitLabel,
+    cancelLabel,
+    cancelEnabled,
+    isEnabled
+  } = useFirstflowIssueForm();
+  useEffect(() => {
+    if (!isModalOpen) {
+      reset();
+      clearSubmitError();
+    }
+  }, [isModalOpen, reset, clearSubmitError]);
+  if (!isEnabled) return null;
+  const handleSubmit = async (event) => {
+    event.preventDefault();
+    await submit();
+  };
+  const body = isModalOpen ? /* @__PURE__ */ jsx("div", { className: styles.backdrop, role: "presentation", onClick: closeModal, children: /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: styles.panel,
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-label": title,
+      onClick: (event) => event.stopPropagation(),
+      children: [
+        /* @__PURE__ */ jsx("h2", { className: styles.title, children: title }),
+        promptText ? /* @__PURE__ */ jsx("p", { className: styles.prompt, children: promptText }) : null,
+        /* @__PURE__ */ jsxs("form", { onSubmit: handleSubmit, children: [
+          fields.map((field) => /* @__PURE__ */ jsxs("div", { className: styles.field, children: [
+            /* @__PURE__ */ jsx("label", { className: styles.label, htmlFor: `ff-issue-${field.id}`, children: field.label }),
+            renderField(
+              field,
+              values[field.id] ?? "",
+              errors[field.id],
+              (fieldId, next) => setValue(fieldId, next)
+            )
+          ] }, field.id)),
+          /* @__PURE__ */ jsxs("div", { className: styles.actions, children: [
+            cancelEnabled ? /* @__PURE__ */ jsx("button", { type: "button", className: styles.button, onClick: closeModal, children: cancelLabel }) : null,
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "submit",
+                className: `${styles.button} ${styles.primary}`,
+                disabled: submitting,
+                children: submitting ? "Submitting..." : submitLabel
+              }
+            )
+          ] }),
+          submitError ? /* @__PURE__ */ jsx("div", { className: styles.statusError, children: submitError }) : null,
+          submitted ? /* @__PURE__ */ jsx("div", { className: styles.statusSuccess, children: "Thanks for your report." }) : null
+        ] })
+      ]
+    }
+  ) }) : null;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    showTrigger ? /* @__PURE__ */ jsx("button", { type: "button", className: styles.button, onClick: () => openModal(), children: triggerLabel }) : null,
+    body
+  ] });
+}
+
+// src/issue/IssueReporterContext.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var IssueReporterContext = createContext(
+  null
+);
+function IssueReporterProvider({
+  reporter,
+  children
+}) {
+  const [isModalOpen, setIsModalOpen] = useState(false);
+  const openOptionsRef = useRef(void 0);
+  const openModal = useCallback((options) => {
+    openOptionsRef.current = options;
+    setIsModalOpen(true);
+  }, []);
+  const closeModal = useCallback(() => {
+    setIsModalOpen(false);
+    openOptionsRef.current = void 0;
+  }, []);
+  useEffect2(() => {
+    reporter.setOpenHandler(openModal);
+    return () => {
+      reporter.setOpenHandler(void 0);
+    };
+  }, [reporter, openModal]);
+  const value = {
+    reporter,
+    isModalOpen,
+    openModal,
+    closeModal,
+    openOptionsRef
+  };
+  return /* @__PURE__ */ jsxs2(IssueReporterContext.Provider, { value, children: [
+    children,
+    /* @__PURE__ */ jsx2(IssueReporter, { showTrigger: false })
+  ] });
+}
+function useIssueReporterContext() {
+  const ctx = useContext(IssueReporterContext);
+  if (ctx == null) {
+    throw new Error(
+      "useIssueReporterContext must be used within IssueReporterProvider"
+    );
+  }
+  return ctx;
+}
+
+// src/issue/hooks/useFirstflowIssueForm.ts
+function emptyValues(fields) {
+  const init = {};
+  fields.forEach((f) => {
+    init[f.id] = "";
+  });
+  return init;
+}
+function useFirstflowIssueForm() {
+  const { reporter, openOptionsRef } = useIssueReporterContext();
+  const config = reporter.getConfig();
+  const fields = config.fields;
+  const [values, setValuesState] = useState2(() => emptyValues(fields));
+  const [errors, setErrors] = useState2({});
+  const [submitting, setSubmitting] = useState2(false);
+  const [submitted, setSubmitted] = useState2(false);
+  const [submitError, setSubmitError] = useState2(null);
+  const fieldsKey = fields.map((f) => f.id).join("\0");
+  useEffect3(() => {
+    setValuesState(emptyValues(fields));
+    setErrors({});
+    setSubmitted(false);
+    setSubmitError(null);
+  }, [fieldsKey, reporter]);
+  const setValue = useCallback2((fieldId, value) => {
+    setValuesState((prev) => ({ ...prev, [fieldId]: value }));
+    setErrors((prev) => prev[fieldId] ? { ...prev, [fieldId]: "" } : prev);
+  }, []);
+  const setValues = useCallback2((next) => {
+    setValuesState(next);
+  }, []);
+  const validate = useCallback2(() => {
+    const result = validatePayload(
+      values,
+      fields
+    );
+    if (!result.valid) {
+      setErrors(result.errors ?? {});
+      return false;
+    }
+    setErrors({});
+    return true;
+  }, [values, fields]);
+  const submit = useCallback2(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 = useCallback2(() => {
+    setValuesState(emptyValues(fields));
+    setErrors({});
+    setSubmitted(false);
+    setSubmitError(null);
+  }, [fields]);
+  const clearSubmitError = useCallback2(() => setSubmitError(null), []);
+  return {
+    values,
+    setValue,
+    setValues,
+    errors,
+    submitting,
+    submitted,
+    submitError,
+    validate,
+    submit,
+    reset,
+    clearSubmitError,
+    isEnabled: config.enabled,
+    config,
+    title: config.title,
+    triggerLabel: config.triggerLabel,
+    submitLabel: config.submitLabel,
+    cancelLabel: config.cancelLabel,
+    cancelEnabled: config.cancelEnabled,
+    uiText: {
+      title: config.title,
+      triggerLabel: config.triggerLabel,
+      submitLabel: config.submitLabel,
+      cancelLabel: config.cancelLabel,
+      cancelEnabled: config.cancelEnabled,
+      promptText: config.promptText
+    },
+    fields,
+    promptText: config.promptText
+  };
+}
+
+// src/platform/FirstflowContext.tsx
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useEffect as useEffect4,
+  useLayoutEffect,
+  useRef as useRef2,
+  useState as useState3
+} from "react";
+import { Fragment as Fragment2, jsx as jsx3 } from "react/jsx-runtime";
+var FirstflowContext = createContext2(null);
+function FirstflowProvider({
+  agentId,
+  apiKey,
+  children,
+  fallback = null,
+  onError,
+  initialSdkPayload = null,
+  user = null,
+  audienceMembership,
+  autoFetchAudienceMembership = true
+}) {
+  const firstflowRef = useRef2(null);
+  if (!firstflowRef.current && agentId.trim()) {
+    firstflowRef.current = createFirstflow({
+      agentId,
+      apiKey,
+      user: user ?? void 0,
+      autoFetchAudienceMembership
+    });
+  }
+  const [childrenReady, setChildrenReady] = useState3(initialSdkPayload == null);
+  const [bootstrapError, setBootstrapError] = useState3(null);
+  const firstflow = firstflowRef.current;
+  const initialAppliedRef = useRef2(false);
+  useLayoutEffect(() => {
+    if (!firstflow) return;
+    if (!initialSdkPayload || initialAppliedRef.current) {
+      setChildrenReady(true);
+      return;
+    }
+    applySdkAgentPayload(firstflow, initialSdkPayload);
+    initialAppliedRef.current = true;
+    setChildrenReady(true);
+  }, [firstflow, initialSdkPayload]);
+  useEffect4(() => {
+    if (!firstflow) return;
+    if (audienceMembership) {
+      firstflow.setAudienceMembership(audienceMembership);
+    }
+  }, [firstflow, audienceMembership]);
+  useEffect4(() => {
+    if (!firstflow) {
+      return;
+    }
+    if (!apiKey?.trim()) {
+      const err = new Error(
+        "Missing `apiKey` in FirstflowProvider; remote config requires an API key."
+      );
+      setBootstrapError(err);
+      onError?.(err);
+      return;
+    }
+    const controller = new AbortController();
+    let cancelled = false;
+    setBootstrapError(null);
+    void (async () => {
+      try {
+        const payload = await fetchSdkAgentConfig(
+          firstflow.apiUrl,
+          agentId,
+          apiKey.trim()
+        );
+        if (cancelled || controller.signal.aborted) return;
+        applySdkAgentPayload(firstflow, payload);
+      } catch (error) {
+        if (cancelled || controller.signal.aborted) return;
+        const err = error instanceof Error ? error : new Error(String(error));
+        setBootstrapError(err);
+        onError?.(err);
+      } finally {
+        if (!cancelled) {
+          setChildrenReady(true);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+      controller.abort();
+    };
+  }, [agentId, apiKey, firstflow, onError]);
+  if (!firstflow || bootstrapError || !childrenReady) {
+    return /* @__PURE__ */ jsx3(Fragment2, { children: fallback });
+  }
+  const internalIssue = getInternalIssueReporter(firstflow);
+  return /* @__PURE__ */ jsx3(FirstflowContext.Provider, { value: firstflow, children: /* @__PURE__ */ jsx3(IssueReporterProvider, { reporter: internalIssue, children }) });
+}
+function useFirstflow() {
+  const ctx = useContext2(FirstflowContext);
+  if (ctx == null) {
+    throw new Error("useFirstflow must be used within FirstflowProvider");
+  }
+  return ctx;
+}
+
+export {
+  ISSUE_SUBMITTED,
+  FEEDBACK_SUBMITTED,
+  SURVEY_COMPLETED,
+  EXPERIENCE_SHOWN,
+  EXPERIENCE_CLICKED,
+  CHAT_MESSAGE_SENT,
+  EXPERIENCE_ANALYTICS_TYPE,
+  createIssueReporter,
+  EXPERIENCE_SETTINGS_DEFAULT,
+  createStorageAdapter,
+  clearFrequencyRecords,
+  markExperienceShown,
+  runEligibilityFilter,
+  fetchSdkAgentConfig,
+  FIRSTFLOW_PUBLIC_API_BASE_URL,
+  subscribeInternalRuntime,
+  getRuntimeSnapshot,
+  createFirstflow,
+  useFirstflowIssueForm,
+  styleInject,
+  IssueReporter,
+  IssueReporterProvider,
+  useIssueReporterContext,
+  FirstflowProvider,
+  useFirstflow
+};