@everfur/sdk 0.1.0

package/dist/chat/index.js

@@ -0,0 +1,1167 @@
+import { createContext, useState, useEffect, useCallback, useSyncExternalStore, useMemo, useContext, useRef } from 'react';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import { KeyboardAvoidingView, View, Text, Platform, TextInput, Pressable, ActivityIndicator, ScrollView, StyleSheet, Animated } from 'react-native';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/rn/chat/useChat.ts
+var CONTRACT_RETRYABILITY = Object.freeze([
+  Object.freeze({ wireCode: "AccessDeniedException", envelope: "http_envelope", httpStatus: 403, retryable: false }),
+  Object.freeze({ wireCode: "AuthorizationException", envelope: "http_envelope", httpStatus: 401, retryable: false }),
+  Object.freeze({ wireCode: "ConflictException", envelope: "http_envelope", httpStatus: 409, retryable: true }),
+  Object.freeze({ wireCode: "DAILY_QUOTA_EXCEEDED", envelope: "http_envelope", httpStatus: 429, retryable: true }),
+  Object.freeze({ wireCode: "IDEMPOTENCY_KEY_IN_FLIGHT", envelope: "http_envelope", httpStatus: 409, retryable: true }),
+  Object.freeze({ wireCode: "IDEMPOTENCY_KEY_REUSED_DIFFERENT_REQUEST", envelope: "http_envelope", httpStatus: 409, retryable: false }),
+  Object.freeze({ wireCode: "InternalFailureException", envelope: "http_envelope", httpStatus: 500, retryable: true }),
+  Object.freeze({ wireCode: "NotImplementedException", envelope: "http_envelope", httpStatus: 501, retryable: false }),
+  Object.freeze({ wireCode: "PaymentRequiredException", envelope: "http_envelope", httpStatus: 402, retryable: false }),
+  Object.freeze({ wireCode: "ResourceNotFoundException", envelope: "http_envelope", httpStatus: 404, retryable: false }),
+  Object.freeze({ wireCode: "ServiceUnavailableException", envelope: "http_envelope", httpStatus: 503, retryable: true }),
+  Object.freeze({ wireCode: "TIER_UPGRADE_REQUIRED", envelope: "http_envelope", httpStatus: 402, retryable: false }),
+  Object.freeze({ wireCode: "ThrottlingException", envelope: "http_envelope", httpStatus: 429, retryable: true }),
+  Object.freeze({ wireCode: "ValidationException", envelope: "http_envelope", httpStatus: 400, retryable: false }),
+  Object.freeze({ wireCode: "accessDenied", envelope: "http_envelope", httpStatus: 403, retryable: false }),
+  Object.freeze({ wireCode: "authExpired", envelope: "http_envelope", httpStatus: 401, retryable: true }),
+  Object.freeze({ wireCode: "internal_error", envelope: "sse_frame", httpStatus: 200, retryable: false }),
+  Object.freeze({ wireCode: "invalidRequest", envelope: "http_envelope", httpStatus: 400, retryable: false }),
+  Object.freeze({ wireCode: "not_found", envelope: "sse_frame", httpStatus: 200, retryable: false }),
+  Object.freeze({ wireCode: "session_required", envelope: "http_envelope", httpStatus: 403, retryable: false }),
+  Object.freeze({ wireCode: "timeout", envelope: "sse_frame", httpStatus: 200, retryable: true }),
+  Object.freeze({ wireCode: "unavailable", envelope: "http_envelope", httpStatus: 503, retryable: true })
+]);
+Object.freeze(
+  CONTRACT_RETRYABILITY.map((row) => row.wireCode)
+);
+
+// src/client/errors/contract.ts
+var NORMALIZED_FOLD = Object.freeze({
+  // the default status-mapped envelope
+  ValidationException: "validationFailed",
+  AuthorizationException: "authRejected",
+  PaymentRequiredException: "paymentRequired",
+  AccessDeniedException: "accessDenied",
+  ResourceNotFoundException: "resourceNotFound",
+  ConflictException: "conflict",
+  ThrottlingException: "rateLimited",
+  InternalFailureException: "internalError",
+  NotImplementedException: "notImplemented",
+  ServiceUnavailableException: "serviceUnavailable",
+  // dict-detail codes on the widget surface
+  authExpired: "authExpired",
+  unavailable: "serviceUnavailable",
+  session_required: "sessionRequired",
+  accessDenied: "accessDenied",
+  invalidRequest: "sdkUpdateRequired",
+  // typed codes
+  IDEMPOTENCY_KEY_IN_FLIGHT: "idempotencyInFlight",
+  IDEMPOTENCY_KEY_REUSED_DIFFERENT_REQUEST: "idempotencyConflict",
+  DAILY_QUOTA_EXCEEDED: "quotaExceeded",
+  TIER_UPGRADE_REQUIRED: "paymentRequired",
+  // SSE error frames
+  not_found: "conversationNotFound",
+  timeout: "streamTimeout",
+  internal_error: "internalError"
+});
+var CONTRACT_ERROR_ROWS = Object.freeze(
+  CONTRACT_RETRYABILITY.map(
+    (generated) => Object.freeze({
+      wireCode: generated.wireCode,
+      envelope: generated.envelope,
+      retryable: generated.retryable,
+      normalized: NORMALIZED_FOLD[generated.wireCode]
+    })
+  )
+);
+var BY_UPPER = new Map(
+  CONTRACT_ERROR_ROWS.map((r) => [r.wireCode.toUpperCase(), r])
+);
+function contractErrorFor(wireCode) {
+  if (typeof wireCode !== "string") return void 0;
+  const key = wireCode.trim().toUpperCase();
+  return key.length > 0 ? BY_UPPER.get(key) : void 0;
+}
+var CATEGORY_OF = Object.freeze({
+  // the caller's sign-in state is wrong and a credential change is the remedy
+  authExpired: "authentication",
+  authRejected: "authentication",
+  sessionRequired: "authentication",
+  // signed in, correctly identified, and still not allowed
+  accessDenied: "authorization",
+  // a plan gate, not a permission failure: the remedy is commercial
+  paymentRequired: "entitlement",
+  // slow down / come back later
+  quotaExceeded: "rateLimit",
+  rateLimited: "rateLimit",
+  // the request itself was wrong; retrying it unchanged can never succeed
+  validationFailed: "invalidRequest",
+  sdkUpdateRequired: "invalidRequest",
+  // the target is gone, hidden, or was never visible to this caller
+  conversationNotFound: "notFound",
+  petNotFound: "notFound",
+  resourceNotFound: "notFound",
+  // something else already holds the thing
+  conflict: "conflict",
+  idempotencyConflict: "conflict",
+  idempotencyInFlight: "conflict",
+  // the pipe, not the request: timeouts, drops, a briefly unreachable dependency
+  streamTimeout: "connection",
+  streamIncomplete: "connection",
+  upstreamLlmTimeout: "connection",
+  serviceUnavailable: "connection",
+  // the server admits fault
+  internalError: "server",
+  notImplemented: "server",
+  mediaUploadFailed: "media",
+  moderationBlocked: "policy",
+  unknown: "unknown"
+});
+function categoryFor(code) {
+  return CATEGORY_OF[code];
+}
+
+// src/client/errors/EverfurError.ts
+var USER_FACING_COPY = Object.freeze({
+  authExpired: "Please sign in again to continue.",
+  authRejected: "Please sign in again to continue.",
+  sessionRequired: "This app needs to be updated to keep using Everfur.",
+  accessDenied: "This feature isn't available on your account right now.",
+  paymentRequired: "This is part of a paid plan.",
+  quotaExceeded: "You have used today's messages. This resets tomorrow.",
+  rateLimited: "You are sending messages quickly. Try again in a few seconds.",
+  validationFailed: "Something in that request was not right. Check the details and try again.",
+  sdkUpdateRequired: "This app needs to be updated to keep using Everfur.",
+  conflict: "That is already running. Wait for it to finish, then try again.",
+  idempotencyConflict: "That message was already delivered.",
+  idempotencyInFlight: "That is still processing. Give it a moment.",
+  conversationNotFound: "This conversation is no longer available.",
+  petNotFound: "We could not find that pet. Please pick a pet and try again.",
+  resourceNotFound: "We could not find that.",
+  streamTimeout: "The response timed out. Tap retry to try again.",
+  mediaUploadFailed: "We could not upload that photo. Please attach it again.",
+  moderationBlocked: "This request cannot be answered here.",
+  upstreamLlmTimeout: "The response timed out. Tap retry to try again.",
+  internalError: "We hit a snag on our end. Please try again.",
+  notImplemented: "That is not available yet.",
+  serviceUnavailable: "That service is briefly unavailable. Try again shortly.",
+  streamIncomplete: "The connection dropped mid-answer. Tap retry to continue.",
+  unknown: "Something went wrong. Please try again."
+});
+function userFacingError(code) {
+  return USER_FACING_COPY[code];
+}
+function defineHidden(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+}
+function makeEverfurError(code, opts) {
+  contractErrorFor(opts?.wireCode);
+  const error = {
+    code,
+    category: categoryFor(code),
+    retryable: opts?.retryable,
+    displayMessage: userFacingError(code)
+  };
+  if (opts?.httpStatus !== void 0) error.httpStatus = opts.httpStatus;
+  if (opts?.requestId) error.requestId = opts.requestId;
+  if (opts?.wireMessage) defineHidden(error, "wireMessage", opts.wireMessage);
+  if (opts?.raw !== void 0 && opts.raw !== null) defineHidden(error, "raw", opts.raw);
+  return Object.freeze(error);
+}
+
+// src/client/errors/EverfurResult.ts
+function ok(value, warning) {
+  return Object.freeze(
+    { ok: true, value } 
+  );
+}
+function err(error) {
+  return Object.freeze({ ok: false, error });
+}
+var EverfurConfigError = class _EverfurConfigError extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.name = "EverfurConfigError";
+    this.kind = kind;
+    Object.setPrototypeOf(this, _EverfurConfigError.prototype);
+  }
+};
+
+// src/client/protocol/frames.ts
+function assertNever(x) {
+  throw new Error(
+    `assertNever: unhandled discriminated-union member ${JSON.stringify(x)}`
+  );
+}
+
+// src/core/chat/ChatController.ts
+var MESSAGE_MAX_CHARS = 4e3;
+
+// src/client/entitlements/resolve.ts
+var REQUIRES = Object.freeze({
+  chat: Object.freeze(["chat.message.create"]),
+  records: Object.freeze(["records.upload.create", "records.record.read"]),
+  video: Object.freeze(["video.gait.execute"]),
+  photo: Object.freeze(["photo.checkup.execute"]),
+  animations: Object.freeze(["animations.state.read"])
+});
+function requires(name) {
+  return REQUIRES[name];
+}
+function decideCapability(name, decisions, opts) {
+  if (opts?.isPending === true) {
+    return freezeDecision({ name, enabled: false, isPending: true, limits: {} });
+  }
+  const keys = requires(name);
+  const byResource = /* @__PURE__ */ new Map();
+  for (const decision of decisions) byResource.set(decision.resource, decision);
+  const limits = mergeLimits(keys, byResource);
+  const missing = keys.filter((key) => byResource.get(key)?.granted !== true);
+  if (missing.length === 0) {
+    return freezeDecision({ name, enabled: true, isPending: false, limits });
+  }
+  return freezeDecision({
+    name,
+    enabled: false,
+    isPending: false,
+    limits,
+    disabled: disabledFor(keys, byResource)
+  });
+}
+function mergeLimits(keys, byResource) {
+  const out = {};
+  for (const key of keys) {
+    const decisionLimits = byResource.get(key)?.limits;
+    if (!decisionLimits) continue;
+    for (const [limitKey, limitValue] of Object.entries(decisionLimits)) {
+      const existing = out[limitKey];
+      out[limitKey] = existing === void 0 ? limitValue : Math.min(existing, limitValue);
+    }
+  }
+  return out;
+}
+function disabledFor(keys, byResource) {
+  for (const key of keys) {
+    const explicit = byResource.get(key)?.disabled;
+    if (explicit) {
+      return Object.freeze({
+        reason: explicit.reason,
+        level: explicit.level,
+        recoverable: explicit.recoverable
+      });
+    }
+  }
+  return Object.freeze({
+    reason: userFacingError("accessDenied"),
+    level: "user_entitlement",
+    recoverable: false
+  });
+}
+function freezeDecision(d) {
+  const base = {
+    name: d.name,
+    enabled: d.enabled,
+    isPending: d.isPending,
+    limits: Object.freeze({ ...d.limits })
+  };
+  if (d.disabled !== void 0) base.disabled = d.disabled;
+  return Object.freeze(base);
+}
+
+// src/client/theme/tokens.ts
+function deepFreeze(value) {
+  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const key of Object.keys(value)) {
+      deepFreeze(value[key]);
+    }
+  }
+  return value;
+}
+var SPACE = { xs: 4, sm: 8, md: 12, lg: 16, xl: 24, xxl: 32 };
+var RADIUS = { tile: 5, xs: 6, sm: 10, md: 14, lg: 20, xl: 28, pill: 500 };
+var TYPE_SIZE = {
+  nano: 8,
+  small: 9,
+  micro: 10,
+  tiny: 11,
+  caption: 12,
+  bodyTight: 13,
+  body: 14,
+  subtitle: 16,
+  heading: 18,
+  verdict: 24
+};
+var LINE_HEIGHT = { tight: 1.15, snug: 1.3, normal: 1.4, relaxed: 1.55 };
+var WEIGHT = { regular: "400", medium: "500", bold: "700" };
+var LETTER_SPACING = {
+  eyebrow: 1,
+  monoWide: 0.9,
+  headerBrand: -0.42,
+  tight: -0.35
+};
+function baseType() {
+  return {
+    family: "System",
+    mono: "monospace",
+    fontUrl: null,
+    size: TYPE_SIZE,
+    lineHeight: LINE_HEIGHT,
+    weight: WEIGHT,
+    letterSpacing: LETTER_SPACING
+  };
+}
+var MOTION = {
+  duration: { instant: 80, fast: 140, normal: 220, slow: 320 },
+  spring: { gentle: { damping: 18, stiffness: 200 } },
+  easing: { standard: "cubic-bezier(0.4, 0, 0.2, 1)" },
+  reducedMotion: false
+};
+var LIGHT_COLOR = {
+  brand: "#10462E",
+  brandSoft: "rgba(16,70,46,0.10)",
+  brandSofter: "rgba(16,70,46,0.15)",
+  brandBorder: "rgba(16,70,46,0.18)",
+  borderHairlineGreen: "rgba(16,70,46,0.25)",
+  surface: "#FFFFFF",
+  surfaceCream: "#FDFBF8",
+  surfaceSubtle: "#EFE9E3",
+  background: "#FFFFFF",
+  borderRingCream: "#D8D2C8",
+  text: {
+    primary: "#111111",
+    secondary: "#0E462E",
+    muted: "#6E6660",
+    placeholder: "rgba(0,0,0,0.30)",
+    onBrand: "#FFFFFF",
+    metaCool: "#3D3D3D"
+  },
+  primary: "#10462E",
+  onPrimary: "#FFFFFF",
+  accent: "#10462E",
+  onAccent: "#FFFFFF",
+  accentEdge: "#07C168",
+  success: "#07C168",
+  danger: "#B91C1C",
+  errorRed: "#FF1B00",
+  warningStrong: "#A45610",
+  cautionAccent: "#D9821D",
+  riskConcern: "#EFA700",
+  badgeBgPositive: "rgba(7,193,104,0.12)",
+  badgeBgCaution: "rgba(217,130,29,0.14)",
+  badgeBgCritical: "rgba(185,28,28,0.12)",
+  badgeBgNeutral: "rgba(110,102,96,0.12)",
+  bubbleUser: "#10462E",
+  bubbleAssistant: "#FFFFFF",
+  skeleton: "#EFE9E3",
+  scanButtonPink: "#FFC3BC",
+  checkupCardLowRiskBg: "rgba(7,193,104,0.10)",
+  checkupCardConcernBg: "rgba(239,167,0,0.10)"
+};
+var EVERFUR_LIGHT = deepFreeze({
+  brightness: "light",
+  meta: { displayName: "Everfur", logoUrl: null, placeholder: null, hidePoweredBy: false },
+  color: LIGHT_COLOR,
+  space: SPACE,
+  radius: RADIUS,
+  type: baseType(),
+  motion: MOTION
+});
+var DARK_COLOR = {
+  brand: "#6BD39A",
+  brandSoft: "rgba(107,211,154,0.12)",
+  brandSofter: "rgba(107,211,154,0.18)",
+  brandBorder: "rgba(107,211,154,0.22)",
+  borderHairlineGreen: "rgba(107,211,154,0.28)",
+  surface: "#1C1F23",
+  surfaceCream: "#23272C",
+  surfaceSubtle: "#23272C",
+  background: "#15171A",
+  borderRingCream: "#3A3F45",
+  text: {
+    primary: "#F5F3F0",
+    secondary: "#A9E4C4",
+    muted: "#9A938C",
+    placeholder: "rgba(255,255,255,0.35)",
+    onBrand: "#0E1F17",
+    metaCool: "#C9C9C9"
+  },
+  primary: "#6BD39A",
+  onPrimary: "#0E1F17",
+  accent: "#6BD39A",
+  onAccent: "#0E1F17",
+  accentEdge: "#34D888",
+  success: "#07C168",
+  danger: "#B91C1C",
+  errorRed: "#FF1B00",
+  warningStrong: "#A45610",
+  cautionAccent: "#D9821D",
+  riskConcern: "#EFA700",
+  badgeBgPositive: "rgba(7,193,104,0.18)",
+  badgeBgCaution: "rgba(217,130,29,0.20)",
+  badgeBgCritical: "rgba(185,28,28,0.22)",
+  badgeBgNeutral: "rgba(255,255,255,0.10)",
+  bubbleUser: "#6BD39A",
+  bubbleAssistant: "#1C1F23",
+  skeleton: "#23272C",
+  scanButtonPink: "#FFC3BC",
+  checkupCardLowRiskBg: "rgba(7,193,104,0.16)",
+  checkupCardConcernBg: "rgba(239,167,0,0.16)"
+};
+deepFreeze({
+  brightness: "dark",
+  meta: { displayName: "Everfur", logoUrl: null, placeholder: null, hidePoweredBy: false },
+  color: DARK_COLOR,
+  space: SPACE,
+  radius: RADIUS,
+  type: baseType(),
+  motion: MOTION
+});
+var EVERFUR_THEME_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("@everfur/sdk#EverfurThemeContext@v1");
+var globalThemeHost = globalThis;
+var EverfurThemeContext = globalThemeHost[EVERFUR_THEME_CONTEXT_SYMBOL] ?? (globalThemeHost[EVERFUR_THEME_CONTEXT_SYMBOL] = createContext(EVERFUR_LIGHT));
+EverfurThemeContext.displayName ??= "EverfurThemeContext";
+function useEverfurTheme() {
+  return useContext(EverfurThemeContext);
+}
+
+// src/rn/facade.ts
+var EVERFUR_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("@everfur/sdk#EverfurContext@v1");
+var globalContextHost = globalThis;
+var EverfurContext = globalContextHost[EVERFUR_CONTEXT_SYMBOL] ?? (globalContextHost[EVERFUR_CONTEXT_SYMBOL] = createContext(null));
+EverfurContext.displayName ??= "EverfurContext";
+function useEverfurContext() {
+  const ctx = useContext(EverfurContext);
+  if (ctx === null) {
+    throw new EverfurConfigError(
+      "not-initialized",
+      "Everfur hooks must be called inside <EverfurProvider>. Wrap your tree once, high."
+    );
+  }
+  return ctx;
+}
+
+// src/rn/chat/useChat.ts
+var BOOTSTRAP_SNAPSHOT = Object.freeze({
+  status: "idle",
+  messages: Object.freeze([]),
+  conversationId: null,
+  error: null,
+  isStreaming: false,
+  isBootstrapping: true,
+  suggestedPrompts: Object.freeze([])
+});
+function useEverfurChat(opts) {
+  const { runtime, userRef, activePet } = useEverfurContext();
+  const petRef = opts?.petRef ?? activePet ?? null;
+  const conversationId = opts?.conversationId ?? null;
+  const [controller, setController] = useState(null);
+  useEffect(() => {
+    const acquired = runtime.registry.acquireChat({ userRef, petRef, conversationId });
+    setController(acquired);
+    return () => {
+      setController((current) => current === acquired ? null : current);
+      runtime.registry.releaseChat(acquired);
+    };
+  }, [runtime, userRef, petRef, conversationId]);
+  const subscribe = useCallback(
+    (onChange) => controller ? controller.subscribe(onChange) : NOOP_UNSUBSCRIBE,
+    [controller]
+  );
+  const getSnapshot = useCallback(
+    () => controller ? controller.getSnapshot() : BOOTSTRAP_SNAPSHOT,
+    [controller]
+  );
+  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const send = useCallback(
+    (text) => controller ? driveToResult(controller, controller.send(text)) : Promise.resolve(notReadyError()),
+    [controller]
+  );
+  const retryLast = useCallback(
+    () => controller ? driveToResult(controller, controller.retryLast()) : Promise.resolve(notReadyError()),
+    [controller]
+  );
+  const stop = useCallback(() => {
+    controller?.stop();
+  }, [controller]);
+  return useMemo(
+    () => ({
+      status: snapshot.status,
+      messages: snapshot.messages,
+      conversationId: snapshot.conversationId,
+      error: snapshot.error,
+      isStreaming: snapshot.isStreaming,
+      isBootstrapping: snapshot.isBootstrapping,
+      suggestedPrompts: snapshot.suggestedPrompts,
+      send,
+      retryLast,
+      stop
+    }),
+    [snapshot, send, retryLast, stop]
+  );
+}
+var NOOP_UNSUBSCRIBE = () => {
+};
+async function driveToResult(controller, iterable) {
+  for await (const _frame of iterable) {
+  }
+  const snapshot = controller.getSnapshot();
+  if (snapshot.status === "error" && snapshot.error !== null) return err(snapshot.error);
+  return ok(lastAssistantResponseId(snapshot.messages));
+}
+function lastAssistantResponseId(messages) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i];
+    if (message && message.role === "assistant" && message.responseId !== void 0) {
+      return message.responseId;
+    }
+  }
+  return null;
+}
+function notReadyError() {
+  return err(
+    makeEverfurError("internalError", { retryable: true })
+  );
+}
+function useCapability(name) {
+  const { runtime } = useEverfurContext();
+  const store = runtime.entitlements;
+  const snapshot = useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot
+  );
+  return useMemo(
+    () => decideCapability(name, snapshot.decisions, { isPending: snapshot.isPending }),
+    [name, snapshot]
+  );
+}
+var MIN_OFFSTATE_HEIGHT = 48;
+function selectView(decision) {
+  if (decision.isPending) return "pending";
+  return decision.enabled ? "enabled" : "disabled";
+}
+function CapabilityGate(props) {
+  const { capability, children, renderDisabled, renderPending, style } = props;
+  const decision = useCapability(capability);
+  const view = useMemo(() => selectView(decision), [decision]);
+  switch (view) {
+    case "enabled":
+      return children;
+    case "pending":
+      return renderPending ? renderPending() : /* @__PURE__ */ jsx(PendingSkeleton, { capability, style });
+    case "disabled":
+      return renderDisabled ? renderDisabled(decision) : /* @__PURE__ */ jsx(OffState, { decision, style });
+    default:
+      return assertNever(view);
+  }
+}
+function PendingSkeleton({
+  capability,
+  style
+}) {
+  const theme = useEverfurTheme();
+  const styles = useMemo(() => makeStyles(theme), [theme]);
+  return /* @__PURE__ */ jsx(
+    View,
+    {
+      style: [styles.offstate, style],
+      accessible: true,
+      accessibilityState: { busy: true },
+      accessibilityLabel: `Loading ${capability}`,
+      children: /* @__PURE__ */ jsx(View, { style: styles.skeletonBar })
+    }
+  );
+}
+function OffState({
+  decision,
+  style
+}) {
+  const theme = useEverfurTheme();
+  const styles = useMemo(() => makeStyles(theme), [theme]);
+  const message = decision.disabled?.reason ?? "";
+  return /* @__PURE__ */ jsx(
+    View,
+    {
+      style: [styles.offstate, style],
+      accessible: true,
+      accessibilityRole: "text",
+      accessibilityLabel: message,
+      children: message.length > 0 ? /* @__PURE__ */ jsx(Text, { style: styles.offstateText, children: message }) : null
+    }
+  );
+}
+function makeStyles(theme) {
+  const { color, space, radius, type } = theme;
+  return StyleSheet.create({
+    // A deliberate cream card with a soft brand hairline, never a bare grey slab.
+    offstate: {
+      minHeight: MIN_OFFSTATE_HEIGHT,
+      justifyContent: "center",
+      paddingHorizontal: space.lg,
+      paddingVertical: space.md,
+      backgroundColor: color.surfaceCream,
+      borderRadius: radius.md,
+      borderWidth: StyleSheet.hairlineWidth,
+      borderColor: color.brandBorder
+    },
+    offstateText: {
+      fontFamily: type.family,
+      fontSize: type.size.body,
+      lineHeight: Math.round(type.size.body * type.lineHeight.normal),
+      color: color.text.muted
+    },
+    // A soft green shimmer bar (brand wash) that stays legible on the cream card in both light and dark,
+    // where the neutral `skeleton` token would collide with the dark cream surface.
+    skeletonBar: {
+      height: space.md,
+      borderRadius: radius.xs,
+      backgroundColor: color.brandSofter
+    }
+  });
+}
+var CLINICAL_DISCLAIMER = Object.freeze({
+  title: "For educational use only",
+  body: "Everfur is for educational purposes only. It helps you track visible changes through AI checkups. It does not diagnose, treat, prescribe, or replace veterinary care. For urgent symptoms or emergencies, contact a veterinarian immediately."
+});
+function ClinicalDisclaimer(props) {
+  const theme = useEverfurTheme();
+  const styles = useMemo(() => makeStyles2(theme), [theme]);
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      style: [styles.container, props.style],
+      accessible: true,
+      accessibilityRole: "text",
+      accessibilityLabel: `${CLINICAL_DISCLAIMER.title}. ${CLINICAL_DISCLAIMER.body}`,
+      children: [
+        /* @__PURE__ */ jsx(Text, { style: styles.title, children: CLINICAL_DISCLAIMER.title }),
+        /* @__PURE__ */ jsx(Text, { style: styles.body, children: CLINICAL_DISCLAIMER.body })
+      ]
+    }
+  );
+}
+function makeStyles2(theme) {
+  const { color, space, type } = theme;
+  return StyleSheet.create({
+    container: {
+      paddingHorizontal: space.lg,
+      paddingVertical: space.md,
+      borderTopWidth: StyleSheet.hairlineWidth,
+      borderTopColor: color.borderHairlineGreen,
+      backgroundColor: color.surfaceCream,
+      gap: space.xs
+    },
+    title: {
+      fontFamily: type.family,
+      fontSize: type.size.caption,
+      lineHeight: Math.round(type.size.caption * type.lineHeight.snug),
+      color: color.text.secondary,
+      fontWeight: type.weight.bold,
+      letterSpacing: type.letterSpacing.eyebrow
+    },
+    body: {
+      fontFamily: type.family,
+      fontSize: type.size.caption,
+      lineHeight: Math.round(type.size.caption * type.lineHeight.snug),
+      color: color.text.muted,
+      fontWeight: type.weight.regular
+    }
+  });
+}
+var INLINE_TOKEN = /\*\*([^*]+?)\*\*|\*([^*]+?)\*|`([^`]+?)`/g;
+function renderInlineMarkdown(text, styles) {
+  if (!text.includes("*") && !text.includes("`")) return text;
+  const nodes = [];
+  let cursor = 0;
+  let key = 0;
+  INLINE_TOKEN.lastIndex = 0;
+  for (let match = INLINE_TOKEN.exec(text); match !== null; match = INLINE_TOKEN.exec(text)) {
+    if (match.index > cursor) nodes.push(text.slice(cursor, match.index));
+    const bold = match[1];
+    const italic = match[2];
+    const code = match[3];
+    if (bold !== void 0) {
+      nodes.push(/* @__PURE__ */ jsx(Text, { style: styles.bold, children: bold }, key++));
+    } else if (italic !== void 0) {
+      nodes.push(styles.italic ? /* @__PURE__ */ jsx(Text, { style: styles.italic, children: italic }, key++) : italic);
+    } else if (code !== void 0) {
+      nodes.push(styles.code ? /* @__PURE__ */ jsx(Text, { style: styles.code, children: code }, key++) : code);
+    }
+    cursor = match.index + match[0].length;
+  }
+  if (cursor < text.length) nodes.push(text.slice(cursor));
+  return nodes;
+}
+var DOT_SIZE = 6;
+var LOOP_MS = 520;
+var STAGGER_MS = Math.round(LOOP_MS * 0.18);
+var OPACITY_REST = 0.44;
+var OPACITY_STATIC = 0.5;
+var TRI_IN = [0, 0.5, 1];
+var DOT_INDICES = [0, 1, 2];
+function TypingIndicator() {
+  const theme = useEverfurTheme();
+  const styles = useMemo(() => makeStyles3(theme), [theme]);
+  const animate = !theme.motion.reducedMotion;
+  return /* @__PURE__ */ jsx(
+    View,
+    {
+      style: styles.card,
+      accessible: true,
+      accessibilityRole: "text",
+      accessibilityLabel: "Assistant is typing",
+      accessibilityLiveRegion: "polite",
+      accessibilityState: { busy: true },
+      children: DOT_INDICES.map(
+        (index) => animate ? /* @__PURE__ */ jsx(AnimatedDot, { index, style: styles.dot }, index) : /* @__PURE__ */ jsx(View, { style: [styles.dot, styles.dotStatic] }, index)
+      )
+    }
+  );
+}
+function AnimatedDot({ index, style }) {
+  const t = useRef(new Animated.Value(0)).current;
+  useEffect(() => {
+    const anim = Animated.sequence([
+      Animated.delay(index * STAGGER_MS),
+      Animated.loop(Animated.timing(t, { toValue: 1, duration: LOOP_MS, useNativeDriver: true }))
+    ]);
+    anim.start();
+    return () => anim.stop();
+  }, [t, index]);
+  const opacity = t.interpolate({ inputRange: TRI_IN, outputRange: [OPACITY_REST, 1, OPACITY_REST] });
+  const translateY = t.interpolate({ inputRange: TRI_IN, outputRange: [0, -3.5, 0] });
+  return /* @__PURE__ */ jsx(Animated.View, { style: [style, { opacity, transform: [{ translateY }] }] });
+}
+function makeStyles3(theme) {
+  const c = theme.color;
+  const s = theme.space;
+  const r = theme.radius;
+  return StyleSheet.create({
+    card: {
+      alignSelf: "flex-start",
+      flexDirection: "row",
+      alignItems: "center",
+      gap: s.xs,
+      paddingHorizontal: s.md,
+      paddingVertical: s.sm,
+      backgroundColor: c.surfaceCream,
+      borderRadius: r.md,
+      borderWidth: StyleSheet.hairlineWidth,
+      borderColor: c.brandBorder
+    },
+    dot: { width: DOT_SIZE, height: DOT_SIZE, borderRadius: r.pill, backgroundColor: c.brand },
+    dotStatic: { opacity: OPACITY_STATIC }
+  });
+}
+var SPINNER_DELAY_MS = 300;
+var DEFAULT_PLACEHOLDER = "Message";
+var DEFAULT_SEND_LABEL = "Send";
+var DEFAULT_STOP_LABEL = "Stop";
+var FOLLOW_UPS_LABEL = "Follow up questions";
+var POWERED_BY_LABEL = "powered by everfur";
+var MIN_SURFACE_HEIGHT = 120;
+var MIN_TOUCH_TARGET = 44;
+var INPUT_MAX_HEIGHT = 120;
+var EMPTY_GLYPH_SIZE = 40;
+var BUBBLE_MAX_WIDTH = "82%";
+var COMPOSER_BORDER_WIDTH = 1.25;
+var BUBBLE_EDGE_WIDTH = 0.5;
+var PENDING_OPACITY = 0.6;
+var COMPOSER_SHADOW_OPACITY = 0.1;
+var COMPOSER_SHADOW_OFFSET_Y = 2;
+var COMPOSER_SHADOW_ELEVATION = 2;
+function EverfurChat(props) {
+  const { petRef, conversationId, style } = props;
+  return /* @__PURE__ */ jsx(CapabilityGate, { capability: "chat", style, children: /* @__PURE__ */ jsx(ChatBody, { petRef, conversationId, style }) });
+}
+function selectView2(state) {
+  if (state.isBootstrapping) return "loading";
+  if (state.status === "error" && state.error) return "error";
+  if (state.messages.length === 0) return "empty";
+  return "populated";
+}
+function ChatBody({
+  petRef,
+  conversationId,
+  style
+}) {
+  const { theme, styles } = useChatTheme();
+  const chatOpts = useMemo(
+    () => buildChatOpts(petRef, conversationId),
+    [petRef, conversationId]
+  );
+  const chat = useEverfurChat(chatOpts);
+  const view = selectView2(chat);
+  const insets = useSafeAreaInsets();
+  const onSelectPrompt = useCallback(
+    (prompt) => {
+      void chat.send(prompt);
+    },
+    [chat.send]
+  );
+  return (
+    // KeyboardAvoidingView so the composer + disclaimer lift above the software keyboard while the user types.
+    /* @__PURE__ */ jsxs(
+      KeyboardAvoidingView,
+      {
+        style: [styles.container, { paddingTop: insets.top }, style],
+        behavior: Platform.OS === "ios" ? "padding" : void 0,
+        children: [
+          /* @__PURE__ */ jsx(View, { style: styles.body, children: renderView(view, chat, onSelectPrompt) }),
+          /* @__PURE__ */ jsx(Composer, { send: chat.send, stop: chat.stop, isStreaming: chat.isStreaming }),
+          /* @__PURE__ */ jsx(ClinicalDisclaimer, {}),
+          theme.meta.hidePoweredBy ? null : /* @__PURE__ */ jsx(Text, { style: styles.poweredBy, accessibilityRole: "text", accessibilityLabel: POWERED_BY_LABEL, children: POWERED_BY_LABEL })
+        ]
+      }
+    )
+  );
+}
+function Composer({
+  send,
+  stop,
+  isStreaming
+}) {
+  const { theme, styles } = useChatTheme();
+  const [draft, setDraft] = useState("");
+  const placeholder = theme.meta.placeholder ?? DEFAULT_PLACEHOLDER;
+  const onSend = useCallback(() => {
+    if (draft.trim().length === 0) return;
+    if ([...draft].length > MESSAGE_MAX_CHARS) return;
+    void send(draft);
+    setDraft("");
+  }, [draft, send]);
+  const onStop = useCallback(() => {
+    stop();
+  }, [stop]);
+  const isOverLimit = useMemo(() => [...draft].length > MESSAGE_MAX_CHARS, [draft]);
+  return /* @__PURE__ */ jsxs(View, { style: styles.composer, children: [
+    /* @__PURE__ */ jsx(
+      TextInput,
+      {
+        style: styles.input,
+        value: draft,
+        onChangeText: setDraft,
+        placeholder,
+        placeholderTextColor: theme.color.text.placeholder,
+        accessibilityLabel: placeholder,
+        onSubmitEditing: onSend,
+        returnKeyType: "send",
+        blurOnSubmit: false,
+        multiline: true,
+        editable: true
+      }
+    ),
+    isStreaming ? /* @__PURE__ */ jsx(
+      Pressable,
+      {
+        onPress: onStop,
+        accessibilityRole: "button",
+        accessibilityLabel: DEFAULT_STOP_LABEL,
+        style: styles.actionButton,
+        children: /* @__PURE__ */ jsx(Text, { style: styles.actionLabel, children: DEFAULT_STOP_LABEL })
+      }
+    ) : /* @__PURE__ */ jsx(
+      Pressable,
+      {
+        onPress: onSend,
+        disabled: isOverLimit,
+        accessibilityRole: "button",
+        accessibilityLabel: DEFAULT_SEND_LABEL,
+        accessibilityState: { disabled: isOverLimit },
+        style: [styles.actionButton, isOverLimit ? styles.actionButtonDisabled : null],
+        children: /* @__PURE__ */ jsx(Text, { style: [styles.actionLabel, isOverLimit ? styles.actionLabelDisabled : null], children: DEFAULT_SEND_LABEL })
+      }
+    )
+  ] });
+}
+function renderView(view, chat, onSelectPrompt) {
+  switch (view) {
+    case "loading":
+      return /* @__PURE__ */ jsx(LoadingState, {});
+    case "empty":
+      return /* @__PURE__ */ jsx(EmptyState, { prompts: chat.suggestedPrompts, onSelectPrompt });
+    case "error":
+      return /* @__PURE__ */ jsx(ErrorState, { error: chat.error, onRetry: chat.retryLast });
+    case "populated":
+      return /* @__PURE__ */ jsx(
+        PopulatedState,
+        {
+          messages: chat.messages,
+          prompts: chat.suggestedPrompts,
+          onSelectPrompt,
+          isStreaming: chat.isStreaming
+        }
+      );
+    default:
+      return assertNever(view);
+  }
+}
+function buildChatOpts(petRef, conversationId) {
+  const opts = {};
+  if (petRef !== void 0) opts.petRef = petRef;
+  if (conversationId !== void 0) opts.conversationId = conversationId;
+  return opts;
+}
+function LoadingState() {
+  const { theme, styles } = useChatTheme();
+  const [visible, setVisible] = useState(false);
+  useEffect(() => {
+    const id = setTimeout(() => setVisible(true), SPINNER_DELAY_MS);
+    return () => clearTimeout(id);
+  }, []);
+  return /* @__PURE__ */ jsx(View, { style: styles.centered, accessible: true, accessibilityState: { busy: true }, accessibilityLabel: "Loading", children: visible ? /* @__PURE__ */ jsx(ActivityIndicator, { color: theme.color.brand }) : null });
+}
+function EmptyState({
+  prompts,
+  onSelectPrompt
+}) {
+  const { styles } = useChatTheme();
+  return /* @__PURE__ */ jsxs(ScrollView, { contentContainerStyle: styles.emptyContent, keyboardShouldPersistTaps: "handled", children: [
+    /* @__PURE__ */ jsx(View, { style: styles.emptyGlyphWrap, accessible: true, accessibilityRole: "summary", accessibilityLabel: "No messages yet", children: /* @__PURE__ */ jsx(View, { style: styles.emptyGlyph }) }),
+    /* @__PURE__ */ jsx(FollowUps, { prompts, onSelectPrompt })
+  ] });
+}
+function FollowUps({
+  prompts,
+  onSelectPrompt
+}) {
+  const { styles } = useChatTheme();
+  if (prompts.length === 0) return null;
+  return /* @__PURE__ */ jsxs(View, { style: styles.followUps, children: [
+    /* @__PURE__ */ jsx(Text, { style: styles.followUpsLabel, accessibilityRole: "header", children: FOLLOW_UPS_LABEL }),
+    prompts.map((prompt, index) => /* @__PURE__ */ jsx(
+      Pressable,
+      {
+        onPress: () => onSelectPrompt(prompt),
+        accessibilityRole: "button",
+        accessibilityLabel: prompt,
+        style: [styles.followUpRow, index > 0 ? styles.followUpDivider : null],
+        children: /* @__PURE__ */ jsx(Text, { style: styles.followUpText, children: prompt })
+      },
+      prompt
+    ))
+  ] });
+}
+function ErrorState({ error, onRetry }) {
+  const { styles } = useChatTheme();
+  return /* @__PURE__ */ jsxs(View, { style: styles.centered, accessible: true, accessibilityRole: "alert", children: [
+    /* @__PURE__ */ jsx(Text, { style: styles.errorText, children: error.displayMessage }),
+    error.retryable ? /* @__PURE__ */ jsx(
+      Pressable,
+      {
+        onPress: onRetry,
+        accessibilityRole: "button",
+        accessibilityLabel: "Try again",
+        style: styles.retryButton,
+        children: /* @__PURE__ */ jsx(Text, { style: styles.retryLabel, children: "Try again" })
+      }
+    ) : null
+  ] });
+}
+function PopulatedState({
+  messages,
+  prompts,
+  onSelectPrompt,
+  isStreaming
+}) {
+  const { styles } = useChatTheme();
+  const lastMessage = messages[messages.length - 1];
+  const awaitingAssistant = isStreaming && (lastMessage === void 0 || lastMessage.role === "user");
+  return /* @__PURE__ */ jsxs(
+    ScrollView,
+    {
+      style: styles.list,
+      contentContainerStyle: styles.listContent,
+      accessibilityLabel: "Conversation",
+      keyboardShouldPersistTaps: "handled",
+      children: [
+        messages.map((message) => /* @__PURE__ */ jsx(MessageRow, { message }, message.id)),
+        awaitingAssistant ? /* @__PURE__ */ jsx(TypingIndicator, {}) : null,
+        !isStreaming ? /* @__PURE__ */ jsx(FollowUps, { prompts, onSelectPrompt }) : null
+      ]
+    }
+  );
+}
+function MessageRow({ message }) {
+  const { styles } = useChatTheme();
+  const isUser = message.role === "user";
+  const sender = isUser ? "You" : "Assistant";
+  return /* @__PURE__ */ jsx(
+    View,
+    {
+      style: [styles.row, isUser ? styles.rowUser : styles.rowAssistant],
+      accessible: true,
+      accessibilityRole: "text",
+      accessibilityLabel: `${sender}: ${message.text}`,
+      accessibilityState: message.pending === true ? { busy: true } : void 0,
+      children: /* @__PURE__ */ jsx(View, { style: [styles.bubble, isUser ? styles.bubbleUser : styles.bubbleAssistant, message.pending ? styles.bubblePending : null], children: /* @__PURE__ */ jsx(Text, { style: isUser ? styles.bubbleTextUser : styles.bubbleTextAssistant, children: isUser ? message.text : renderInlineMarkdown(message.text, {
+        bold: styles.bubbleBold,
+        italic: styles.bubbleItalic,
+        code: styles.bubbleCode
+      }) }) })
+    }
+  );
+}
+function useChatTheme() {
+  const theme = useEverfurTheme();
+  const styles = useMemo(() => makeStyles4(theme), [theme]);
+  return { theme, styles };
+}
+function makeStyles4(theme) {
+  const c = theme.color;
+  const s = theme.space;
+  const r = theme.radius;
+  const t = theme.type;
+  const weightLabel = t.weight.medium;
+  return StyleSheet.create({
+    // Cream ground so the branded bubbles / bare assistant text sit on an Everfur surface (host `style` still wins).
+    container: { flex: 1, minHeight: MIN_SURFACE_HEIGHT, backgroundColor: c.surfaceCream },
+    body: { flex: 1 },
+    centered: { minHeight: MIN_SURFACE_HEIGHT, flexGrow: 1, alignItems: "center", justifyContent: "center", padding: s.xl },
+    // Deliberate empty-state placeholder: a soft brand-wash disc (never a blank region).
+    emptyGlyph: {
+      width: EMPTY_GLYPH_SIZE,
+      height: EMPTY_GLYPH_SIZE,
+      borderRadius: r.pill,
+      backgroundColor: c.brandSoft,
+      borderWidth: StyleSheet.hairlineWidth,
+      borderColor: c.brandBorder
+    },
+    // Empty state scrolls (glyph centered, then the follow-up list) so nothing overflows a short surface.
+    emptyContent: { flexGrow: 1, justifyContent: "center", padding: s.lg, gap: s.lg },
+    emptyGlyphWrap: { alignItems: "center", justifyContent: "center", paddingVertical: s.xl },
+    errorText: {
+      fontFamily: t.family,
+      fontSize: t.size.subtitle,
+      lineHeight: t.size.subtitle * t.lineHeight.snug,
+      color: c.danger,
+      textAlign: "center",
+      marginBottom: s.md
+    },
+    // Brand-green pill retry CTA with the WCAG-legible on-brand foreground.
+    retryButton: {
+      minHeight: MIN_TOUCH_TARGET,
+      minWidth: MIN_TOUCH_TARGET,
+      alignItems: "center",
+      justifyContent: "center",
+      paddingHorizontal: s.xl,
+      paddingVertical: s.sm,
+      borderRadius: r.pill,
+      backgroundColor: c.brand
+    },
+    retryLabel: { fontFamily: t.family, color: c.onPrimary, fontSize: t.size.body, fontWeight: weightLabel },
+    list: { flex: 1 },
+    listContent: { padding: s.lg, gap: s.md },
+    row: { flexDirection: "row" },
+    rowUser: { justifyContent: "flex-end" },
+    rowAssistant: { justifyContent: "flex-start" },
+    bubble: { maxWidth: BUBBLE_MAX_WIDTH, paddingHorizontal: s.md, paddingVertical: s.sm, borderRadius: r.lg },
+    // User = brand accent fill + 0.5px accent edge, tail corner tightened (the mobile asymmetry).
+    bubbleUser: {
+      backgroundColor: c.bubbleUser,
+      borderBottomRightRadius: r.tile,
+      borderWidth: BUBBLE_EDGE_WIDTH,
+      borderColor: c.accentEdge
+    },
+    // Assistant = bare text block (no fill, flush-left) so the reply reads as plain, on-surface prose.
+    bubbleAssistant: { paddingHorizontal: 0 },
+    bubblePending: { opacity: PENDING_OPACITY },
+    bubbleTextUser: {
+      fontFamily: t.family,
+      color: c.onAccent,
+      fontSize: t.size.body,
+      lineHeight: t.size.body * t.lineHeight.normal
+    },
+    bubbleTextAssistant: {
+      fontFamily: t.family,
+      color: c.text.primary,
+      fontSize: t.size.body,
+      lineHeight: t.size.body * t.lineHeight.normal
+    },
+    // Inline-markdown runs inside the assistant reply (nested <Text>): bold entities + optional italic / code.
+    bubbleBold: { fontWeight: t.weight.bold },
+    bubbleItalic: { fontStyle: "italic" },
+    bubbleCode: { fontFamily: t.mono },
+    // "Follow up questions": a labeled, list-with-dividers block of tappable, ready-to-send backend prompts.
+    followUps: { marginTop: s.sm, borderRadius: r.md, backgroundColor: c.brandSoft, borderWidth: StyleSheet.hairlineWidth, borderColor: c.brandBorder },
+    followUpsLabel: {
+      fontFamily: t.family,
+      color: c.text.secondary,
+      fontSize: t.size.caption,
+      fontWeight: weightLabel,
+      letterSpacing: t.letterSpacing.eyebrow,
+      textTransform: "uppercase",
+      paddingHorizontal: s.md,
+      paddingTop: s.md,
+      paddingBottom: s.sm
+    },
+    followUpRow: { minHeight: MIN_TOUCH_TARGET, justifyContent: "center", paddingHorizontal: s.md, paddingVertical: s.sm },
+    followUpDivider: { borderTopWidth: StyleSheet.hairlineWidth, borderTopColor: c.brandBorder },
+    followUpText: {
+      fontFamily: t.family,
+      color: c.text.primary,
+      fontSize: t.size.body,
+      lineHeight: t.size.body * t.lineHeight.snug
+    },
+    // Composer = inset cream pill with a brand border and a soft brand-tinted lift.
+    composer: {
+      flexDirection: "row",
+      alignItems: "flex-end",
+      gap: s.sm,
+      marginHorizontal: s.md,
+      marginTop: s.xs,
+      marginBottom: s.sm,
+      paddingHorizontal: s.md,
+      paddingVertical: s.sm,
+      backgroundColor: c.surfaceCream,
+      borderWidth: COMPOSER_BORDER_WIDTH,
+      borderColor: c.brandBorder,
+      borderRadius: r.pill,
+      shadowColor: c.brand,
+      shadowOpacity: COMPOSER_SHADOW_OPACITY,
+      shadowRadius: s.sm,
+      shadowOffset: { width: 0, height: COMPOSER_SHADOW_OFFSET_Y },
+      elevation: COMPOSER_SHADOW_ELEVATION
+    },
+    // Bare input inside the pill (the composer owns the border / fill); placeholder color set on the element.
+    input: {
+      flex: 1,
+      minHeight: MIN_TOUCH_TARGET,
+      maxHeight: INPUT_MAX_HEIGHT,
+      paddingHorizontal: s.md,
+      paddingVertical: s.sm,
+      fontFamily: t.family,
+      fontSize: t.size.body,
+      lineHeight: t.size.body * t.lineHeight.normal,
+      color: c.text.primary
+    },
+    // Brand-green pill send / stop control.
+    actionButton: {
+      minHeight: MIN_TOUCH_TARGET,
+      minWidth: MIN_TOUCH_TARGET,
+      alignItems: "center",
+      justifyContent: "center",
+      paddingHorizontal: s.lg,
+      borderRadius: r.pill,
+      backgroundColor: c.brand
+    },
+    actionLabel: { fontFamily: t.family, color: c.onPrimary, fontSize: t.size.body, fontWeight: weightLabel },
+    // The over-length state. Opacity alone would carry the meaning by appearance only, so the control also
+    // sets `disabled` and `accessibilityState.disabled`, which is what a screen reader announces.
+    actionButtonDisabled: { opacity: 0.45 },
+    actionLabelDisabled: { color: c.onPrimary },
+    // Everfur's own attribution: small, muted, centered under the disclaimer.
+    poweredBy: {
+      fontFamily: t.family,
+      color: c.text.muted,
+      fontSize: t.size.micro,
+      textAlign: "center",
+      paddingBottom: s.xs
+    }
+  });
+}
+
+export { EverfurChat, useEverfurChat };