@wireai/activation 0.1.0

package/dist/index.mjs

@@ -0,0 +1,3186 @@
+import React14, { createContext, forwardRef, useRef, useState, useEffect, useCallback, useImperativeHandle, useContext, useMemo } from 'react';
+import { useWireAIThread, useWireAIAction, ComponentRenderer, WireAIProvider } from 'wireai-rn';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { StyleSheet, Easing, Animated, BackHandler, Modal, Pressable, Text, View, TouchableOpacity, KeyboardAvoidingView, ScrollView, useWindowDimensions, TextInput, Image, AccessibilityInfo, Platform, Dimensions, I18nManager, AppState } from 'react-native';
+import { SafeAreaView } from 'react-native-safe-area-context';
+import { z } from 'zod';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/theme/defaultTheme.ts
+var defaultOnboardingTheme = {
+  colors: {
+    background: "#FFFFFF",
+    surface: "#F7F7F8",
+    text: "#101114",
+    textMuted: "#6B7280",
+    primary: "#111111",
+    onPrimary: "#FFFFFF",
+    primarySoft: "rgba(17,17,17,0.06)",
+    border: "#E4E4E7",
+    borderStrong: "#C7C7CC",
+    disabled: "#EBEBEB",
+    success: "#16A34A",
+    warning: "#D97706",
+    error: "#DC2626",
+    info: "#2563EB"
+  },
+  fonts: {
+    regular: void 0,
+    medium: void 0,
+    bold: void 0,
+    baseSize: 16,
+    scale: 1
+  },
+  radius: {
+    sm: 8,
+    md: 12,
+    lg: 16,
+    full: 9999
+  },
+  spacing: {
+    xs: 4,
+    sm: 8,
+    md: 16,
+    lg: 24,
+    xl: 32
+  },
+  // Circled (pill) CTA by default; an app can pass `button: { radius: 12 }` for
+  // a rounded rectangle, or override height/paddingX to match its design system.
+  button: {
+    radius: 9999,
+    height: 52,
+    paddingX: 24
+  }
+};
+var mergeTheme = (override) => {
+  if (!override) return defaultOnboardingTheme;
+  return {
+    colors: { ...defaultOnboardingTheme.colors, ...override.colors },
+    fonts: { ...defaultOnboardingTheme.fonts, ...override.fonts },
+    radius: { ...defaultOnboardingTheme.radius, ...override.radius },
+    spacing: { ...defaultOnboardingTheme.spacing, ...override.spacing },
+    button: { ...defaultOnboardingTheme.button, ...override.button }
+  };
+};
+var OnboardingThemeContext = createContext(null);
+var OnboardingThemeProvider = ({
+  theme,
+  children
+}) => {
+  const resolved = useMemo(() => mergeTheme(theme), [theme]);
+  return /* @__PURE__ */ jsx(OnboardingThemeContext.Provider, { value: resolved, children });
+};
+var useOnboardingTheme = () => {
+  const ctx = useContext(OnboardingThemeContext);
+  return ctx != null ? ctx : mergeTheme();
+};
+var IllustrationContext = createContext({});
+var IllustrationProvider = ({
+  registry,
+  children
+}) => /* @__PURE__ */ jsx(IllustrationContext.Provider, { value: registry != null ? registry : {}, children });
+var useIllustration = (name) => {
+  const registry = useContext(IllustrationContext);
+  if (!name) return void 0;
+  return registry[name];
+};
+var Glyph = ({ children }) => {
+  const t = useOnboardingTheme();
+  return /* @__PURE__ */ jsx(
+    View,
+    {
+      style: [
+        styles.disc,
+        { backgroundColor: t.colors.primarySoft, borderRadius: t.radius.full }
+      ],
+      children: /* @__PURE__ */ jsx(Text, { style: [styles.glyphText, { color: t.colors.primary }], allowFontScaling: false, children })
+    }
+  );
+};
+var MomentumGlyph = () => /* @__PURE__ */ jsx(Glyph, { children: "\u2197" });
+var BeforeAfterGlyph = () => {
+  const t = useOnboardingTheme();
+  return /* @__PURE__ */ jsxs(View, { style: styles.row, children: [
+    /* @__PURE__ */ jsx(
+      View,
+      {
+        style: [
+          styles.chip,
+          { borderColor: t.colors.border, borderRadius: t.radius.md }
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(Text, { style: [styles.arrow, { color: t.colors.primary }], allowFontScaling: false, children: "\u2192" }),
+    /* @__PURE__ */ jsx(
+      View,
+      {
+        style: [
+          styles.chip,
+          { backgroundColor: t.colors.primarySoft, borderColor: t.colors.primary, borderRadius: t.radius.md }
+        ]
+      }
+    )
+  ] });
+};
+var defaultIllustrations = {
+  momentum: /* @__PURE__ */ jsx(MomentumGlyph, {}),
+  "before-after": /* @__PURE__ */ jsx(BeforeAfterGlyph, {})
+};
+var styles = StyleSheet.create({
+  disc: {
+    width: 96,
+    height: 96,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  glyphText: {
+    fontSize: 44,
+    fontWeight: "700",
+    lineHeight: 52
+  },
+  row: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "center",
+    gap: 12
+  },
+  chip: {
+    width: 56,
+    height: 56,
+    borderWidth: 2
+  },
+  arrow: {
+    fontSize: 28,
+    fontWeight: "700"
+  }
+});
+
+// src/theme/typography.ts
+var round = (n) => Math.round(n);
+var bodyStyle = (f) => ({
+  fontFamily: f.regular,
+  fontSize: round(f.baseSize * f.scale),
+  lineHeight: round(f.baseSize * f.scale * 1.5)
+});
+var captionStyle = (f) => ({
+  fontFamily: f.regular,
+  fontSize: round(f.baseSize * 0.8125 * f.scale),
+  lineHeight: round(f.baseSize * 0.8125 * f.scale * 1.5)
+});
+var labelStyle = (f) => {
+  var _a;
+  return {
+    fontFamily: (_a = f.medium) != null ? _a : f.bold,
+    fontSize: round(f.baseSize * f.scale),
+    lineHeight: round(f.baseSize * f.scale * 1.4),
+    fontWeight: f.medium ? void 0 : "600"
+  };
+};
+var headingStyle = (f) => ({
+  fontFamily: f.bold,
+  fontSize: round(f.baseSize * 1.25 * f.scale),
+  lineHeight: round(f.baseSize * 1.25 * f.scale * 1.3),
+  fontWeight: f.bold ? void 0 : "700"
+});
+var buttonLabelStyle = (f) => {
+  var _a;
+  return {
+    fontFamily: (_a = f.bold) != null ? _a : f.medium,
+    fontSize: round(f.baseSize * f.scale),
+    fontWeight: f.bold ? void 0 : "600"
+  };
+};
+
+// src/motion/motionSpec.ts
+var motionSpec_exports = {};
+__export(motionSpec_exports, {
+  BUTTON_PRESS_SCALE: () => BUTTON_PRESS_SCALE,
+  BUTTON_PRESS_SPRING: () => BUTTON_PRESS_SPRING,
+  CARD_ENTER_MS: () => CARD_ENTER_MS,
+  CARD_ENTER_SCALE_FROM: () => CARD_ENTER_SCALE_FROM,
+  CARD_EXIT_LEAD_MS: () => CARD_EXIT_LEAD_MS,
+  CARD_EXIT_MS: () => CARD_EXIT_MS,
+  CARD_SLIDE_PX: () => CARD_SLIDE_PX,
+  CARD_SPRING: () => CARD_SPRING,
+  CHECK_SCALE_FROM: () => CHECK_SCALE_FROM,
+  CHECK_SPRING: () => CHECK_SPRING,
+  CHIP_FILL_MS: () => CHIP_FILL_MS,
+  CHIP_PRESS_SCALE: () => CHIP_PRESS_SCALE,
+  DURATION_BASE_MS: () => DURATION_BASE_MS,
+  DURATION_FAST_MS: () => DURATION_FAST_MS,
+  DURATION_SLOW_MS: () => DURATION_SLOW_MS,
+  INTERSTITIAL_CHECK_DELAY_MS: () => INTERSTITIAL_CHECK_DELAY_MS,
+  INTERSTITIAL_CHECK_SCALE_FROM: () => INTERSTITIAL_CHECK_SCALE_FROM,
+  INTERSTITIAL_HEAD_MS: () => INTERSTITIAL_HEAD_MS,
+  INTERSTITIAL_HEAD_STAGGER_MS: () => INTERSTITIAL_HEAD_STAGGER_MS,
+  INTERSTITIAL_ITEM_BASE_DELAY_MS: () => INTERSTITIAL_ITEM_BASE_DELAY_MS,
+  INTERSTITIAL_ITEM_MS: () => INTERSTITIAL_ITEM_MS,
+  INTERSTITIAL_ITEM_STAGGER_MS: () => INTERSTITIAL_ITEM_STAGGER_MS,
+  LOADER_HANDOFF_FADE_MS: () => LOADER_HANDOFF_FADE_MS,
+  LOADER_ORBIT_MS: () => LOADER_ORBIT_MS,
+  LOADER_PULSE_MIN_OPACITY: () => LOADER_PULSE_MIN_OPACITY,
+  LOADER_PULSE_MS: () => LOADER_PULSE_MS,
+  PRESS_SPRING: () => PRESS_SPRING,
+  PROGRESS_MS: () => PROGRESS_MS,
+  REDUCED_FADE_MS: () => REDUCED_FADE_MS,
+  REDUCED_PRESS_OPACITY: () => REDUCED_PRESS_OPACITY,
+  ROW_PRESS_SCALE: () => ROW_PRESS_SCALE,
+  SELECT_FILL_MS: () => SELECT_FILL_MS,
+  SKELETON_DELAY_MS: () => SKELETON_DELAY_MS,
+  SKELETON_MIN_OPACITY: () => SKELETON_MIN_OPACITY,
+  SKELETON_PULSE_MS: () => SKELETON_PULSE_MS,
+  STATUS_BURST_MS: () => STATUS_BURST_MS,
+  STATUS_BURST_OPACITY_FROM: () => STATUS_BURST_OPACITY_FROM,
+  STATUS_BURST_SCALE_FROM: () => STATUS_BURST_SCALE_FROM,
+  STATUS_BURST_SCALE_TO: () => STATUS_BURST_SCALE_TO,
+  STATUS_COPY_BASE_DELAY_MS: () => STATUS_COPY_BASE_DELAY_MS,
+  STATUS_COPY_MS: () => STATUS_COPY_MS,
+  STATUS_COPY_STAGGER_MS: () => STATUS_COPY_STAGGER_MS,
+  STATUS_POP_SCALE_FROM: () => STATUS_POP_SCALE_FROM,
+  STATUS_POP_SPRING: () => STATUS_POP_SPRING,
+  WIRE_BEZIER: () => WIRE_BEZIER,
+  entranceSpec: () => entranceSpec,
+  getMotionDurationScale: () => getMotionDurationScale,
+  interstitialCheckDelay: () => interstitialCheckDelay,
+  interstitialItemDelay: () => interstitialItemDelay,
+  loopEnabled: () => loopEnabled,
+  scaledMs: () => scaledMs,
+  setMotionDurationScale: () => setMotionDurationScale,
+  stateChangeDuration: () => stateChangeDuration,
+  statusCopyDelay: () => statusCopyDelay
+});
+var WIRE_BEZIER = [0.16, 1, 0.3, 1];
+var DURATION_FAST_MS = 150;
+var DURATION_BASE_MS = 300;
+var DURATION_SLOW_MS = 500;
+var REDUCED_FADE_MS = 120;
+var ROW_PRESS_SCALE = 0.975;
+var CHIP_PRESS_SCALE = 0.94;
+var BUTTON_PRESS_SCALE = 0.975;
+var REDUCED_PRESS_OPACITY = 0.85;
+var PRESS_SPRING = { friction: 8, tension: 220 };
+var BUTTON_PRESS_SPRING = { friction: 8, tension: 240 };
+var SELECT_FILL_MS = 180;
+var CHIP_FILL_MS = 160;
+var CHECK_SPRING = { friction: 6, tension: 180 };
+var CHECK_SCALE_FROM = 0.6;
+var CARD_ENTER_MS = 220;
+var CARD_EXIT_MS = 180;
+var CARD_EXIT_LEAD_MS = 80;
+var CARD_SLIDE_PX = 26;
+var CARD_ENTER_SCALE_FROM = 0.96;
+var CARD_SPRING = { damping: 14, stiffness: 180, mass: 1 };
+var LOADER_HANDOFF_FADE_MS = 120;
+var INTERSTITIAL_HEAD_MS = 500;
+var INTERSTITIAL_HEAD_STAGGER_MS = 100;
+var INTERSTITIAL_ITEM_MS = 300;
+var INTERSTITIAL_ITEM_STAGGER_MS = 90;
+var INTERSTITIAL_ITEM_BASE_DELAY_MS = 200;
+var INTERSTITIAL_CHECK_DELAY_MS = 200;
+var INTERSTITIAL_CHECK_SCALE_FROM = 0.4;
+var interstitialItemDelay = (index) => INTERSTITIAL_ITEM_BASE_DELAY_MS + index * INTERSTITIAL_ITEM_STAGGER_MS;
+var interstitialCheckDelay = (index) => interstitialItemDelay(index) + INTERSTITIAL_CHECK_DELAY_MS;
+var STATUS_POP_SPRING = { friction: 6, tension: 200 };
+var STATUS_POP_SCALE_FROM = 0.4;
+var STATUS_BURST_MS = 500;
+var STATUS_BURST_SCALE_FROM = 0.4;
+var STATUS_BURST_SCALE_TO = 1.5;
+var STATUS_BURST_OPACITY_FROM = 0.5;
+var STATUS_COPY_MS = 300;
+var STATUS_COPY_STAGGER_MS = 80;
+var STATUS_COPY_BASE_DELAY_MS = 200;
+var statusCopyDelay = (index) => STATUS_COPY_BASE_DELAY_MS + index * STATUS_COPY_STAGGER_MS;
+var LOADER_PULSE_MS = 1600;
+var LOADER_PULSE_MIN_OPACITY = 0.35;
+var LOADER_ORBIT_MS = 2400;
+var SKELETON_DELAY_MS = 300;
+var SKELETON_PULSE_MS = 1500;
+var SKELETON_MIN_OPACITY = 0.45;
+var PROGRESS_MS = 400;
+var durationScale = 1;
+var setMotionDurationScale = (scale) => {
+  durationScale = Number.isFinite(scale) && scale > 0 ? Math.min(10, Math.max(0.1, scale)) : 1;
+};
+var getMotionDurationScale = () => durationScale;
+var scaledMs = (ms) => Math.round(ms * durationScale);
+var entranceSpec = (reduced, durationMs) => reduced ? { duration: REDUCED_FADE_MS, useTransform: false } : { duration: durationMs, useTransform: true };
+var stateChangeDuration = (reduced, durationMs) => reduced ? 0 : durationMs;
+var loopEnabled = (reduced) => !reduced;
+var lastKnown = false;
+var useReducedMotion = () => {
+  const [reduced, setReduced] = useState(lastKnown);
+  useEffect(() => {
+    let mounted = true;
+    AccessibilityInfo.isReduceMotionEnabled().then((value) => {
+      lastKnown = value;
+      if (mounted) setReduced(value);
+    }).catch(() => {
+    });
+    const sub = AccessibilityInfo.addEventListener("reduceMotionChanged", (value) => {
+      lastKnown = value;
+      setReduced(value);
+    });
+    return () => {
+      mounted = false;
+      sub == null ? void 0 : sub.remove();
+    };
+  }, []);
+  return reduced;
+};
+var ROTATION_MS = 1800;
+var _AnimatedSparkle = ({ size = 30, color, variant = "spin" }) => {
+  const t = useOnboardingTheme();
+  const reduced = useReducedMotion();
+  const progress = useRef(new Animated.Value(0)).current;
+  useEffect(() => {
+    if (!loopEnabled(reduced)) {
+      progress.setValue(0);
+      return;
+    }
+    const loop = variant === "pulse" ? Animated.loop(
+      Animated.sequence([
+        Animated.timing(progress, {
+          toValue: 1,
+          duration: scaledMs(LOADER_PULSE_MS / 2),
+          easing: Easing.inOut(Easing.ease),
+          useNativeDriver: true
+        }),
+        Animated.timing(progress, {
+          toValue: 0,
+          duration: scaledMs(LOADER_PULSE_MS / 2),
+          easing: Easing.inOut(Easing.ease),
+          useNativeDriver: true
+        })
+      ])
+    ) : Animated.loop(
+      Animated.timing(progress, {
+        toValue: 1,
+        duration: scaledMs(ROTATION_MS),
+        easing: Easing.linear,
+        useNativeDriver: true
+      })
+    );
+    loop.start();
+    return () => loop.stop();
+  }, [progress, variant, reduced]);
+  const rotate = progress.interpolate({ inputRange: [0, 1], outputRange: ["0deg", "360deg"] });
+  const pulse = progress.interpolate({
+    inputRange: [0, 1],
+    outputRange: [1, LOADER_PULSE_MIN_OPACITY]
+  });
+  const animatedStyle = reduced ? void 0 : variant === "pulse" ? { opacity: pulse } : { transform: [{ rotate }] };
+  return /* @__PURE__ */ jsx(Animated.View, { style: animatedStyle, children: /* @__PURE__ */ jsx(
+    Text,
+    {
+      accessibilityElementsHidden: true,
+      importantForAccessibility: "no",
+      style: [styles2.glyph, { fontSize: size, lineHeight: size * 1.1, color: color != null ? color : t.colors.primary }],
+      children: "\u2726"
+    }
+  ) });
+};
+var AnimatedSparkle = React14.memo(_AnimatedSparkle);
+var styles2 = StyleSheet.create({
+  glyph: { textAlign: "center" }
+});
+var LoaderChromeContext = createContext({ offsetY: 0 });
+var LoaderChromeProvider = LoaderChromeContext.Provider;
+var useLoaderChrome = () => useContext(LoaderChromeContext);
+var STAGE_SIZE = 96;
+var ORBIT_DOT = 9;
+var OrbitDot = ({ color, reduced }) => {
+  const spin = useRef(new Animated.Value(0)).current;
+  useEffect(() => {
+    if (!loopEnabled(reduced)) return;
+    const loop = Animated.loop(
+      Animated.timing(spin, {
+        toValue: 1,
+        duration: scaledMs(LOADER_ORBIT_MS),
+        easing: Easing.linear,
+        useNativeDriver: true
+      })
+    );
+    loop.start();
+    return () => loop.stop();
+  }, [spin, reduced]);
+  if (reduced) return null;
+  const rotate = spin.interpolate({ inputRange: [0, 1], outputRange: ["0deg", "360deg"] });
+  return /* @__PURE__ */ jsx(Animated.View, { pointerEvents: "none", style: [StyleSheet.absoluteFill, { transform: [{ rotate }] }], children: /* @__PURE__ */ jsx(View, { style: [styles3.orbitDot, { backgroundColor: color }] }) });
+};
+var SkeletonLine = ({
+  width,
+  delay,
+  color,
+  reduced
+}) => {
+  const pulse = useRef(new Animated.Value(1)).current;
+  useEffect(() => {
+    if (!loopEnabled(reduced)) return;
+    const loop = Animated.loop(
+      Animated.sequence([
+        Animated.delay(delay),
+        Animated.timing(pulse, {
+          toValue: SKELETON_MIN_OPACITY,
+          duration: scaledMs(SKELETON_PULSE_MS / 2),
+          easing: Easing.inOut(Easing.ease),
+          useNativeDriver: true
+        }),
+        Animated.timing(pulse, {
+          toValue: 1,
+          duration: scaledMs(SKELETON_PULSE_MS / 2),
+          easing: Easing.inOut(Easing.ease),
+          useNativeDriver: true
+        })
+      ])
+    );
+    loop.start();
+    return () => loop.stop();
+  }, [pulse, delay, reduced]);
+  return /* @__PURE__ */ jsx(
+    Animated.View,
+    {
+      style: [styles3.skeletonLine, { width, backgroundColor: color, opacity: reduced ? 1 : pulse }]
+    }
+  );
+};
+var _LoadingBlock = ({
+  title = "Thinking\u2026",
+  hint = "Personalizing your experience"
+}) => {
+  const t = useOnboardingTheme();
+  const reduced = useReducedMotion();
+  const { offsetY } = useLoaderChrome();
+  const [showSkeleton, setShowSkeleton] = useState(false);
+  useEffect(() => {
+    const timer = setTimeout(() => setShowSkeleton(true), SKELETON_DELAY_MS);
+    return () => clearTimeout(timer);
+  }, []);
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      style: [
+        styles3.center,
+        { gap: t.spacing.md, padding: t.spacing.lg },
+        offsetY ? { transform: [{ translateY: offsetY }] } : null
+      ],
+      children: [
+        /* @__PURE__ */ jsxs(View, { style: styles3.stage, children: [
+          /* @__PURE__ */ jsx(View, { style: [styles3.ring, { borderColor: t.colors.border, borderRadius: t.radius.full }] }),
+          /* @__PURE__ */ jsx(OrbitDot, { color: t.colors.primary, reduced }),
+          /* @__PURE__ */ jsx(AnimatedSparkle, { size: 40, variant: "pulse" })
+        ] }),
+        title ? /* @__PURE__ */ jsx(Text, { style: [headingStyle(t.fonts), { color: t.colors.text, textAlign: "center" }], children: title }) : null,
+        hint ? /* @__PURE__ */ jsx(Text, { style: [bodyStyle(t.fonts), { color: t.colors.textMuted, textAlign: "center" }], children: hint }) : null,
+        showSkeleton ? /* @__PURE__ */ jsxs(View, { style: [styles3.skeleton, { gap: t.spacing.sm, marginTop: t.spacing.sm }], children: [
+          /* @__PURE__ */ jsx(SkeletonLine, { width: "80%", delay: 0, color: t.colors.surface, reduced }),
+          /* @__PURE__ */ jsx(SkeletonLine, { width: "60%", delay: 200, color: t.colors.surface, reduced })
+        ] }) : null
+      ]
+    }
+  );
+};
+var LoadingBlock = React14.memo(_LoadingBlock);
+var styles3 = StyleSheet.create({
+  center: { flex: 1, alignItems: "center", justifyContent: "center" },
+  stage: {
+    width: STAGE_SIZE,
+    height: STAGE_SIZE,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  ring: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    borderWidth: 1.5,
+    borderStyle: "dashed"
+  },
+  orbitDot: {
+    position: "absolute",
+    top: -ORBIT_DOT / 2 + 1,
+    left: STAGE_SIZE / 2 - ORBIT_DOT / 2,
+    width: ORBIT_DOT,
+    height: ORBIT_DOT,
+    borderRadius: ORBIT_DOT / 2
+  },
+  skeleton: { width: "100%", alignItems: "center" },
+  skeletonLine: { height: 12, borderRadius: 6 }
+});
+var _LoadingScreen = ({ title, hint }) => {
+  const t = useOnboardingTheme();
+  return /* @__PURE__ */ jsx(
+    SafeAreaView,
+    {
+      edges: ["top", "bottom"],
+      style: [styles4.flex, { backgroundColor: t.colors.background }],
+      children: /* @__PURE__ */ jsx(LoadingBlock, { title, hint })
+    }
+  );
+};
+var LoadingScreen = React14.memo(_LoadingScreen);
+var styles4 = StyleSheet.create({
+  flex: { flex: 1 }
+});
+var easeWire = Easing.bezier(...WIRE_BEZIER);
+var DECAY = 0.62;
+var MIN_FILL = 0.08;
+var APPROX_CAP = 0.95;
+var targetFor = (step, complete, approxScreens) => {
+  if (complete) return 1;
+  const s = Number.isFinite(step) && step > 0 ? Math.floor(step) : 1;
+  if (approxScreens && approxScreens > 0) {
+    return Math.max(MIN_FILL, Math.min(APPROX_CAP, s / approxScreens));
+  }
+  return Math.max(MIN_FILL, 1 - DECAY ** s);
+};
+var _StepProgress = ({ step, complete, approxScreens }) => {
+  const t = useOnboardingTheme();
+  const reduced = useReducedMotion();
+  const fill = useRef(new Animated.Value(targetFor(step, complete, approxScreens))).current;
+  useEffect(() => {
+    Animated.timing(fill, {
+      toValue: targetFor(step, complete, approxScreens),
+      duration: scaledMs(stateChangeDuration(reduced, PROGRESS_MS)),
+      easing: easeWire,
+      useNativeDriver: false
+      // animating width %
+    }).start();
+  }, [fill, step, complete, approxScreens, reduced]);
+  const width = fill.interpolate({ inputRange: [0, 1], outputRange: ["0%", "100%"] });
+  return /* @__PURE__ */ jsx(View, { style: [styles5.track, { backgroundColor: t.colors.border, borderRadius: t.radius.full }], children: /* @__PURE__ */ jsx(
+    Animated.View,
+    {
+      style: [
+        styles5.fill,
+        { width, backgroundColor: t.colors.primary, borderRadius: t.radius.full }
+      ]
+    }
+  ) });
+};
+var StepProgress = React14.memo(_StepProgress);
+var styles5 = StyleSheet.create({
+  track: { height: 6, width: "100%", overflow: "hidden" },
+  fill: { height: 6 }
+});
+var PROGRESS_TRACK = 6;
+var _OnboardingScaffold = ({
+  step,
+  complete,
+  approxScreens,
+  onBack,
+  onSkip,
+  skipLabel = "Skip",
+  backLabel = "Back",
+  children
+}) => {
+  const t = useOnboardingTheme();
+  const hit = { top: 12, bottom: 12, left: 12, right: 12 };
+  const topChrome = t.spacing.md + PROGRESS_TRACK + t.spacing.md;
+  const loaderOffsetY = -Math.round(topChrome / 2);
+  return /* @__PURE__ */ jsxs(
+    SafeAreaView,
+    {
+      edges: ["top", "bottom"],
+      style: [styles6.flex, { backgroundColor: t.colors.background }],
+      children: [
+        /* @__PURE__ */ jsxs(View, { style: [styles6.header, { paddingHorizontal: t.spacing.md, paddingTop: t.spacing.md }], children: [
+          /* @__PURE__ */ jsx(View, { style: styles6.progressWrap, children: /* @__PURE__ */ jsx(StepProgress, { step, complete, approxScreens }) }),
+          onSkip ? /* @__PURE__ */ jsx(TouchableOpacity, { onPress: onSkip, hitSlop: hit, style: { marginLeft: t.spacing.md }, children: /* @__PURE__ */ jsx(Text, { style: [bodyStyle(t.fonts), { color: t.colors.textMuted }], children: skipLabel }) }) : null
+        ] }),
+        /* @__PURE__ */ jsx(View, { style: [styles6.body, { paddingHorizontal: t.spacing.md, paddingTop: t.spacing.md }], children: /* @__PURE__ */ jsx(LoaderChromeProvider, { value: { offsetY: loaderOffsetY }, children }) }),
+        onBack ? /* @__PURE__ */ jsx(View, { style: [styles6.footer, { paddingHorizontal: t.spacing.md, paddingBottom: t.spacing.sm }], children: /* @__PURE__ */ jsx(TouchableOpacity, { onPress: onBack, hitSlop: hit, children: /* @__PURE__ */ jsx(Text, { style: [bodyStyle(t.fonts), { color: t.colors.textMuted }], children: backLabel }) }) }) : null
+      ]
+    }
+  );
+};
+var OnboardingScaffold = React14.memo(_OnboardingScaffold);
+var styles6 = StyleSheet.create({
+  flex: { flex: 1 },
+  header: { flexDirection: "row", alignItems: "center" },
+  progressWrap: { flex: 1 },
+  body: { flex: 1 },
+  footer: { flexDirection: "row", justifyContent: "flex-start" }
+});
+var _Button = ({
+  title,
+  onPress,
+  variant = "primary",
+  disabled = false,
+  fullWidth = false
+}) => {
+  const t = useOnboardingTheme();
+  const reduced = useReducedMotion();
+  const isPrimary = variant === "primary";
+  const pressT = useRef(new Animated.Value(0)).current;
+  const pressTo = useCallback(
+    (to) => {
+      if (reduced) {
+        Animated.timing(pressT, {
+          toValue: to,
+          duration: scaledMs(REDUCED_FADE_MS),
+          useNativeDriver: true
+        }).start();
+        return;
+      }
+      Animated.spring(pressT, {
+        toValue: to,
+        friction: BUTTON_PRESS_SPRING.friction,
+        tension: BUTTON_PRESS_SPRING.tension,
+        useNativeDriver: true
+      }).start();
+    },
+    [pressT, reduced]
+  );
+  const handlePressIn = useCallback(() => pressTo(1), [pressTo]);
+  const handlePressOut = useCallback(() => pressTo(0), [pressTo]);
+  const scale = pressT.interpolate({
+    inputRange: [0, 1],
+    outputRange: [1, reduced ? 1 : BUTTON_PRESS_SCALE]
+  });
+  const opacity = pressT.interpolate({
+    inputRange: [0, 1],
+    outputRange: [1, reduced ? REDUCED_PRESS_OPACITY : 1]
+  });
+  return /* @__PURE__ */ jsx(
+    Pressable,
+    {
+      onPress: disabled ? void 0 : onPress,
+      onPressIn: disabled ? void 0 : handlePressIn,
+      onPressOut: disabled ? void 0 : handlePressOut,
+      disabled,
+      accessibilityRole: "button",
+      accessibilityState: { disabled },
+      style: fullWidth ? styles7.fill : void 0,
+      children: /* @__PURE__ */ jsx(
+        Animated.View,
+        {
+          style: [
+            styles7.base,
+            fullWidth && styles7.fill,
+            {
+              borderRadius: t.button.radius,
+              minHeight: t.button.height,
+              paddingHorizontal: t.button.paddingX,
+              opacity,
+              transform: [{ scale }]
+            },
+            isPrimary ? { backgroundColor: disabled ? t.colors.disabled : t.colors.primary } : { borderWidth: 1.5, borderColor: disabled ? t.colors.border : t.colors.primary }
+          ],
+          children: /* @__PURE__ */ jsx(
+            Text,
+            {
+              style: [
+                buttonLabelStyle(t.fonts),
+                {
+                  color: disabled ? t.colors.textMuted : isPrimary ? t.colors.onPrimary : t.colors.primary
+                }
+              ],
+              children: title
+            }
+          )
+        }
+      )
+    }
+  );
+};
+var Button = React14.memo(_Button);
+var styles7 = StyleSheet.create({
+  base: { alignItems: "center", justifyContent: "center" },
+  fill: { width: "100%" }
+});
+var _ErrorBlock = ({
+  title = "Something went wrong",
+  message = "We couldn't load this step. You can try again.",
+  retryLabel = "Try again",
+  onRetry
+}) => {
+  const t = useOnboardingTheme();
+  return /* @__PURE__ */ jsxs(View, { style: [styles8.center, { gap: t.spacing.md, padding: t.spacing.lg }], children: [
+    /* @__PURE__ */ jsx(Text, { style: [headingStyle(t.fonts), { color: t.colors.text, textAlign: "center" }], children: title }),
+    /* @__PURE__ */ jsx(Text, { style: [bodyStyle(t.fonts), { color: t.colors.textMuted, textAlign: "center" }], children: message }),
+    onRetry ? /* @__PURE__ */ jsx(Button, { title: retryLabel, onPress: onRetry, variant: "outline" }) : null
+  ] });
+};
+var ErrorBlock = React14.memo(_ErrorBlock);
+var styles8 = StyleSheet.create({
+  center: { flex: 1, alignItems: "center", justifyContent: "center" }
+});
+var _CardLayout = ({
+  title,
+  subtitle,
+  children,
+  footer,
+  align = "top",
+  titleNode
+}) => {
+  const t = useOnboardingTheme();
+  const hasHeader = !!title || !!subtitle || !!titleNode;
+  return /* @__PURE__ */ jsxs(KeyboardAvoidingView, { style: styles9.fill, behavior: "padding", children: [
+    hasHeader ? /* @__PURE__ */ jsxs(View, { style: { marginBottom: t.spacing.lg }, children: [
+      titleNode != null ? titleNode : title ? /* @__PURE__ */ jsx(Text, { style: [labelStyle(t.fonts), { color: t.colors.text }], children: title }) : null,
+      subtitle ? /* @__PURE__ */ jsx(
+        Text,
+        {
+          style: [
+            bodyStyle(t.fonts),
+            { color: t.colors.textMuted, marginTop: t.spacing.xs }
+          ],
+          children: subtitle
+        }
+      ) : null
+    ] }) : null,
+    /* @__PURE__ */ jsx(
+      ScrollView,
+      {
+        style: styles9.fill,
+        contentContainerStyle: [
+          styles9.scrollContent,
+          align === "center" && styles9.center
+        ],
+        keyboardShouldPersistTaps: "handled",
+        keyboardDismissMode: "on-drag",
+        showsVerticalScrollIndicator: false,
+        children
+      }
+    ),
+    footer ? /* @__PURE__ */ jsx(View, { style: { paddingTop: t.spacing.lg }, children: footer }) : null
+  ] });
+};
+var CardLayout = React14.memo(_CardLayout);
+var styles9 = StyleSheet.create({
+  fill: { flex: 1 },
+  // flexGrow lets a short content block grow to fill (pinning the footer) while a
+  // tall one scrolls past the visible area.
+  scrollContent: { flexGrow: 1 },
+  center: { justifyContent: "center" }
+});
+var easeWire2 = Easing.bezier(...WIRE_BEZIER);
+var BADGE_SIZE = 64;
+var BURST_SIZE = 104;
+var _CompletionView = ({
+  title,
+  message,
+  ctaLabel = "Let's go",
+  onContinue
+}) => {
+  const t = useOnboardingTheme();
+  const reduced = useReducedMotion();
+  const [submitted, setSubmitted] = useState(false);
+  const pop = useRef(new Animated.Value(reduced ? 1 : 0)).current;
+  const burst = useRef(new Animated.Value(reduced ? 1 : 0)).current;
+  const titleT = useRef(new Animated.Value(reduced ? 1 : 0)).current;
+  const messageT = useRef(new Animated.Value(reduced ? 1 : 0)).current;
+  useEffect(() => {
+    if (reduced) {
+      pop.setValue(1);
+      burst.setValue(1);
+      titleT.setValue(1);
+      messageT.setValue(1);
+      return;
+    }
+    const rise = (value, delay) => Animated.timing(value, {
+      toValue: 1,
+      duration: scaledMs(STATUS_COPY_MS),
+      delay,
+      easing: easeWire2,
+      useNativeDriver: true
+    });
+    const anims = [
+      Animated.spring(pop, {
+        toValue: 1,
+        friction: STATUS_POP_SPRING.friction,
+        tension: STATUS_POP_SPRING.tension,
+        useNativeDriver: true
+      }),
+      // One-shot celebratory burst: fires once, never loops.
+      Animated.timing(burst, {
+        toValue: 1,
+        duration: scaledMs(STATUS_BURST_MS),
+        easing: Easing.out(Easing.ease),
+        useNativeDriver: true
+      }),
+      rise(titleT, scaledMs(statusCopyDelay(0))),
+      rise(messageT, scaledMs(statusCopyDelay(1)))
+    ];
+    anims.forEach((a) => a.start());
+    return () => anims.forEach((a) => a.stop());
+  }, [reduced, pop, burst, titleT, messageT]);
+  const handlePress = useCallback(() => {
+    if (submitted) return;
+    setSubmitted(true);
+    onContinue();
+  }, [submitted, onContinue]);
+  const scale = pop.interpolate({ inputRange: [0, 1], outputRange: [STATUS_POP_SCALE_FROM, 1] });
+  const burstScale = burst.interpolate({
+    inputRange: [0, 1],
+    outputRange: [STATUS_BURST_SCALE_FROM, STATUS_BURST_SCALE_TO]
+  });
+  const burstOpacity = burst.interpolate({
+    inputRange: [0, 1],
+    outputRange: [STATUS_BURST_OPACITY_FROM, 0]
+  });
+  const riseStyle = (value) => ({
+    opacity: value,
+    transform: [{ translateY: value.interpolate({ inputRange: [0, 1], outputRange: [10, 0] }) }]
+  });
+  return /* @__PURE__ */ jsx(
+    CardLayout,
+    {
+      align: "center",
+      footer: /* @__PURE__ */ jsx(Button, { title: ctaLabel, onPress: handlePress, variant: "primary", disabled: submitted }),
+      children: /* @__PURE__ */ jsxs(View, { style: [styles10.center, { gap: t.spacing.md }], children: [
+        /* @__PURE__ */ jsxs(View, { style: styles10.badgeStage, children: [
+          /* @__PURE__ */ jsx(
+            Animated.View,
+            {
+              pointerEvents: "none",
+              style: [
+                styles10.burst,
+                {
+                  backgroundColor: t.colors.primarySoft,
+                  borderRadius: t.radius.full,
+                  opacity: burstOpacity,
+                  transform: [{ scale: burstScale }]
+                }
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Animated.View,
+            {
+              style: [
+                styles10.badge,
+                {
+                  backgroundColor: t.colors.primarySoft,
+                  borderRadius: t.radius.full,
+                  transform: [{ scale }],
+                  opacity: pop
+                }
+              ],
+              children: /* @__PURE__ */ jsx(Text, { style: [styles10.check, { color: t.colors.primary }], children: "\u2713" })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(Animated.View, { style: riseStyle(titleT), children: /* @__PURE__ */ jsx(Text, { style: [headingStyle(t.fonts), { color: t.colors.text, textAlign: "center" }], children: title }) }),
+        message ? /* @__PURE__ */ jsx(Animated.View, { style: riseStyle(messageT), children: /* @__PURE__ */ jsx(Text, { style: [bodyStyle(t.fonts), { color: t.colors.textMuted, textAlign: "center" }], children: message }) }) : null
+      ] })
+    }
+  );
+};
+var CompletionView = React14.memo(_CompletionView);
+var styles10 = StyleSheet.create({
+  center: { width: "100%", alignItems: "center", justifyContent: "center" },
+  badgeStage: {
+    width: BURST_SIZE,
+    height: BURST_SIZE,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  burst: { position: "absolute", width: BURST_SIZE, height: BURST_SIZE },
+  badge: { width: BADGE_SIZE, height: BADGE_SIZE, alignItems: "center", justifyContent: "center" },
+  check: { fontSize: 34, fontWeight: "800" }
+});
+var easeWire3 = Easing.bezier(...WIRE_BEZIER);
+var _CardHandoff = ({
+  transitionKey,
+  variant = "slide",
+  children
+}) => {
+  const reduced = useReducedMotion();
+  const [leaving, setLeaving] = useState(null);
+  const enterT = useRef(new Animated.Value(0)).current;
+  const exitT = useRef(new Animated.Value(0)).current;
+  const prev = useRef({ key: transitionKey, node: children, variant });
+  const [enterVariant, setEnterVariant] = useState(variant);
+  const running = useRef({});
+  const mounted = useRef(false);
+  useEffect(() => {
+    var _a, _b;
+    const last = prev.current;
+    prev.current = { key: transitionKey, node: children, variant };
+    if (!mounted.current) {
+      mounted.current = true;
+      setEnterVariant(variant);
+      running.current.enter = startEnter(enterT, variant, reduced, 0);
+      return;
+    }
+    if (last.key === transitionKey) return;
+    (_a = running.current.enter) == null ? void 0 : _a.stop();
+    (_b = running.current.exit) == null ? void 0 : _b.stop();
+    setLeaving(last);
+    setEnterVariant(variant);
+    enterT.setValue(0);
+    exitT.setValue(0);
+    const exitDuration = reduced ? REDUCED_FADE_MS : last.variant === "fade" ? LOADER_HANDOFF_FADE_MS : CARD_EXIT_MS;
+    const exit = Animated.timing(exitT, {
+      toValue: 1,
+      duration: scaledMs(exitDuration),
+      easing: easeWire3,
+      useNativeDriver: true
+    });
+    running.current.exit = exit;
+    exit.start();
+    const enter = startEnter(
+      enterT,
+      variant,
+      reduced,
+      reduced ? 0 : CARD_EXIT_LEAD_MS,
+      () => setLeaving(null)
+    );
+    running.current.enter = enter;
+  });
+  useEffect(
+    () => () => {
+      var _a, _b;
+      (_a = running.current.enter) == null ? void 0 : _a.stop();
+      (_b = running.current.exit) == null ? void 0 : _b.stop();
+    },
+    []
+  );
+  const enterStyle = {
+    opacity: enterT,
+    transform: transformFor(enterVariant, enterT, reduced, "enter")
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    leaving ? /* @__PURE__ */ jsx(
+      Animated.View,
+      {
+        pointerEvents: "none",
+        style: [
+          StyleSheet.absoluteFill,
+          {
+            opacity: exitT.interpolate({ inputRange: [0, 1], outputRange: [1, 0] }),
+            transform: transformFor(leaving.variant, exitT, reduced, "exit")
+          }
+        ],
+        children: leaving.node
+      }
+    ) : null,
+    /* @__PURE__ */ jsx(Animated.View, { style: [styles11.fill, enterStyle], children })
+  ] });
+};
+var startEnter = (value, variant, reduced, delay, onDone) => {
+  value.setValue(0);
+  const anim = !reduced && variant === "spring" ? Animated.spring(value, {
+    toValue: 1,
+    delay: scaledMs(delay),
+    damping: CARD_SPRING.damping,
+    stiffness: CARD_SPRING.stiffness,
+    mass: CARD_SPRING.mass,
+    useNativeDriver: true
+  }) : Animated.timing(value, {
+    toValue: 1,
+    delay: scaledMs(delay),
+    duration: scaledMs(
+      reduced ? REDUCED_FADE_MS : variant === "fade" ? LOADER_HANDOFF_FADE_MS : CARD_ENTER_MS
+    ),
+    easing: easeWire3,
+    useNativeDriver: true
+  });
+  anim.start(({ finished }) => {
+    if (finished) onDone == null ? void 0 : onDone();
+  });
+  return anim;
+};
+var transformFor = (variant, t, reduced, direction) => {
+  if (reduced || variant === "fade") return [];
+  if (variant === "spring" && direction === "enter") {
+    return [{ scale: t.interpolate({ inputRange: [0, 1], outputRange: [CARD_ENTER_SCALE_FROM, 1] }) }];
+  }
+  return [
+    {
+      translateX: t.interpolate({
+        inputRange: [0, 1],
+        outputRange: direction === "enter" ? [CARD_SLIDE_PX, 0] : [0, -CARD_SLIDE_PX]
+      })
+    }
+  ];
+};
+var CardHandoff = React14.memo(_CardHandoff);
+var styles11 = StyleSheet.create({
+  fill: { flex: 1 }
+});
+
+// src/utils/deriveAnswers.ts
+var stripPrefix = (s) => s.replace(/^(I selected:|My answer is:|I tapped:)\s*/i, "").trim();
+var tryParse = (s) => {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return s;
+  }
+};
+var deriveAnswers = (messages) => {
+  var _a, _b, _c;
+  const out = {};
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    const r = m == null ? void 0 : m.response;
+    if (!m || m.role !== "assistant" || !r || r.action !== "render") continue;
+    const props = (_a = r.props) != null ? _a : {};
+    const progress = props.progress;
+    const questionText = (_c = (_b = props.title) != null ? _b : props.label) != null ? _c : props.question;
+    const key = (progress == null ? void 0 : progress.key) || questionText;
+    const reply = messages[i + 1];
+    if (key && (reply == null ? void 0 : reply.role) === "user") {
+      out[key] = tryParse(stripPrefix(reply.content));
+    }
+  }
+  return out;
+};
+
+// src/utils/readProgress.ts
+var readProgress = (response) => {
+  var _a;
+  if (!response || response.action !== "render") return {};
+  const props = (_a = response.props) != null ? _a : {};
+  const raw = props.progress;
+  if (!raw || typeof raw !== "object") return {};
+  const p = raw;
+  return {
+    step: typeof p.step === "number" ? p.step : void 0,
+    total: typeof p.total === "number" ? p.total : void 0,
+    key: typeof p.key === "string" ? p.key : void 0,
+    skippable: typeof p.skippable === "boolean" ? p.skippable : void 0
+  };
+};
+
+// src/analytics/reportClientEvent.ts
+var makeSessionId = () => `wire_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+var reportClientEvents = (target, events) => {
+  if (!(target == null ? void 0 : target.serverUrl) || events.length === 0) return;
+  try {
+    const url = `${target.serverUrl.replace(/\/$/, "")}/v1/events`;
+    const headers = { "Content-Type": "application/json" };
+    if (target.apiKey) headers.Authorization = `Bearer ${target.apiKey}`;
+    void fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ events })
+    }).catch(() => {
+    });
+  } catch {
+  }
+};
+var reportClientEvent = (target, event) => reportClientEvents(target, [event]);
+
+// src/analytics/sendPreview.ts
+var sendPreview = (target, { sessionId, userMessage }) => {
+  if (!(target == null ? void 0 : target.serverUrl)) return;
+  try {
+    const url = `${target.serverUrl.replace(/\/$/, "")}/a2a`;
+    const headers = { "Content-Type": "application/json" };
+    if (target.apiKey) headers.Authorization = `Bearer ${target.apiKey}`;
+    void fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: Math.floor(Math.random() * 1e9),
+        method: "message/preview",
+        params: {
+          message: { role: "user", parts: [{ text: userMessage }] },
+          contextId: sessionId,
+          metadata: { sessionId }
+        }
+      })
+    }).catch(() => {
+    });
+  } catch {
+  }
+};
+var SKIP_ONE_SENTINEL = "__wireai_skip__";
+var ANSWER_CALLBACKS = ["onSubmit", "onSelect", "onConfirm", "onPress"];
+var DEFAULT_COPY = {
+  startingTitle: "Getting started\u2026",
+  startingHint: "Setting up your onboarding",
+  restoringTitle: "Picking up where you left off\u2026",
+  restoringHint: "Restoring your session",
+  thinkingTitle: "Personalizing\u2026",
+  thinkingHint: "Tailoring your next question",
+  checkingTitle: "Checking\u2026",
+  checkingHint: "One moment",
+  completeTitle: "You're all set",
+  completeCta: "Let's go"
+};
+var OnboardingFlow = ({
+  validators,
+  onComplete,
+  onError,
+  onEvent,
+  copy,
+  approxScreens,
+  startMessage,
+  startTimeoutMs,
+  fallbackFlow,
+  maxRetries,
+  reportTarget,
+  sessionId,
+  resumed = false,
+  clientContext
+}) => {
+  var _a, _b, _c, _d, _e, _f;
+  const { messages, error, isLoading, sendMessage, reset } = useWireAIThread();
+  const makeActions = useWireAIAction(sendMessage);
+  const c = useMemo(() => ({ ...DEFAULT_COPY, ...copy }), [copy]);
+  const onEventRef = useRef(onEvent);
+  onEventRef.current = onEvent;
+  const onErrorRef = useRef(onError);
+  onErrorRef.current = onError;
+  const reportTargetRef = useRef(reportTarget);
+  reportTargetRef.current = reportTarget;
+  const sessionIdRef = useRef(sessionId);
+  sessionIdRef.current = sessionId;
+  const clientContextRef = useRef(clientContext);
+  clientContextRef.current = clientContext;
+  const lastScreenIndexRef = useRef(-1);
+  const previewTimer = useRef(null);
+  const started = useRef(false);
+  const finished = useRef(false);
+  const errored = useRef(false);
+  const attempts = useRef(0);
+  const degradedRef = useRef(false);
+  const [degraded, setDegraded] = useState(false);
+  const [timedOut, setTimedOut] = useState(false);
+  const [validationError, setValidationError] = useState();
+  const [validating, setValidating] = useState(false);
+  const lastCard = useMemo(
+    () => [...messages].reverse().find((m) => {
+      var _a2;
+      return m.role === "assistant" && ((_a2 = m.response) == null ? void 0 : _a2.action) === "render";
+    }),
+    [messages]
+  );
+  const renderedCount = useMemo(
+    () => messages.filter((m) => {
+      var _a2;
+      return m.role === "assistant" && ((_a2 = m.response) == null ? void 0 : _a2.action) === "render";
+    }).length,
+    [messages]
+  );
+  const progress = useMemo(() => readProgress(lastCard == null ? void 0 : lastCard.response), [lastCard]);
+  useEffect(() => {
+    var _a2;
+    if (started.current) return;
+    started.current = true;
+    sendMessage(resumed ? SKIP_ONE_SENTINEL : startMessage);
+    (_a2 = onEventRef.current) == null ? void 0 : _a2.call(
+      onEventRef,
+      resumed ? { type: "resumed", contextId: sessionId } : { type: "started", contextId: sessionId }
+    );
+  }, [sendMessage, startMessage, resumed, sessionId]);
+  useEffect(() => {
+    if (lastCard) return;
+    const timer = setTimeout(() => setTimedOut(true), startTimeoutMs);
+    return () => clearTimeout(timer);
+  }, [lastCard, startTimeoutMs]);
+  useEffect(() => {
+    var _a2, _b2, _c2, _d2;
+    setValidationError(void 0);
+    if (!(lastCard == null ? void 0 : lastCard.id)) return;
+    const step2 = (_a2 = progress.step) != null ? _a2 : renderedCount;
+    lastScreenIndexRef.current = Math.max(0, step2 - 1);
+    (_c2 = onEventRef.current) == null ? void 0 : _c2.call(onEventRef, {
+      type: "turn",
+      step: step2,
+      component: (_b2 = lastCard.response) == null ? void 0 : _b2.component
+    });
+    if (((_d2 = lastCard.response) == null ? void 0 : _d2.component) === "InterstitialCard") {
+      sendPreview(reportTargetRef.current, {
+        sessionId: sessionIdRef.current,
+        userMessage: `My answer is: ${JSON.stringify("continue")}`
+      });
+    }
+  }, [lastCard == null ? void 0 : lastCard.id]);
+  useEffect(() => {
+    return () => {
+      var _a2, _b2, _c2;
+      if (finished.current || degradedRef.current) return;
+      reportClientEvent(reportTargetRef.current, {
+        event_type: "dropped",
+        session_id: sessionIdRef.current,
+        screen_index: lastScreenIndexRef.current >= 0 ? lastScreenIndexRef.current : void 0,
+        device: (_a2 = clientContextRef.current) == null ? void 0 : _a2.device,
+        user_context: (_b2 = clientContextRef.current) == null ? void 0 : _b2.userContext,
+        user_id: (_c2 = clientContextRef.current) == null ? void 0 : _c2.userId
+      });
+    };
+  }, []);
+  const restartThread = useCallback(() => {
+    setTimedOut(false);
+    started.current = false;
+    errored.current = false;
+    reset();
+  }, [reset]);
+  useEffect(() => {
+    var _a2, _b2, _c2, _d2, _e2, _f2, _g;
+    if (errored.current) return;
+    if (!error && !timedOut) return;
+    errored.current = true;
+    const reason = error ? "backend" : "timeout";
+    (_a2 = onEventRef.current) == null ? void 0 : _a2.call(onEventRef, { type: "error", reason });
+    attempts.current += 1;
+    if (attempts.current <= maxRetries) {
+      (_b2 = onEventRef.current) == null ? void 0 : _b2.call(onEventRef, { type: "retry", reason, attempt: attempts.current });
+      restartThread();
+    } else {
+      (_c2 = onEventRef.current) == null ? void 0 : _c2.call(onEventRef, { type: "fallback", reason });
+      reportClientEvent(reportTargetRef.current, {
+        event_type: "client_fallback",
+        session_id: sessionIdRef.current,
+        screen_index: lastScreenIndexRef.current >= 0 ? lastScreenIndexRef.current : void 0,
+        meta: JSON.stringify({ reason }),
+        device: (_d2 = clientContextRef.current) == null ? void 0 : _d2.device,
+        user_context: (_e2 = clientContextRef.current) == null ? void 0 : _e2.userContext,
+        user_id: (_f2 = clientContextRef.current) == null ? void 0 : _f2.userId
+      });
+      degradedRef.current = true;
+      setDegraded(true);
+      (_g = onErrorRef.current) == null ? void 0 : _g.call(onErrorRef, error != null ? error : new Error("Onboarding timed out"));
+    }
+  }, [error, timedOut, maxRetries]);
+  const handleFinish = useCallback(() => {
+    if (finished.current) return;
+    finished.current = true;
+    onComplete({ answers: deriveAnswers(messages), raw: messages });
+  }, [messages, onComplete]);
+  const handleRetry = useCallback(() => {
+    attempts.current = 0;
+    degradedRef.current = false;
+    setDegraded(false);
+    restartThread();
+  }, [restartThread]);
+  const skipQuestion = useCallback(() => {
+    if (isLoading) return;
+    sendMessage(SKIP_ONE_SENTINEL);
+  }, [isLoading, sendMessage]);
+  const previewOnSelect = useCallback((value) => {
+    const target = reportTargetRef.current;
+    if (!(target == null ? void 0 : target.serverUrl)) return;
+    if (Array.isArray(value) ? value.length === 0 : !value) return;
+    if (previewTimer.current) clearTimeout(previewTimer.current);
+    previewTimer.current = setTimeout(() => {
+      sendPreview(target, {
+        sessionId: sessionIdRef.current,
+        userMessage: `I selected: ${JSON.stringify(value)}`
+      });
+    }, 300);
+  }, []);
+  useEffect(() => () => {
+    if (previewTimer.current) clearTimeout(previewTimer.current);
+  }, []);
+  const wrappedActions = useCallback(
+    (messageId) => {
+      const base = makeActions(messageId);
+      const key = progress.key;
+      const validator = key ? validators == null ? void 0 : validators[key] : void 0;
+      if (!validator) return base;
+      const out = { ...base };
+      for (const name of ANSWER_CALLBACKS) {
+        const original = base[name];
+        if (!original) continue;
+        out[name] = (...args) => {
+          const value = args[0];
+          if (typeof value !== "string") return original(...args);
+          setValidating(true);
+          validator(value).then((res) => {
+            var _a2;
+            if (res.ok) {
+              setValidationError(void 0);
+              original(...args);
+            } else {
+              setValidationError((_a2 = res.error) != null ? _a2 : "That value isn't available.");
+            }
+          }).catch(() => {
+            original(...args);
+          }).finally(() => setValidating(false));
+        };
+      }
+      return out;
+    },
+    [makeActions, progress.key, validators]
+  );
+  if (degraded) {
+    if (fallbackFlow !== void 0) return /* @__PURE__ */ jsx(Fragment, { children: fallbackFlow });
+    if (onError) {
+      return /* @__PURE__ */ jsx(LoadingScreen, { title: c.startingTitle, hint: c.startingHint });
+    }
+    return /* @__PURE__ */ jsx(
+      ErrorBlock,
+      {
+        onRetry: handleRetry,
+        message: timedOut ? "This is taking longer than expected. Try again?" : "We couldn't reach the onboarding service. Try again?"
+      }
+    );
+  }
+  if (error || timedOut) {
+    return /* @__PURE__ */ jsx(LoadingScreen, { title: c.startingTitle, hint: c.startingHint });
+  }
+  const response = lastCard == null ? void 0 : lastCard.response;
+  if (!lastCard || !response) {
+    return /* @__PURE__ */ jsx(LoadingScreen, { title: c.startingTitle, hint: c.startingHint });
+  }
+  const step = (_a = progress.step) != null ? _a : renderedCount;
+  const total = (_b = progress.total) != null ? _b : approxScreens;
+  const isTerminal = response.action === "render" && response.component === "StatusCard";
+  if (isTerminal) {
+    const props = (_c = response.props) != null ? _c : {};
+    return /* @__PURE__ */ jsx(OnboardingScaffold, { step, complete: true, approxScreens: total, children: /* @__PURE__ */ jsx(
+      CompletionView,
+      {
+        title: (_d = props.title) != null ? _d : c.completeTitle,
+        message: props.message,
+        ctaLabel: (_e = props.ctaLabel) != null ? _e : c.completeCta,
+        onContinue: handleFinish
+      }
+    ) });
+  }
+  const overrides = {
+    ...wrappedActions(lastCard.id),
+    // Inject the inline error onto whichever card supports it (TextInputCard).
+    validationError,
+    // Choice cards (Selection/ChipSelect) call this as the live selection changes, so the flow
+    // can prefetch the next turn before Continue. Non-committing; ignored by cards that don't use it.
+    onSelectionChange: previewOnSelect
+  };
+  return /* @__PURE__ */ jsx(
+    OnboardingScaffold,
+    {
+      step,
+      onSkip: progress.skippable ? skipQuestion : void 0,
+      approxScreens: total,
+      children: /* @__PURE__ */ jsx(
+        CardHandoff,
+        {
+          transitionKey: validating ? "loader:checking" : isLoading ? "loader:thinking" : lastCard.id,
+          variant: validating || isLoading ? "fade" : ((_f = lastCard.response) == null ? void 0 : _f.component) === "InterstitialCard" ? "spring" : "slide",
+          children: validating ? /* @__PURE__ */ jsx(LoadingBlock, { title: c.checkingTitle, hint: c.checkingHint }) : isLoading ? (
+            // Between turns: the answer was sent and we're waiting on the next card.
+            // Show the "thinking" loader instead of leaving the old card on screen.
+            /* @__PURE__ */ jsx(LoadingBlock, { title: c.thinkingTitle, hint: c.thinkingHint })
+          ) : (
+            // key={lastCard.id} is load-bearing: cards (SelectionCard/ChipSelectCard)
+            // hold internal `selected`/`submitted` state, and React reuses a component
+            // instance across turns when the rendered type is identical (e.g. two
+            // SelectionCards in a row). Without a per-turn key the second card inherits
+            // the first's `submitted=true` and silently rejects all taps. Keying on the
+            // message id forces a fresh mount every turn. (CardHandoff's transitionKey
+            // shares the id, but this renderer key stays the state-isolation guarantee.)
+            /* @__PURE__ */ jsx(
+              ComponentRenderer,
+              {
+                messageId: lastCard.id,
+                response,
+                callbackOverrides: overrides
+              },
+              lastCard.id
+            )
+          )
+        }
+      )
+    }
+  );
+};
+var easeWire4 = Easing.bezier(...WIRE_BEZIER);
+var schema = z.object({
+  title: z.string().describe("Question or section header, e.g. 'Which season?'"),
+  chips: z.array(z.string()).min(1).describe("List of option labels shown as chips, e.g. ['Spring','Summer','Autumn','Winter']"),
+  multiSelect: z.boolean().optional().describe("Allow multiple chips selected at once, default true"),
+  submitLabel: z.string().optional().describe("Confirm button label, default: Continue"),
+  maxSelections: z.number().optional().describe("Maximum number of chips the user can select at once")
+});
+var _ChipItem = ({ chip, isSelected, multiSelect, onToggle }) => {
+  const t = useOnboardingTheme();
+  const reduced = useReducedMotion();
+  const handlePress = useCallback(() => onToggle(chip), [chip, onToggle]);
+  const pressScale = useRef(new Animated.Value(1)).current;
+  const pressTo = useCallback(
+    (to) => {
+      if (reduced) return;
+      Animated.spring(pressScale, {
+        toValue: to,
+        friction: PRESS_SPRING.friction,
+        tension: PRESS_SPRING.tension,
+        useNativeDriver: true
+      }).start();
+    },
+    [pressScale, reduced]
+  );
+  const handlePressIn = useCallback(() => pressTo(CHIP_PRESS_SCALE), [pressTo]);
+  const handlePressOut = useCallback(() => pressTo(1), [pressTo]);
+  const fillT = useRef(new Animated.Value(isSelected ? 1 : 0)).current;
+  useEffect(() => {
+    const anim = Animated.timing(fillT, {
+      toValue: isSelected ? 1 : 0,
+      duration: scaledMs(stateChangeDuration(reduced, CHIP_FILL_MS)),
+      easing: easeWire4,
+      useNativeDriver: true
+    });
+    anim.start();
+    return () => anim.stop();
+  }, [isSelected, reduced, fillT]);
+  const checkT = useRef(new Animated.Value(isSelected ? 1 : 0)).current;
+  useEffect(() => {
+    if (!isSelected) {
+      checkT.setValue(0);
+      return;
+    }
+    if (reduced) {
+      checkT.setValue(1);
+      return;
+    }
+    checkT.setValue(0);
+    const anim = Animated.spring(checkT, {
+      toValue: 1,
+      friction: CHECK_SPRING.friction,
+      tension: CHECK_SPRING.tension,
+      useNativeDriver: true
+    });
+    anim.start();
+    return () => anim.stop();
+  }, [isSelected, reduced, checkT]);
+  const checkScale = checkT.interpolate({ inputRange: [0, 1], outputRange: [CHECK_SCALE_FROM, 1] });
+  return /* @__PURE__ */ jsx(
+    Pressable,
+    {
+      onPress: handlePress,
+      onPressIn: handlePressIn,
+      onPressOut: handlePressOut,
+      accessibilityRole: multiSelect ? "checkbox" : "radio",
+      accessibilityState: multiSelect ? { checked: isSelected } : { selected: isSelected },
+      accessibilityLabel: chip,
+      children: /* @__PURE__ */ jsxs(
+        Animated.View,
+        {
+          style: [
+            styles12.chip,
+            {
+              borderRadius: t.radius.full,
+              paddingHorizontal: t.spacing.md,
+              paddingVertical: t.spacing.sm,
+              borderColor: t.colors.border,
+              backgroundColor: t.colors.background,
+              transform: [{ scale: pressScale }]
+            }
+          ],
+          children: [
+            /* @__PURE__ */ jsx(
+              Animated.View,
+              {
+                pointerEvents: "none",
+                style: [
+                  StyleSheet.absoluteFill,
+                  styles12.fillOverlay,
+                  {
+                    borderRadius: t.radius.full,
+                    borderColor: t.colors.primary,
+                    backgroundColor: t.colors.primary,
+                    opacity: fillT
+                  }
+                ]
+              }
+            ),
+            isSelected ? /* @__PURE__ */ jsx(
+              Animated.Text,
+              {
+                style: [
+                  styles12.check,
+                  { color: t.colors.onPrimary, opacity: checkT, transform: [{ scale: checkScale }] }
+                ],
+                children: "\u2713"
+              }
+            ) : null,
+            /* @__PURE__ */ jsx(
+              Text,
+              {
+                style: [
+                  captionStyle(t.fonts),
+                  styles12.chipLabel,
+                  { color: isSelected ? t.colors.onPrimary : t.colors.textMuted }
+                ],
+                children: chip
+              }
+            )
+          ]
+        }
+      )
+    }
+  );
+};
+var ChipItem = React14.memo(_ChipItem);
+var _ChipSelectCard = ({
+  title,
+  chips,
+  multiSelect = true,
+  submitLabel = "Continue",
+  maxSelections,
+  onSelect,
+  onSelectionChange
+}) => {
+  const t = useOnboardingTheme();
+  const [selected, setSelected] = useState([]);
+  const [submitted, setSubmitted] = useState(false);
+  useEffect(() => {
+    if (!submitted && selected.length) onSelectionChange == null ? void 0 : onSelectionChange(multiSelect ? selected : selected[0]);
+  }, [selected, submitted, multiSelect, onSelectionChange]);
+  const toggle = useCallback(
+    (chip) => {
+      if (submitted) return;
+      if (multiSelect) {
+        setSelected((prev) => {
+          if (prev.includes(chip)) return prev.filter((c) => c !== chip);
+          if (maxSelections && prev.length >= maxSelections) return prev;
+          return [...prev, chip];
+        });
+      } else {
+        setSelected([chip]);
+      }
+    },
+    [submitted, multiSelect, maxSelections]
+  );
+  const handleSubmit = useCallback(() => {
+    if (!selected.length || !onSelect || submitted) return;
+    setSubmitted(true);
+    onSelect(multiSelect ? selected : selected[0]);
+  }, [selected, onSelect, submitted, multiSelect]);
+  return /* @__PURE__ */ jsx(
+    CardLayout,
+    {
+      title,
+      subtitle: maxSelections ? `Select up to ${maxSelections}` : void 0,
+      footer: /* @__PURE__ */ jsx(
+        Button,
+        {
+          title: submitLabel,
+          onPress: handleSubmit,
+          variant: "primary",
+          disabled: selected.length === 0 || submitted
+        }
+      ),
+      children: /* @__PURE__ */ jsx(View, { style: [styles12.chipsRow, { gap: t.spacing.sm + t.spacing.xs }], children: chips.map((chip) => /* @__PURE__ */ jsx(
+        ChipItem,
+        {
+          chip,
+          isSelected: selected.includes(chip),
+          multiSelect,
+          onToggle: toggle
+        },
+        chip
+      )) })
+    }
+  );
+};
+var ChipSelectCard = {
+  name: "ChipSelectCard",
+  description: "Use for compact short labels: seasons, activities, travel styles, moods, categories. Ideal for 4\u201312 single-word or two-word options. Use SelectionCard instead when options need descriptions.",
+  component: React14.memo(_ChipSelectCard),
+  propsSchema: schema,
+  defaultProps: { multiSelect: true, submitLabel: "Continue" }
+};
+var styles12 = StyleSheet.create({
+  chipsRow: { flexDirection: "row", flexWrap: "wrap" },
+  chip: { borderWidth: 1.5, flexDirection: "row", alignItems: "center", gap: 6, overflow: "hidden" },
+  fillOverlay: { borderWidth: 1.5 },
+  chipLabel: { fontWeight: "600" },
+  check: { fontSize: 13, fontWeight: "800", lineHeight: 15 }
+});
+var schema2 = z.object({
+  label: z.string().describe("Input field label / the question being asked"),
+  hint: z.string().optional().describe(
+    "One short line under the question giving context: what the answer is used for or why you ask. Add it whenever the question alone might be unclear."
+  ),
+  placeholder: z.string().optional().describe(
+    'A concrete example answer shown inside the box, phrased like a real user wrote it and starting with "e.g. ". ALWAYS provide one for open-ended questions: it shows the expected answer shape and inspires the user.'
+  ),
+  submitLabel: z.string().optional().describe("Submit button label, default: Submit"),
+  multiline: z.boolean().optional().describe(
+    "Tall multi-line box for open-ended answers (goals, notes, feedback). Default true. Set false for a single-line field like a name or username."
+  ),
+  lines: z.number().optional().describe("Approx visible rows when multiline (default 6). Height is capped at 40% of the screen.")
+});
+var _TextInputCard = ({
+  label,
+  hint,
+  placeholder,
+  submitLabel = "Submit",
+  onSubmit,
+  validationError,
+  multiline = true,
+  lines = 6
+}) => {
+  const t = useOnboardingTheme();
+  const { height: screenHeight } = useWindowDimensions();
+  const [value, setValue] = useState("");
+  const [submitted, setSubmitted] = useState(false);
+  const locked = submitted && !validationError;
+  const APPROX_ROW_HEIGHT = 26;
+  const minHeight = multiline ? Math.min(Math.max(lines, 4) * APPROX_ROW_HEIGHT + t.spacing.md * 2, screenHeight * 0.4) : 52;
+  const handleSubmit = useCallback(() => {
+    if (value.trim() && onSubmit && !locked) {
+      setSubmitted(true);
+      onSubmit(value.trim());
+    }
+  }, [value, onSubmit, locked]);
+  return /* @__PURE__ */ jsx(
+    CardLayout,
+    {
+      title: label,
+      subtitle: hint,
+      footer: /* @__PURE__ */ jsx(
+        Button,
+        {
+          title: submitLabel,
+          onPress: handleSubmit,
+          variant: "primary",
+          disabled: !value.trim() || locked
+        }
+      ),
+      children: /* @__PURE__ */ jsxs(View, { style: { gap: t.spacing.sm }, children: [
+        /* @__PURE__ */ jsx(
+          TextInput,
+          {
+            value,
+            onChangeText: setValue,
+            placeholder: placeholder != null ? placeholder : "",
+            placeholderTextColor: t.colors.textMuted,
+            editable: !locked,
+            multiline,
+            numberOfLines: multiline ? lines : 1,
+            textAlignVertical: multiline ? "top" : "center",
+            style: [
+              bodyStyle(t.fonts),
+              styles13.input,
+              {
+                color: t.colors.text,
+                backgroundColor: t.colors.surface,
+                borderRadius: t.radius.md,
+                borderColor: validationError ? t.colors.error : t.colors.border,
+                padding: t.spacing.md,
+                minHeight
+              }
+            ]
+          }
+        ),
+        validationError ? /* @__PURE__ */ jsx(Text, { style: [captionStyle(t.fonts), { color: t.colors.error }], children: validationError }) : null
+      ] })
+    }
+  );
+};
+var TextInputCard = {
+  name: "TextInputCard",
+  description: "Use when the user needs to type a free-text answer: an open-ended goal, notes, feedback, a name, a destination, a search query. Multi-line by default (great for open-ended goals); set multiline:false for a short single-line field like a name. Use NumberStepperCard for numeric ranges with known bounds.",
+  component: React14.memo(_TextInputCard),
+  propsSchema: schema2,
+  defaultProps: { submitLabel: "Submit", multiline: true, lines: 6 }
+};
+var styles13 = StyleSheet.create({
+  input: { borderWidth: 1 }
+});
+var easeWire5 = Easing.bezier(...WIRE_BEZIER);
+var optionObjectSchema = z.object({
+  value: z.string().describe("Option value"),
+  label: z.string().describe("Option display label")
+});
+var schema3 = z.object({
+  title: z.string().describe("Question or prompt for the user"),
+  options: z.preprocess(
+    (arr) => Array.isArray(arr) ? arr.map((item) => typeof item === "string" ? { value: item, label: item } : item) : arr,
+    z.array(optionObjectSchema).min(1)
+  ).describe("List of choices"),
+  submitLabel: z.string().optional().describe("Submit button label, default: Continue"),
+  multiSelect: z.boolean().optional().describe("Allow multiple selections")
+});
+var _OptionRow = ({ opt, isSelected, multiSelect, onToggle }) => {
+  const t = useOnboardingTheme();
+  const reduced = useReducedMotion();
+  const handlePress = useCallback(() => onToggle(opt.value), [opt.value, onToggle]);
+  const pressScale = useRef(new Animated.Value(1)).current;
+  const pressTo = useCallback(
+    (to) => {
+      if (reduced) return;
+      Animated.spring(pressScale, {
+        toValue: to,
+        friction: PRESS_SPRING.friction,
+        tension: PRESS_SPRING.tension,
+        useNativeDriver: true
+      }).start();
+    },
+    [pressScale, reduced]
+  );
+  const handlePressIn = useCallback(() => pressTo(ROW_PRESS_SCALE), [pressTo]);
+  const handlePressOut = useCallback(() => pressTo(1), [pressTo]);
+  const selectT = useRef(new Animated.Value(isSelected ? 1 : 0)).current;
+  useEffect(() => {
+    const anim = Animated.timing(selectT, {
+      toValue: isSelected ? 1 : 0,
+      duration: scaledMs(stateChangeDuration(reduced, SELECT_FILL_MS)),
+      easing: easeWire5,
+      useNativeDriver: true
+    });
+    anim.start();
+    return () => anim.stop();
+  }, [isSelected, reduced, selectT]);
+  const checkT = useRef(new Animated.Value(isSelected ? 1 : 0)).current;
+  useEffect(() => {
+    if (!isSelected) {
+      checkT.setValue(0);
+      return;
+    }
+    if (reduced) {
+      checkT.setValue(1);
+      return;
+    }
+    checkT.setValue(0);
+    const anim = Animated.spring(checkT, {
+      toValue: 1,
+      friction: CHECK_SPRING.friction,
+      tension: CHECK_SPRING.tension,
+      useNativeDriver: true
+    });
+    anim.start();
+    return () => anim.stop();
+  }, [isSelected, reduced, checkT]);
+  const checkScale = checkT.interpolate({ inputRange: [0, 1], outputRange: [CHECK_SCALE_FROM, 1] });
+  return /* @__PURE__ */ jsx(
+    Pressable,
+    {
+      onPress: handlePress,
+      onPressIn: handlePressIn,
+      onPressOut: handlePressOut,
+      accessibilityRole: multiSelect ? "checkbox" : "radio",
+      accessibilityState: multiSelect ? { checked: isSelected } : { selected: isSelected },
+      accessibilityLabel: opt.label,
+      children: /* @__PURE__ */ jsxs(
+        Animated.View,
+        {
+          style: [
+            styles14.option,
+            {
+              padding: t.spacing.md,
+              borderRadius: t.radius.md,
+              gap: t.spacing.sm,
+              borderColor: t.colors.border,
+              backgroundColor: t.colors.background,
+              transform: [{ scale: pressScale }]
+            }
+          ],
+          children: [
+            /* @__PURE__ */ jsx(
+              Animated.View,
+              {
+                pointerEvents: "none",
+                style: [
+                  StyleSheet.absoluteFill,
+                  styles14.selectedOverlay,
+                  {
+                    borderRadius: t.radius.md,
+                    borderColor: t.colors.primary,
+                    backgroundColor: t.colors.primarySoft,
+                    opacity: selectT
+                  }
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              View,
+              {
+                style: [
+                  styles14.indicator,
+                  { borderRadius: t.radius.full },
+                  isSelected ? { borderColor: t.colors.primary, backgroundColor: t.colors.primary } : { borderColor: t.colors.borderStrong, backgroundColor: "transparent" }
+                ],
+                children: isSelected ? /* @__PURE__ */ jsx(
+                  Animated.Text,
+                  {
+                    style: [
+                      styles14.check,
+                      { color: t.colors.onPrimary, opacity: checkT, transform: [{ scale: checkScale }] }
+                    ],
+                    children: "\u2713"
+                  }
+                ) : null
+              }
+            ),
+            /* @__PURE__ */ jsx(Text, { style: [labelStyle(t.fonts), { color: t.colors.text }], children: opt.label })
+          ]
+        }
+      )
+    }
+  );
+};
+var OptionRow = React14.memo(_OptionRow);
+var _SelectionCard = ({
+  title,
+  options,
+  submitLabel = "Continue",
+  multiSelect = false,
+  onSelect,
+  onSelectionChange
+}) => {
+  const t = useOnboardingTheme();
+  const [selected, setSelected] = useState([]);
+  const [submitted, setSubmitted] = useState(false);
+  useEffect(() => {
+    if (!submitted && selected.length) onSelectionChange == null ? void 0 : onSelectionChange(multiSelect ? selected : selected[0]);
+  }, [selected, submitted, multiSelect, onSelectionChange]);
+  const toggle = useCallback(
+    (value) => {
+      if (submitted) return;
+      if (multiSelect) {
+        setSelected((prev) => prev.includes(value) ? prev.filter((v) => v !== value) : [...prev, value]);
+      } else {
+        setSelected([value]);
+      }
+    },
+    [submitted, multiSelect]
+  );
+  const handleSubmit = useCallback(() => {
+    if (!selected.length || !onSelect || submitted) return;
+    setSubmitted(true);
+    onSelect(multiSelect ? selected : selected[0]);
+  }, [selected, onSelect, submitted, multiSelect]);
+  return /* @__PURE__ */ jsx(
+    CardLayout,
+    {
+      title,
+      footer: /* @__PURE__ */ jsx(
+        Button,
+        {
+          title: submitLabel,
+          onPress: handleSubmit,
+          variant: "primary",
+          disabled: selected.length === 0 || submitted
+        }
+      ),
+      children: /* @__PURE__ */ jsx(View, { style: { gap: t.spacing.sm + t.spacing.xs }, children: options.map((opt) => /* @__PURE__ */ jsx(
+        OptionRow,
+        {
+          opt,
+          isSelected: selected.includes(opt.value),
+          multiSelect,
+          onToggle: toggle
+        },
+        opt.value
+      )) })
+    }
+  );
+};
+var SelectionCard = {
+  name: "SelectionCard",
+  description: "Use for mutually exclusive (radio) or multi-select (checkbox) choices from 2\u20138 options. Use ChipSelectCard instead when options are short single words.",
+  component: React14.memo(_SelectionCard),
+  propsSchema: schema3,
+  defaultProps: { submitLabel: "Continue", multiSelect: false }
+};
+var styles14 = StyleSheet.create({
+  option: { borderWidth: 1.5, flexDirection: "row", alignItems: "center", overflow: "hidden" },
+  selectedOverlay: { borderWidth: 1.5 },
+  indicator: { width: 24, height: 24, borderWidth: 2, alignItems: "center", justifyContent: "center" },
+  check: { fontSize: 13, fontWeight: "800", lineHeight: 15 }
+});
+var easeWire6 = Easing.bezier(...WIRE_BEZIER);
+var schema4 = z.object({
+  status: z.enum(["success", "warning", "error", "info"]).describe("Status type"),
+  title: z.string().describe("Status title"),
+  message: z.string().optional().describe("Supporting message"),
+  ctaLabel: z.string().optional().describe(
+    "Optional call-to-action button label. Always include this on success status to keep the conversation going."
+  )
+});
+var STATUS_ICONS = {
+  success: "\u2713",
+  warning: "\u26A0",
+  error: "\u2717",
+  info: "\u2139"
+};
+var _StatusCard = ({ status, title, message, ctaLabel, onContinue, onPress, onSubmit }) => {
+  var _a, _b;
+  const t = useOnboardingTheme();
+  const reduced = useReducedMotion();
+  const [submitted, setSubmitted] = useState(false);
+  const colorFor = {
+    success: t.colors.success,
+    warning: t.colors.warning,
+    error: t.colors.error,
+    info: t.colors.info
+  };
+  const color = (_a = colorFor[status]) != null ? _a : t.colors.info;
+  const popT = useRef(new Animated.Value(reduced ? 1 : 0)).current;
+  const copyT = useRef(new Animated.Value(reduced ? 1 : 0)).current;
+  useEffect(() => {
+    if (reduced) {
+      popT.setValue(1);
+      copyT.setValue(1);
+      return;
+    }
+    const anims = [
+      Animated.spring(popT, {
+        toValue: 1,
+        friction: STATUS_POP_SPRING.friction,
+        tension: STATUS_POP_SPRING.tension,
+        useNativeDriver: true
+      }),
+      Animated.timing(copyT, {
+        toValue: 1,
+        duration: scaledMs(STATUS_COPY_MS),
+        delay: scaledMs(STATUS_COPY_STAGGER_MS),
+        easing: easeWire6,
+        useNativeDriver: true
+      })
+    ];
+    anims.forEach((a) => a.start());
+    return () => anims.forEach((a) => a.stop());
+  }, [reduced, popT, copyT]);
+  const popScale = popT.interpolate({ inputRange: [0, 1], outputRange: [STATUS_POP_SCALE_FROM, 1] });
+  const copyRise = copyT.interpolate({ inputRange: [0, 1], outputRange: [10, 0] });
+  const handleContinue = useCallback(() => {
+    if (!submitted) {
+      setSubmitted(true);
+      if (onContinue) onContinue();
+      else if (onPress && ctaLabel) onPress(ctaLabel);
+      else if (onSubmit) onSubmit("continue");
+    }
+  }, [submitted, onContinue, onPress, onSubmit, ctaLabel]);
+  return /* @__PURE__ */ jsx(
+    CardLayout,
+    {
+      align: "center",
+      footer: ctaLabel ? /* @__PURE__ */ jsx(Button, { title: ctaLabel, onPress: handleContinue, variant: "primary", disabled: submitted }) : void 0,
+      children: /* @__PURE__ */ jsxs(View, { style: [styles15.center, { gap: t.spacing.sm }], children: [
+        /* @__PURE__ */ jsxs(View, { style: [styles15.titleRow, { gap: t.spacing.sm }], children: [
+          /* @__PURE__ */ jsx(
+            Animated.Text,
+            {
+              style: [
+                headingStyle(t.fonts),
+                { color, opacity: popT, transform: [{ scale: popScale }] }
+              ],
+              children: (_b = STATUS_ICONS[status]) != null ? _b : "\xB7"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Animated.Text,
+            {
+              style: [
+                headingStyle(t.fonts),
+                { color, textAlign: "center", opacity: copyT, transform: [{ translateY: copyRise }] }
+              ],
+              children: title
+            }
+          )
+        ] }),
+        message ? /* @__PURE__ */ jsx(
+          Animated.Text,
+          {
+            style: [
+              bodyStyle(t.fonts),
+              {
+                color: t.colors.textMuted,
+                textAlign: "center",
+                opacity: copyT,
+                transform: [{ translateY: copyRise }]
+              }
+            ],
+            children: message
+          }
+        ) : null
+      ] })
+    }
+  );
+};
+var StatusCard = {
+  name: "StatusCard",
+  description: "Use ONLY for real outcomes: booking confirmed, data saved, action completed. NEVER for 'you just viewed X' acknowledgments. Always include ctaLabel so the user can continue after seeing the status.",
+  component: React14.memo(_StatusCard),
+  propsSchema: schema4
+};
+var styles15 = StyleSheet.create({
+  center: { width: "100%", alignItems: "center", justifyContent: "center" },
+  titleRow: { flexDirection: "row", alignItems: "center", justifyContent: "center" }
+});
+var schema5 = z.object({
+  label: z.string().describe("What is being counted, e.g. 'Number of days' or 'Travellers'"),
+  min: z.number().optional().describe("Minimum value, default 1"),
+  max: z.number().optional().describe("Maximum value, default 30"),
+  defaultValue: z.number().optional().describe("Starting value"),
+  step: z.number().optional().describe("Increment per tap, default 1"),
+  unit: z.string().optional().describe("Unit label shown next to value, e.g. 'days' or 'people'"),
+  submitLabel: z.string().optional().describe("Confirm button label, default: Confirm")
+});
+var safeNum = (n, fallback) => typeof n === "number" && Number.isFinite(n) ? n : fallback;
+var _NumberStepperCard = ({
+  label,
+  min,
+  max,
+  defaultValue,
+  step,
+  unit,
+  submitLabel = "Confirm",
+  onSubmit
+}) => {
+  const t = useOnboardingTheme();
+  const safeMin = safeNum(min, 1);
+  const safeMaxRaw = safeNum(max, 30);
+  const safeMax = safeMaxRaw < safeMin ? safeMin : safeMaxRaw;
+  const safeStepRaw = safeNum(step, 1);
+  const safeStep = safeStepRaw > 0 ? safeStepRaw : 1;
+  const safeDefault = safeNum(defaultValue, safeMin);
+  const [value, setValue] = useState(Math.min(Math.max(safeDefault, safeMin), safeMax));
+  const [submitted, setSubmitted] = useState(false);
+  const handleDecrement = useCallback(() => {
+    if (!submitted) setValue((v) => Math.max(v - safeStep, safeMin));
+  }, [submitted, safeStep, safeMin]);
+  const handleIncrement = useCallback(() => {
+    if (!submitted) setValue((v) => Math.min(v + safeStep, safeMax));
+  }, [submitted, safeStep, safeMax]);
+  const handleSubmit = useCallback(() => {
+    if (!submitted) {
+      setSubmitted(true);
+      onSubmit == null ? void 0 : onSubmit(value);
+    }
+  }, [submitted, onSubmit, value]);
+  const atMin = value <= safeMin;
+  const atMax = value >= safeMax;
+  const stepBtnStyle = (disabled) => [
+    styles16.stepBtn,
+    { borderRadius: t.radius.full, backgroundColor: t.colors.background, borderColor: disabled ? t.colors.border : t.colors.primary }
+  ];
+  return /* @__PURE__ */ jsx(
+    CardLayout,
+    {
+      title: label,
+      align: "center",
+      footer: /* @__PURE__ */ jsx(Button, { title: submitLabel, onPress: handleSubmit, variant: "primary", disabled: submitted }),
+      children: /* @__PURE__ */ jsxs(View, { style: { gap: t.spacing.md, alignItems: "center" }, children: [
+        /* @__PURE__ */ jsxs(View, { style: [styles16.stepper, { gap: t.spacing.lg }], children: [
+          /* @__PURE__ */ jsx(Pressable, { onPress: atMin || submitted ? void 0 : handleDecrement, disabled: atMin || submitted, style: stepBtnStyle(atMin), children: /* @__PURE__ */ jsx(Text, { style: [headingStyle(t.fonts), { color: atMin ? t.colors.textMuted : t.colors.primary }], children: "\u2212" }) }),
+          /* @__PURE__ */ jsxs(View, { style: styles16.valueBox, children: [
+            /* @__PURE__ */ jsx(Text, { style: [headingStyle(t.fonts), { color: t.colors.primary }], children: String(value) }),
+            unit ? /* @__PURE__ */ jsx(Text, { style: [captionStyle(t.fonts), { color: t.colors.textMuted }], children: unit }) : null
+          ] }),
+          /* @__PURE__ */ jsx(Pressable, { onPress: atMax || submitted ? void 0 : handleIncrement, disabled: atMax || submitted, style: stepBtnStyle(atMax), children: /* @__PURE__ */ jsx(Text, { style: [headingStyle(t.fonts), { color: atMax ? t.colors.textMuted : t.colors.primary }], children: "+" }) })
+        ] }),
+        /* @__PURE__ */ jsx(Text, { style: [captionStyle(t.fonts), { color: t.colors.textMuted, textAlign: "center" }], children: `${safeMin} \u2013 ${safeMax}${unit ? ` ${unit}` : ""}` })
+      ] })
+    }
+  );
+};
+var NumberStepperCard = {
+  name: "NumberStepperCard",
+  description: "Use for any bounded numeric input: days, people, portions, budget tiers, ratings. Best for ranges 1\u201399. Set unit (e.g. 'days', 'people') for clarity.",
+  component: React14.memo(_NumberStepperCard),
+  propsSchema: schema5,
+  defaultProps: { min: 1, max: 30, defaultValue: 1, step: 1, submitLabel: "Confirm" }
+};
+var styles16 = StyleSheet.create({
+  stepper: { flexDirection: "row", alignItems: "center", justifyContent: "center" },
+  stepBtn: { width: 44, height: 44, borderWidth: 2, alignItems: "center", justifyContent: "center" },
+  valueBox: { alignItems: "center", minWidth: 80 }
+});
+var easeWire7 = Easing.bezier(...WIRE_BEZIER);
+var RISE_PX = 10;
+var schema6 = z.object({
+  title: z.string().describe("Short, warm headline for the value/momentum moment"),
+  body: z.string().optional().describe("One or two supporting lines that reflect the user's answers back and build momentum"),
+  items: z.array(z.string()).max(4).optional().describe(
+    "2-3 very short 'work being done' lines that each reference something the user already answered (e.g. 'Sized for a small team'). Shown as ticked items appearing in sequence. Prefer these over `body` when you have concrete answers to reflect back."
+  ),
+  illustration: z.string().optional().describe(
+    "Name of an app-provided illustration to show (the app's registry decides the artwork). Prefer this over imageUrl."
+  ),
+  imageUrl: z.string().url().refine((v) => v.startsWith("https://"), "imageUrl must be an https URL").optional().describe(
+    "Fallback remote HTTPS image URL, used only when no named illustration is registered. A non-https or malformed value is rejected and degrades to the named-illustration fallback."
+  ),
+  illustrationFallback: z.string().optional().describe(
+    "Named illustration to show when neither `illustration` nor `imageUrl` resolves (or the image fails to load). Defaults to the kit's always-present 'momentum' art so the screen is never blank."
+  ),
+  ctaLabel: z.string().optional().describe("Continue button label, default: Continue")
+});
+var MIN_DISPLAY_MS = 500;
+var _WorkItem = ({
+  text,
+  index,
+  reduced
+}) => {
+  const t = useOnboardingTheme();
+  const rowT = useRef(new Animated.Value(reduced ? 1 : 0)).current;
+  const checkT = useRef(new Animated.Value(reduced ? 1 : 0)).current;
+  useEffect(() => {
+    if (reduced) {
+      rowT.setValue(1);
+      checkT.setValue(1);
+      return;
+    }
+    const anims = [
+      Animated.timing(rowT, {
+        toValue: 1,
+        duration: scaledMs(INTERSTITIAL_ITEM_MS),
+        delay: scaledMs(interstitialItemDelay(index)),
+        easing: easeWire7,
+        useNativeDriver: true
+      }),
+      Animated.spring(checkT, {
+        toValue: 1,
+        delay: scaledMs(interstitialCheckDelay(index)),
+        friction: CHECK_SPRING.friction,
+        tension: CHECK_SPRING.tension,
+        useNativeDriver: true
+      })
+    ];
+    anims.forEach((a) => a.start());
+    return () => anims.forEach((a) => a.stop());
+  }, [reduced, index, rowT, checkT]);
+  const rise = rowT.interpolate({ inputRange: [0, 1], outputRange: [RISE_PX, 0] });
+  const checkScale = checkT.interpolate({
+    inputRange: [0, 1],
+    outputRange: [INTERSTITIAL_CHECK_SCALE_FROM, 1]
+  });
+  return /* @__PURE__ */ jsxs(
+    Animated.View,
+    {
+      style: [styles17.itemRow, { gap: t.spacing.sm + t.spacing.xs, opacity: rowT, transform: [{ translateY: rise }] }],
+      children: [
+        /* @__PURE__ */ jsx(
+          View,
+          {
+            style: [
+              styles17.itemBadge,
+              { backgroundColor: t.colors.primarySoft, borderRadius: t.radius.full }
+            ],
+            children: /* @__PURE__ */ jsx(
+              Animated.Text,
+              {
+                style: [
+                  styles17.itemCheck,
+                  { color: t.colors.primary, opacity: checkT, transform: [{ scale: checkScale }] }
+                ],
+                children: "\u2713"
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx(Text, { style: [bodyStyle(t.fonts), styles17.itemText, { color: t.colors.text }], children: text })
+      ]
+    }
+  );
+};
+var WorkItem = React14.memo(_WorkItem);
+var _InterstitialCard = ({
+  title,
+  body,
+  items,
+  illustration,
+  imageUrl,
+  illustrationFallback,
+  ctaLabel = "Continue",
+  onSubmit,
+  onPress
+}) => {
+  const t = useOnboardingTheme();
+  const reduced = useReducedMotion();
+  const node = useIllustration(illustration);
+  const fallbackNode = useIllustration(illustrationFallback);
+  const [submitted, setSubmitted] = useState(false);
+  const [imgFailed, setImgFailed] = useState(false);
+  const [canAdvance, setCanAdvance] = useState(false);
+  useEffect(() => {
+    const timer = setTimeout(() => setCanAdvance(true), MIN_DISPLAY_MS);
+    return () => clearTimeout(timer);
+  }, []);
+  const artT = useRef(new Animated.Value(reduced ? 1 : 0)).current;
+  const titleT = useRef(new Animated.Value(reduced ? 1 : 0)).current;
+  const bodyT = useRef(new Animated.Value(reduced ? 1 : 0)).current;
+  useEffect(() => {
+    if (reduced) {
+      artT.setValue(1);
+      titleT.setValue(1);
+      bodyT.setValue(1);
+      return;
+    }
+    const rise = (value, delay) => Animated.timing(value, {
+      toValue: 1,
+      duration: scaledMs(INTERSTITIAL_HEAD_MS),
+      delay,
+      easing: easeWire7,
+      useNativeDriver: true
+    });
+    const anims = [
+      rise(artT, 0),
+      rise(titleT, scaledMs(INTERSTITIAL_HEAD_STAGGER_MS)),
+      rise(bodyT, scaledMs(INTERSTITIAL_HEAD_STAGGER_MS * 2))
+    ];
+    anims.forEach((a) => a.start());
+    return () => anims.forEach((a) => a.stop());
+  }, [reduced, artT, titleT, bodyT]);
+  const riseStyle = (value) => ({
+    opacity: value,
+    transform: [{ translateY: value.interpolate({ inputRange: [0, 1], outputRange: [RISE_PX, 0] }) }]
+  });
+  const handleContinue = useCallback(() => {
+    if (submitted || !canAdvance) return;
+    setSubmitted(true);
+    if (onSubmit) onSubmit("continue");
+    else if (onPress) onPress(ctaLabel);
+  }, [submitted, canAdvance, onSubmit, onPress, ctaLabel]);
+  const showImage = !node && !!imageUrl && !imgFailed;
+  const art = node != null ? node : showImage ? void 0 : fallbackNode;
+  return /* @__PURE__ */ jsx(
+    CardLayout,
+    {
+      align: "center",
+      footer: /* @__PURE__ */ jsx(
+        Button,
+        {
+          title: ctaLabel,
+          onPress: handleContinue,
+          variant: "primary",
+          disabled: submitted || !canAdvance
+        }
+      ),
+      children: /* @__PURE__ */ jsxs(View, { style: [styles17.center, { gap: t.spacing.md }], children: [
+        /* @__PURE__ */ jsx(Animated.View, { style: [styles17.fullWidth, riseStyle(artT)], children: showImage ? /* @__PURE__ */ jsx(
+          Image,
+          {
+            source: { uri: imageUrl },
+            style: styles17.image,
+            resizeMode: "contain",
+            onError: () => setImgFailed(true)
+          }
+        ) : art ? /* @__PURE__ */ jsx(View, { style: styles17.art, children: art }) : null }),
+        /* @__PURE__ */ jsx(Animated.View, { style: riseStyle(titleT), children: /* @__PURE__ */ jsx(Text, { style: [headingStyle(t.fonts), { color: t.colors.text, textAlign: "center" }], children: title }) }),
+        (items == null ? void 0 : items.length) ? /* @__PURE__ */ jsx(View, { style: [styles17.items, { gap: t.spacing.md, marginTop: t.spacing.sm }], children: items.map((item, i) => /* @__PURE__ */ jsx(WorkItem, { text: item, index: i, reduced }, item)) }) : body ? /* @__PURE__ */ jsx(Animated.View, { style: riseStyle(bodyT), children: /* @__PURE__ */ jsx(Text, { style: [bodyStyle(t.fonts), { color: t.colors.textMuted, textAlign: "center" }], children: body }) }) : null
+      ] })
+    }
+  );
+};
+var InterstitialCard = {
+  name: "InterstitialCard",
+  description: "Use ONCE mid-flow (never first, never last) as a momentum/value screen between questions \u2014 an illustration + a warm line that reflects answers back, like Duolingo/Cal-AI. NOT a question; the user just taps Continue. Set `illustration` to an app-registered artwork name. Prefer `items` (2-3 short ticked lines, each reflecting a real answer) when you have the signal. Skip it if you don't have enough signal to make the line specific.",
+  component: React14.memo(_InterstitialCard),
+  propsSchema: schema6,
+  defaultProps: { ctaLabel: "Continue", illustrationFallback: "momentum" }
+};
+var styles17 = StyleSheet.create({
+  center: { width: "100%", alignItems: "center", justifyContent: "center" },
+  fullWidth: { width: "100%", alignItems: "center" },
+  art: { alignItems: "center", justifyContent: "center" },
+  image: { width: "100%", height: 200 },
+  items: { width: "100%", alignSelf: "stretch" },
+  itemRow: { flexDirection: "row", alignItems: "center" },
+  itemBadge: { width: 24, height: 24, alignItems: "center", justifyContent: "center" },
+  itemCheck: { fontSize: 13, fontWeight: "800", lineHeight: 15 },
+  itemText: { flex: 1 }
+});
+
+// src/cards/index.ts
+var onboardingComponents = [
+  ChipSelectCard,
+  TextInputCard,
+  SelectionCard,
+  StatusCard,
+  NumberStepperCard,
+  InterstitialCard
+];
+var deriveFormFactor = (iosIdiom, width, height) => {
+  if (iosIdiom === "pad") return "tablet";
+  if (iosIdiom === "phone") return "phone";
+  if (typeof width === "number" && typeof height === "number") {
+    return Math.min(width, height) >= 600 ? "tablet" : "phone";
+  }
+  return void 0;
+};
+var collectDeviceContext = () => {
+  var _a;
+  const ctx = { platform: Platform.OS };
+  try {
+    const version = Platform.Version;
+    if (version !== void 0 && version !== null && String(version)) {
+      ctx.osVersion = String(version);
+    }
+  } catch {
+  }
+  let constants = {};
+  try {
+    constants = (_a = Platform.constants) != null ? _a : {};
+  } catch {
+    constants = {};
+  }
+  let iosIdiom;
+  try {
+    if (Platform.OS === "android") {
+      const brand = constants.Brand;
+      const model = constants.Model;
+      const release = constants.Release;
+      if (typeof brand === "string" && brand) ctx.brand = brand;
+      if (typeof model === "string" && model) ctx.model = model;
+      if (release !== void 0 && release !== null && String(release)) {
+        ctx.osVersion = String(release);
+      }
+    } else if (Platform.OS === "ios") {
+      const osVersion = constants.osVersion;
+      const idiom = constants.interfaceIdiom;
+      if (osVersion !== void 0 && osVersion !== null && String(osVersion)) {
+        ctx.osVersion = String(osVersion);
+      }
+      if (typeof idiom === "string" && idiom) {
+        ctx.interfaceIdiom = idiom;
+        iosIdiom = idiom;
+      }
+    }
+  } catch {
+  }
+  try {
+    const screen = Dimensions.get("screen");
+    if (screen) {
+      if (typeof screen.width === "number") ctx.screenWidth = screen.width;
+      if (typeof screen.height === "number") ctx.screenHeight = screen.height;
+      if (typeof screen.scale === "number") ctx.screenScale = screen.scale;
+      const formFactor = deriveFormFactor(iosIdiom, screen.width, screen.height);
+      if (formFactor) ctx.formFactor = formFactor;
+    }
+  } catch {
+  }
+  try {
+    ctx.isRTL = I18nManager.isRTL;
+  } catch {
+  }
+  try {
+    const resolved = Intl.DateTimeFormat().resolvedOptions();
+    if (resolved.locale) ctx.locale = resolved.locale;
+    if (resolved.timeZone) ctx.timeZone = resolved.timeZone;
+  } catch {
+  }
+  return ctx;
+};
+
+// src/session/persistedSession.ts
+var DEFAULT_SESSION_TTL_MS = 36e5;
+var READ_TIMEOUT_MS = 1500;
+var sessionStorageKey = (appId) => `wireai:session:${appId}`;
+var withTimeout = (p, ms) => {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(void 0), ms);
+  });
+  return Promise.race([p, timeout]).finally(() => clearTimeout(timer));
+};
+var parsePersisted = (raw) => {
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.id === "string" && typeof parsed.ts === "number") {
+      return parsed;
+    }
+  } catch {
+  }
+  return void 0;
+};
+var loadPersistedSession = async (storage, key, ttlMs = DEFAULT_SESSION_TTL_MS) => {
+  let stored;
+  try {
+    stored = parsePersisted(await withTimeout(storage.getItem(key), READ_TIMEOUT_MS));
+  } catch {
+    stored = void 0;
+  }
+  if (stored && Date.now() - stored.ts < ttlMs) {
+    return { id: stored.id, resumed: true };
+  }
+  const id = makeSessionId();
+  savePersistedSession(storage, key, id);
+  return { id, resumed: false };
+};
+var peekPersistedSession = async (storage, key) => {
+  try {
+    return parsePersisted(await withTimeout(storage.getItem(key), READ_TIMEOUT_MS));
+  } catch {
+    return void 0;
+  }
+};
+var savePersistedSession = (storage, key, id) => {
+  try {
+    void storage.setItem(key, JSON.stringify({ id, ts: Date.now() })).catch(() => {
+    });
+  } catch {
+  }
+};
+var clearPersistedSession = (storage, key) => {
+  try {
+    void storage.removeItem(key).catch(() => {
+    });
+  } catch {
+  }
+};
+
+// src/identity/userIdentity.ts
+var USER_ID_MAX_LENGTH = 128;
+var sanitizeUserId = (raw) => {
+  if (typeof raw !== "string") return void 0;
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  return trimmed.length > USER_ID_MAX_LENGTH ? trimmed.slice(0, USER_ID_MAX_LENGTH) : trimmed;
+};
+var identifyOnboarding = async (opts) => {
+  var _a, _b, _c;
+  const userId = sanitizeUserId(opts.userId);
+  if (!userId || !((_a = opts.config) == null ? void 0 : _a.serverUrl)) return false;
+  let contextId = ((_b = opts.contextId) == null ? void 0 : _b.trim()) || void 0;
+  if (!contextId && opts.storage) {
+    const key = (_c = opts.persistKey) != null ? _c : opts.appId ? sessionStorageKey(opts.appId) : void 0;
+    if (key) {
+      const stored = await peekPersistedSession(opts.storage, key);
+      contextId = stored == null ? void 0 : stored.id;
+    }
+  }
+  if (!contextId) return false;
+  reportClientEvent(
+    { serverUrl: opts.config.serverUrl, apiKey: opts.config.apiKey },
+    { event_type: "identify", session_id: contextId, user_id: userId }
+  );
+  return true;
+};
+var WireOnboarding = ({
+  config,
+  theme,
+  components,
+  illustrations,
+  validators,
+  onComplete,
+  onSkip,
+  onError,
+  onEvent,
+  copy,
+  approxScreens,
+  startMessage = "start",
+  startTimeoutMs = 15e3,
+  fallbackFlow,
+  maxRetries = 1,
+  storage,
+  sessionTtlMs = DEFAULT_SESSION_TTL_MS,
+  persistKey,
+  userContext,
+  userId
+}) => {
+  var _a, _b, _c;
+  const boundUserId = useMemo(() => sanitizeUserId(userId), [userId]);
+  const device = useMemo(() => {
+    const collected = collectDeviceContext();
+    return config.appVersion ? { ...collected, appVersion: config.appVersion } : collected;
+  }, [config.appVersion]);
+  const userContextKey = userContext ? JSON.stringify(userContext) : "";
+  const userContextStable = useMemo(
+    () => userContextKey ? JSON.parse(userContextKey) : void 0,
+    [userContextKey]
+  );
+  const clientContext = useMemo(
+    () => ({ device, userContext: userContextStable, userId: boundUserId }),
+    [device, userContextStable, boundUserId]
+  );
+  const [session, setSession] = useState(
+    () => storage ? null : { id: makeSessionId(), resumed: false }
+  );
+  const storageKey = persistKey != null ? persistKey : sessionStorageKey(config.appId);
+  useEffect(() => {
+    if (!storage || session) return;
+    let cancelled = false;
+    void loadPersistedSession(storage, storageKey, sessionTtlMs).then((loaded) => {
+      if (!cancelled) setSession(loaded);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [storage, storageKey, sessionTtlMs, session]);
+  const handleComplete = useCallback(
+    (result) => {
+      if (storage) clearPersistedSession(storage, storageKey);
+      onComplete(result);
+    },
+    [storage, storageKey, onComplete]
+  );
+  const sessionId = (_a = session == null ? void 0 : session.id) != null ? _a : "";
+  const startupUserIdRef = useRef(boundUserId);
+  const llm = useMemo(() => {
+    const baseUrl = config.serverUrl.replace(/\/$/, "");
+    return {
+      provider: "a2a",
+      baseUrl: `${baseUrl}/a2a`,
+      model: config.appId,
+      apiKey: config.apiKey,
+      // Carry the kit session id alongside any host attribution so it reaches the A2A
+      // request's `params.metadata` (the correlation seed; see note above), plus the
+      // names of the components this device can actually render — so the backend only
+      // emits cards the kit knows how to draw.
+      metadata: {
+        ...config.metadata,
+        sessionId,
+        supportedComponents: (components != null ? components : onboardingComponents).map((c) => c.name),
+        // Device snapshot + host-injected user context ride the session-start metadata so the
+        // backend can segment the funnel. Old servers ignore these unknown keys (backward compat).
+        device,
+        ...userContextStable ? { userContext: userContextStable } : {},
+        // The session-start user id (from the ref) rides the session-start metadata so the
+        // server binds the session to a real user at creation. Reading the ref — not
+        // `boundUserId` — keeps this memo off the userId dependency, so a mid-session change
+        // does NOT recreate the adapter; it's bound by the `identify` effect below instead.
+        ...startupUserIdRef.current ? { userId: startupUserIdRef.current } : {}
+      },
+      timeoutMs: 6e4
+    };
+  }, [config.serverUrl, config.appId, config.apiKey, config.metadata, sessionId, components, device, userContextStable]);
+  const reportTarget = useMemo(
+    () => ({ serverUrl: config.serverUrl, apiKey: config.apiKey }),
+    [config.serverUrl, config.apiKey]
+  );
+  const identifiedRef = useRef(void 0);
+  const identifySeededRef = useRef(false);
+  useEffect(() => {
+    if (!session || !sessionId) return;
+    if (!identifySeededRef.current) {
+      identifySeededRef.current = true;
+      identifiedRef.current = session.resumed ? void 0 : boundUserId;
+    }
+    if (!boundUserId || boundUserId === identifiedRef.current) return;
+    identifiedRef.current = boundUserId;
+    reportClientEvent(reportTarget, {
+      event_type: "identify",
+      session_id: sessionId,
+      user_id: boundUserId
+    });
+  }, [session, sessionId, boundUserId, reportTarget]);
+  const cards = components != null ? components : onboardingComponents;
+  if (!session) {
+    return /* @__PURE__ */ jsx(OnboardingThemeProvider, { theme, children: /* @__PURE__ */ jsx(
+      LoadingScreen,
+      {
+        title: (_b = copy == null ? void 0 : copy.restoringTitle) != null ? _b : DEFAULT_COPY.restoringTitle,
+        hint: (_c = copy == null ? void 0 : copy.restoringHint) != null ? _c : DEFAULT_COPY.restoringHint
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx(OnboardingThemeProvider, { theme, children: /* @__PURE__ */ jsx(IllustrationProvider, { registry: { ...defaultIllustrations, ...illustrations }, children: /* @__PURE__ */ jsx(WireAIProvider, { llm, components: cards, children: /* @__PURE__ */ jsx(
+    OnboardingFlow,
+    {
+      validators,
+      onComplete: handleComplete,
+      onSkip,
+      onError,
+      onEvent,
+      copy,
+      approxScreens,
+      startMessage,
+      startTimeoutMs,
+      fallbackFlow,
+      maxRetries,
+      reportTarget,
+      sessionId,
+      resumed: session.resumed,
+      clientContext
+    }
+  ) }) }) });
+};
+function DemoOnboarding({
+  config,
+  theme,
+  illustrations,
+  validators,
+  copy,
+  label = "Demo onboarding",
+  onComplete,
+  renderTrigger
+}) {
+  const [open, setOpen] = useState(false);
+  const [runId, setRunId] = useState(0);
+  const t = useMemo(() => mergeTheme(theme != null ? theme : {}), [theme]);
+  const styles20 = useMemo(() => makeStyles(t), [t]);
+  const openDemo = useCallback(() => {
+    setRunId((n) => n + 1);
+    setOpen(true);
+  }, []);
+  const close = useCallback(() => setOpen(false), []);
+  const finish = useCallback(
+    (result) => {
+      onComplete == null ? void 0 : onComplete(result);
+      setOpen(false);
+    },
+    [onComplete]
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    renderTrigger ? renderTrigger(openDemo) : /* @__PURE__ */ jsx(Pressable, { onPress: openDemo, style: styles20.trigger, accessibilityRole: "button", children: /* @__PURE__ */ jsx(Text, { style: styles20.triggerText, children: label }) }),
+    /* @__PURE__ */ jsx(
+      Modal,
+      {
+        visible: open,
+        animationType: "slide",
+        presentationStyle: "fullScreen",
+        onRequestClose: close,
+        children: /* @__PURE__ */ jsx(View, { style: styles20.modal, children: config ? /* @__PURE__ */ jsx(
+          WireOnboarding,
+          {
+            config,
+            theme,
+            illustrations,
+            validators,
+            copy,
+            onComplete: finish,
+            onSkip: close,
+            onError: close
+          },
+          runId
+        ) : /* @__PURE__ */ jsxs(View, { style: styles20.notice, children: [
+          /* @__PURE__ */ jsx(Text, { style: styles20.noticeTitle, children: "Wire AI not configured" }),
+          /* @__PURE__ */ jsx(Text, { style: styles20.noticeBody, children: "Set the Wire AI key + server URL (e.g. via wireConfigFromEnv) to demo the AI onboarding here." }),
+          /* @__PURE__ */ jsx(Pressable, { onPress: close, style: styles20.trigger, accessibilityRole: "button", children: /* @__PURE__ */ jsx(Text, { style: styles20.triggerText, children: "Close" }) })
+        ] }) })
+      }
+    )
+  ] });
+}
+function makeStyles(t) {
+  return StyleSheet.create({
+    trigger: {
+      backgroundColor: t.colors.primary,
+      borderRadius: t.button.radius,
+      paddingVertical: 14,
+      paddingHorizontal: 20,
+      alignItems: "center"
+    },
+    triggerText: { color: t.colors.onPrimary, fontFamily: t.fonts.medium, fontSize: 16 },
+    modal: { flex: 1, backgroundColor: t.colors.background },
+    notice: { flex: 1, alignItems: "center", justifyContent: "center", padding: 24, gap: 12 },
+    noticeTitle: { color: t.colors.text, fontFamily: t.fonts.bold, fontSize: 20 },
+    noticeBody: {
+      color: t.colors.textMuted,
+      fontFamily: t.fonts.regular,
+      fontSize: 15,
+      textAlign: "center"
+    }
+  });
+}
+
+// src/theme/themeFromBrand.ts
+var hexToRgb = (hex) => {
+  const m = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return null;
+  let h = m[1];
+  if (h.length === 3) h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+  const int = parseInt(h, 16);
+  return [int >> 16 & 255, int >> 8 & 255, int & 255];
+};
+var softFromPrimary = (primary) => {
+  const rgb = hexToRgb(primary);
+  if (!rgb) return defaultOnboardingTheme.colors.primarySoft;
+  const [r, g, b] = rgb;
+  return `rgba(${r},${g},${b},0.10)`;
+};
+var themeFromBrand = (input) => {
+  const { primary, background, surface, text, onPrimary, font, extra } = input;
+  const derived = {
+    colors: {
+      ...defaultOnboardingTheme.colors,
+      primary,
+      primarySoft: softFromPrimary(primary),
+      onPrimary: onPrimary != null ? onPrimary : defaultOnboardingTheme.colors.onPrimary,
+      ...background ? { background } : {},
+      ...surface ? { surface } : {},
+      ...text ? { text } : {}
+    },
+    ...font ? {
+      fonts: {
+        ...defaultOnboardingTheme.fonts,
+        regular: font,
+        medium: font,
+        bold: font
+      }
+    } : {}
+  };
+  const base = mergeTheme(derived);
+  if (!extra) return base;
+  return {
+    colors: { ...base.colors, ...extra.colors },
+    fonts: { ...base.fonts, ...extra.fonts },
+    radius: { ...base.radius, ...extra.radius },
+    spacing: { ...base.spacing, ...extra.spacing },
+    button: { ...base.button, ...extra.button }
+  };
+};
+var _DoneBlock = ({
+  title = "You're all set",
+  message = "Personalizing your experience\u2026"
+}) => {
+  const t = useOnboardingTheme();
+  return /* @__PURE__ */ jsxs(View, { style: [styles18.center, { gap: t.spacing.sm, padding: t.spacing.lg }], children: [
+    /* @__PURE__ */ jsx(Text, { style: [headingStyle(t.fonts), { color: t.colors.success, textAlign: "center" }], children: title }),
+    /* @__PURE__ */ jsx(Text, { style: [bodyStyle(t.fonts), { color: t.colors.textMuted, textAlign: "center" }], children: message })
+  ] });
+};
+var DoneBlock = React14.memo(_DoneBlock);
+var styles18 = StyleSheet.create({
+  center: { flex: 1, alignItems: "center", justifyContent: "center" }
+});
+
+// src/motion/centeredModalMotion.ts
+var CENTERED_MODAL_ANIM = {
+  /** Spring config for the card scale/opacity entrance (mirrors CompletionView's pop). */
+  enterSpring: { friction: 7, tension: 80 },
+  /** Exit timing in ms (fade + shrink back out before unmount). */
+  exitMs: 160,
+  /** Card scale at rest (progress 0); grows to 1 at progress 1. */
+  scaleFrom: 0.9,
+  /** Peak dim of the backdrop at progress 1. */
+  backdropOpacity: 0.55
+};
+var _CenteredModal = forwardRef(
+  ({ theme, dismissible = true, onDismiss, children }, ref) => {
+    const progress = useRef(new Animated.Value(0)).current;
+    const [open, setOpen] = useState(true);
+    const closingRef = useRef(false);
+    const reduced = useReducedMotion();
+    useEffect(() => {
+      const anim = reduced ? Animated.timing(progress, {
+        toValue: 1,
+        duration: REDUCED_FADE_MS,
+        useNativeDriver: true
+      }) : Animated.spring(progress, {
+        toValue: 1,
+        useNativeDriver: true,
+        friction: CENTERED_MODAL_ANIM.enterSpring.friction,
+        tension: CENTERED_MODAL_ANIM.enterSpring.tension
+      });
+      anim.start();
+      return () => anim.stop();
+    }, [progress, reduced]);
+    const close = useCallback(() => {
+      if (closingRef.current) return;
+      closingRef.current = true;
+      Animated.timing(progress, {
+        toValue: 0,
+        duration: reduced ? REDUCED_FADE_MS : CENTERED_MODAL_ANIM.exitMs,
+        easing: Easing.in(Easing.cubic),
+        useNativeDriver: true
+      }).start(() => {
+        setOpen(false);
+        onDismiss();
+      });
+    }, [progress, onDismiss, reduced]);
+    useImperativeHandle(ref, () => ({ close }), [close]);
+    useEffect(() => {
+      const sub = BackHandler.addEventListener("hardwareBackPress", () => {
+        if (dismissible) close();
+        return true;
+      });
+      return () => sub.remove();
+    }, [dismissible, close]);
+    const onBackdrop = useCallback(() => {
+      if (dismissible) close();
+    }, [dismissible, close]);
+    const backdropOpacity = progress.interpolate({
+      inputRange: [0, 1],
+      outputRange: [0, CENTERED_MODAL_ANIM.backdropOpacity]
+    });
+    const cardScale = reduced ? 1 : progress.interpolate({
+      inputRange: [0, 1],
+      outputRange: [CENTERED_MODAL_ANIM.scaleFrom, 1]
+    });
+    return /* @__PURE__ */ jsxs(
+      Modal,
+      {
+        visible: open,
+        transparent: true,
+        animationType: "none",
+        statusBarTranslucent: true,
+        onRequestClose: dismissible ? close : void 0,
+        children: [
+          /* @__PURE__ */ jsx(
+            Animated.View,
+            {
+              style: [styles19.backdrop, { opacity: backdropOpacity }],
+              pointerEvents: "none"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Pressable,
+            {
+              style: styles19.fill,
+              onPress: onBackdrop,
+              accessibilityRole: "button",
+              accessibilityLabel: "Dismiss",
+              children: /* @__PURE__ */ jsx(SafeAreaView, { style: styles19.center, pointerEvents: "box-none", children: /* @__PURE__ */ jsx(Pressable, { onPress: () => {
+              }, style: styles19.cardWrap, children: /* @__PURE__ */ jsx(
+                Animated.View,
+                {
+                  accessibilityViewIsModal: true,
+                  accessibilityRole: "alert",
+                  style: [
+                    styles19.card,
+                    {
+                      backgroundColor: theme.colors.surface,
+                      borderRadius: theme.radius.lg,
+                      padding: theme.spacing.lg,
+                      gap: theme.spacing.md,
+                      opacity: progress,
+                      transform: [{ scale: cardScale }]
+                    }
+                  ],
+                  children
+                }
+              ) }) })
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+_CenteredModal.displayName = "CenteredModal";
+var CenteredModal = React14.memo(_CenteredModal);
+var styles19 = StyleSheet.create({
+  fill: { flex: 1 },
+  backdrop: { position: "absolute", top: 0, left: 0, right: 0, bottom: 0, backgroundColor: "#000" },
+  center: { flex: 1, alignItems: "center", justifyContent: "center", padding: 24 },
+  cardWrap: { width: "100%", maxWidth: 420 },
+  card: {
+    width: "100%",
+    // Soft elevation so the popup reads as lifted above the app in both themes.
+    shadowColor: "#000",
+    shadowOffset: { width: 0, height: 8 },
+    shadowOpacity: 0.28,
+    shadowRadius: 24,
+    elevation: 12
+  }
+});
+
+// src/features/defaults.ts
+var defaultWireFeatures = Object.freeze({
+  coachmarks: Object.freeze({ enabled: true }),
+  showcase: Object.freeze({ enabled: true }),
+  onboarding: Object.freeze({ mode: "ai" }),
+  review: Object.freeze({ enabled: true }),
+  questionnaire: Object.freeze({ enabled: true }),
+  announcements: Object.freeze({ enabled: true })
+});
+var VALID_MODES = ["ai", "static", "off"];
+var readEnabled = (raw) => {
+  if (raw && typeof raw === "object" && typeof raw.enabled === "boolean") {
+    return { enabled: raw.enabled };
+  }
+  return { enabled: true };
+};
+var parseWireFeatures = (raw) => {
+  var _a;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return defaultWireFeatures;
+  const src = raw;
+  const modeRaw = (_a = src.onboarding) == null ? void 0 : _a.mode;
+  const mode = typeof modeRaw === "string" && VALID_MODES.includes(modeRaw) ? modeRaw : "ai";
+  return {
+    coachmarks: readEnabled(src.coachmarks),
+    showcase: readEnabled(src.showcase),
+    onboarding: { mode },
+    review: readEnabled(src.review),
+    questionnaire: readEnabled(src.questionnaire),
+    announcements: readEnabled(src.announcements)
+  };
+};
+var featuresEqual = (a, b) => a === b || a.coachmarks.enabled === b.coachmarks.enabled && a.showcase.enabled === b.showcase.enabled && a.onboarding.mode === b.onboarding.mode && a.review.enabled === b.review.enabled && a.questionnaire.enabled === b.questionnaire.enabled && a.announcements.enabled === b.announcements.enabled;
+
+// src/features/cache.ts
+var DEFAULT_FEATURES_TTL_MS = 3e5;
+var READ_TIMEOUT_MS2 = 1500;
+var featuresCacheKey = (appId) => `wireai:features:${appId && appId.length > 0 ? appId : "default"}`;
+var withTimeout2 = (p, ms) => {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(void 0), ms);
+  });
+  return Promise.race([p, timeout]).finally(() => clearTimeout(timer));
+};
+var isFeaturesFresh = (ageMs, ttlMs = DEFAULT_FEATURES_TTL_MS) => ageMs >= 0 && ageMs < ttlMs;
+var readCachedFeatures = async (storage, key) => {
+  let raw;
+  try {
+    raw = await withTimeout2(storage.getItem(key), READ_TIMEOUT_MS2);
+  } catch {
+    return void 0;
+  }
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && typeof parsed.ts === "number") {
+      const ts = parsed.ts;
+      return {
+        features: parseWireFeatures(parsed.features),
+        ageMs: Date.now() - ts
+      };
+    }
+  } catch {
+  }
+  return void 0;
+};
+var writeCachedFeatures = (storage, key, features) => {
+  try {
+    void storage.setItem(key, JSON.stringify({ features, ts: Date.now() })).catch(() => {
+    });
+  } catch {
+  }
+};
+
+// src/features/fetchWireFeatures.ts
+var DEFAULT_TIMEOUT_MS = 4e3;
+var failOpen = async (storage, key) => {
+  var _a;
+  if (!storage) return defaultWireFeatures;
+  const cached = await readCachedFeatures(storage, key);
+  return (_a = cached == null ? void 0 : cached.features) != null ? _a : defaultWireFeatures;
+};
+var fetchWithTimeout = async (url, apiKey, timeoutMs) => {
+  const controller = typeof AbortController !== "undefined" ? new AbortController() : void 0;
+  const timer = setTimeout(() => controller == null ? void 0 : controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, {
+      method: "GET",
+      headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
+      signal: controller == null ? void 0 : controller.signal
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var fetchWireFeatures = async (config) => {
+  const key = featuresCacheKey(config == null ? void 0 : config.appId);
+  const storage = config == null ? void 0 : config.storage;
+  if (!(config == null ? void 0 : config.serverUrl) || !(config == null ? void 0 : config.apiKey)) return failOpen(storage, key);
+  const url = `${config.serverUrl.replace(/\/$/, "")}/v1/features`;
+  const timeoutMs = config.timeoutMs && config.timeoutMs > 0 ? config.timeoutMs : DEFAULT_TIMEOUT_MS;
+  try {
+    const res = await fetchWithTimeout(url, config.apiKey, timeoutMs);
+    if (!res || !res.ok) return failOpen(storage, key);
+    const json = await res.json();
+    const features = parseWireFeatures(json);
+    if (storage) writeCachedFeatures(storage, key, features);
+    return features;
+  } catch {
+    return failOpen(storage, key);
+  }
+};
+var useStableValue = (value, isEqual) => {
+  const ref = useRef(value);
+  if (!isEqual(ref.current, value)) ref.current = value;
+  return ref.current;
+};
+var sameFetchKey = (a, b) => (a == null ? void 0 : a.serverUrl) === (b == null ? void 0 : b.serverUrl) && (a == null ? void 0 : a.apiKey) === (b == null ? void 0 : b.apiKey) && (a == null ? void 0 : a.appId) === (b == null ? void 0 : b.appId);
+var useWireFeatures = (config) => {
+  const stableConfig = useStableValue(config, sameFetchKey);
+  const [flags, setFlags] = useState(defaultWireFeatures);
+  const canFetch = !!(stableConfig == null ? void 0 : stableConfig.serverUrl) && !!(stableConfig == null ? void 0 : stableConfig.apiKey);
+  useEffect(() => {
+    if (!canFetch) {
+      setFlags((prev) => featuresEqual(prev, defaultWireFeatures) ? prev : defaultWireFeatures);
+      return;
+    }
+    let alive = true;
+    void fetchWireFeatures(stableConfig).then((next) => {
+      if (!alive) return;
+      setFlags((prev) => featuresEqual(prev, next) ? prev : next);
+    });
+    return () => {
+      alive = false;
+    };
+  }, [canFetch, stableConfig]);
+  return flags;
+};
+var WireFeaturesContext = createContext(null);
+var WireFeaturesProvider = ({
+  config,
+  flags,
+  children
+}) => {
+  const fetched = useWireFeatures(flags ? void 0 : config);
+  const value = flags != null ? flags : fetched;
+  const stable = useMemo(() => value, [value]);
+  return /* @__PURE__ */ jsx(WireFeaturesContext.Provider, { value: stable, children });
+};
+WireFeaturesProvider.displayName = "WireFeaturesProvider";
+var useWireFeaturesContext = () => useContext(WireFeaturesContext);
+var useResolvedFeatures = (options) => {
+  var _a, _b, _c;
+  const ctx = useWireFeaturesContext();
+  const shouldFetch = !(options == null ? void 0 : options.flags) && ctx == null;
+  const fetched = useWireFeatures(shouldFetch ? options == null ? void 0 : options.config : void 0);
+  return (_c = (_b = (_a = options == null ? void 0 : options.flags) != null ? _a : ctx) != null ? _b : fetched) != null ? _c : defaultWireFeatures;
+};
+
+// src/config/wireConfigFromEnv.ts
+var wireConfigFromEnv = (overrides) => {
+  var _a, _b, _c, _d;
+  const apiKey = (_a = overrides == null ? void 0 : overrides.apiKey) != null ? _a : process.env.EXPO_PUBLIC_WIREAI_API_KEY;
+  const serverUrl = (_b = overrides == null ? void 0 : overrides.serverUrl) != null ? _b : process.env.EXPO_PUBLIC_WIREAI_SERVER_URL;
+  const appId = (_d = (_c = overrides == null ? void 0 : overrides.appId) != null ? _c : process.env.EXPO_PUBLIC_WIREAI_APP_ID) != null ? _d : "default";
+  if (!apiKey || !serverUrl) return null;
+  return {
+    apiKey,
+    serverUrl,
+    appId,
+    ...(overrides == null ? void 0 : overrides.metadata) ? { metadata: overrides.metadata } : {}
+  };
+};
+
+// src/config/onboardingFlag.ts
+var isOnboardingEnabled = (opts) => {
+  var _a;
+  const transportPresent = wireConfigFromEnv(opts == null ? void 0 : opts.config) !== null;
+  if (!transportPresent) return false;
+  return (_a = opts == null ? void 0 : opts.remote) != null ? _a : true;
+};
+
+// src/analytics/analyticsEvent.ts
+var WIRE_ONBOARDING_EVENTS = {
+  started: "wire_onboarding_started",
+  /** A persisted session was restored after an app kill (fires instead of `started`). */
+  resumed: "wire_onboarding_resumed",
+  turn: "wire_onboarding_turn",
+  error: "wire_onboarding_error",
+  retry: "wire_onboarding_retry",
+  fallback: "wire_onboarding_fallback",
+  /** Logged by the host on `onComplete` (no matching kit `OnboardingEvent`). */
+  completed: "wire_onboarding_completed"
+};
+var toAnalyticsEvent = (event) => {
+  switch (event.type) {
+    case "started":
+      return { name: WIRE_ONBOARDING_EVENTS.started };
+    case "resumed":
+      return { name: WIRE_ONBOARDING_EVENTS.resumed };
+    case "turn":
+      return {
+        name: WIRE_ONBOARDING_EVENTS.turn,
+        params: { step: event.step, component: event.component }
+      };
+    case "error":
+      return { name: WIRE_ONBOARDING_EVENTS.error, params: { reason: event.reason } };
+    case "retry":
+      return {
+        name: WIRE_ONBOARDING_EVENTS.retry,
+        params: { reason: event.reason, attempt: event.attempt }
+      };
+    case "fallback":
+      return { name: WIRE_ONBOARDING_EVENTS.fallback, params: { reason: event.reason } };
+    default: {
+      const _exhaustive = event;
+      return _exhaustive;
+    }
+  }
+};
+
+// src/attribution/attribution.ts
+var attributionMetadata = (a) => {
+  const attribution = {};
+  for (const [key, value] of Object.entries(a)) {
+    if (value !== void 0) attribution[key] = value;
+  }
+  return { attribution };
+};
+
+// src/session-analytics/reportSessionStart.ts
+var SESSION_STARTED_EVENT = "app.session_started";
+var _emitted = /* @__PURE__ */ new Set();
+var _GUARD_MAX = 128;
+var resetSessionStartGuard = () => {
+  _emitted.clear();
+};
+var reportSessionStart = (opts) => {
+  var _a;
+  const target = opts.target;
+  if (!(target == null ? void 0 : target.serverUrl)) return;
+  const sessionId = (_a = opts.sessionId) != null ? _a : makeSessionId();
+  if (opts.once !== false) {
+    if (_emitted.has(sessionId)) return;
+    if (_emitted.size >= _GUARD_MAX) {
+      const oldest = _emitted.values().next().value;
+      if (oldest !== void 0) _emitted.delete(oldest);
+    }
+    _emitted.add(sessionId);
+  }
+  try {
+    const url = `${target.serverUrl.replace(/\/$/, "")}/v1/events`;
+    const headers = { "Content-Type": "application/json" };
+    if (target.apiKey) headers.Authorization = `Bearer ${target.apiKey}`;
+    const userContext = {};
+    if (opts.deviceKey) userContext.device_key = opts.deviceKey;
+    if (typeof opts.sessionCount === "number" && Number.isFinite(opts.sessionCount)) {
+      userContext.session_count = opts.sessionCount;
+      userContext.returning = opts.sessionCount > 1;
+    }
+    if (opts.appVersion) userContext.app_version = opts.appVersion;
+    if (opts.platform) userContext.platform = opts.platform;
+    const event = {
+      event_type: "app_event",
+      question_key: SESSION_STARTED_EVENT,
+      session_id: sessionId
+    };
+    const userId = sanitizeUserId(opts.userId);
+    if (userId) event.user_id = userId;
+    if (Object.keys(userContext).length > 0) event.user_context = userContext;
+    if (opts.device) event.device = opts.device;
+    if (opts.meta && Object.keys(opts.meta).length > 0) event.meta = JSON.stringify(opts.meta);
+    void fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ events: [event] })
+    }).catch(() => {
+    });
+  } catch {
+  }
+};
+var BACKGROUND_SESSION_MS = 30 * 60 * 1e3;
+var useSessionStart = (config, options = {}) => {
+  const latest = useRef({ config, options });
+  latest.current = { config, options };
+  useEffect(() => {
+    const fire = () => {
+      var _a, _b;
+      const { config: cfg, options: opts } = latest.current;
+      if (!(cfg == null ? void 0 : cfg.serverUrl)) return;
+      if (opts.enabled === false) return;
+      const target = { serverUrl: cfg.serverUrl, apiKey: (_a = cfg.apiKey) != null ? _a : "" };
+      const device = collectDeviceContext();
+      if (cfg.appVersion && !device.appVersion) device.appVersion = cfg.appVersion;
+      reportSessionStart({
+        target,
+        // A fresh per-open id each fire; the emitter's once-guard dedupes within the open.
+        userId: opts.userId,
+        deviceKey: opts.deviceKey,
+        sessionCount: opts.sessionCount,
+        appVersion: (_b = cfg.appVersion) != null ? _b : device.appVersion,
+        platform: Platform.OS,
+        device,
+        meta: opts.meta
+      });
+    };
+    fire();
+    let backgroundedAt = null;
+    const onChange = (state) => {
+      if (state === "background" || state === "inactive") {
+        if (backgroundedAt == null) backgroundedAt = Date.now();
+        return;
+      }
+      if (state === "active") {
+        const since = backgroundedAt;
+        backgroundedAt = null;
+        if (since != null && Date.now() - since >= BACKGROUND_SESSION_MS) fire();
+      }
+    };
+    const sub = AppState.addEventListener("change", onChange);
+    return () => {
+      if (sub && typeof sub.remove === "function") sub.remove();
+    };
+  }, []);
+};
+
+export { AnimatedSparkle, BACKGROUND_SESSION_MS, CardHandoff, CenteredModal, ChipSelectCard, CompletionView, DEFAULT_FEATURES_TTL_MS, DEFAULT_SESSION_TTL_MS, DemoOnboarding, DoneBlock, ErrorBlock, IllustrationProvider, InterstitialCard, LoadingBlock, LoadingScreen, NumberStepperCard, Button as OnboardingButton, OnboardingFlow, OnboardingScaffold, OnboardingThemeProvider, SESSION_STARTED_EVENT, SelectionCard, StatusCard, StepProgress, TextInputCard, USER_ID_MAX_LENGTH, WIRE_ONBOARDING_EVENTS, WireFeaturesProvider, WireOnboarding, attributionMetadata, clearPersistedSession, collectDeviceContext, defaultIllustrations, defaultOnboardingTheme, defaultWireFeatures, deriveAnswers, featuresCacheKey, featuresEqual, fetchWireFeatures, identifyOnboarding, isFeaturesFresh, isOnboardingEnabled, loadPersistedSession, makeSessionId, mergeTheme, motionSpec_exports as motionSpec, onboardingComponents, parseWireFeatures, peekPersistedSession, readCachedFeatures, readProgress, reportClientEvent, reportClientEvents, reportSessionStart, resetSessionStartGuard, sanitizeUserId, savePersistedSession, sessionStorageKey, themeFromBrand, toAnalyticsEvent, useIllustration, useOnboardingTheme, useReducedMotion, useResolvedFeatures, useSessionStart, useWireFeatures, useWireFeaturesContext, wireConfigFromEnv, writeCachedFeatures };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map