@everfur/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,4464 @@
+import { SafeAreaProvider, useSafeAreaInsets } from 'react-native-safe-area-context';
+import { createContext, useContext, useSyncExternalStore, useMemo, createElement, useState, useEffect, useRef, useReducer, useLayoutEffect, useCallback } from 'react';
+import { z } from 'zod';
+import EventSource from 'react-native-sse';
+import { useColorScheme, AccessibilityInfo, View, Text, StyleSheet, KeyboardAvoidingView, Platform, TextInput, Pressable, ActivityIndicator, ScrollView, Animated } from 'react-native';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/client/text.ts
+function hasLoneSurrogate(value) {
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      const low = value.charCodeAt(i + 1);
+      if (!(low >= 56320 && low <= 57343)) return true;
+      i += 1;
+    } else if (code >= 56320 && code <= 57343) {
+      return true;
+    }
+  }
+  return false;
+}
+function serverLength(value) {
+  return [...value].length;
+}
+
+// src/client/errors/EverfurResult.ts
+function ok(value, warning) {
+  return Object.freeze(
+    { ok: true, value } 
+  );
+}
+function err(error) {
+  return Object.freeze({ ok: false, error });
+}
+function isOk(r) {
+  return r.ok;
+}
+function isErr(r) {
+  return !r.ok;
+}
+var EverfurThrownError = class _EverfurThrownError extends Error {
+  constructor(error) {
+    super(`${error.code}: ${error.displayMessage}`);
+    this.name = "EverfurThrownError";
+    this.error = error;
+    this.code = error.code;
+    this.category = error.category;
+    Object.setPrototypeOf(this, _EverfurThrownError.prototype);
+  }
+};
+function unwrap(r) {
+  if (r.ok) return r.value;
+  throw new EverfurThrownError(r.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/ids.ts
+var MAX_USER_REF_LEN = 128;
+var MAX_PET_REF_LEN = 128;
+var CONTROL_CHAR = /[\u0000-\u001F\u007F]/;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function petRef(raw) {
+  const v = raw;
+  const length = serverLength(v);
+  if (length === 0 || length > MAX_PET_REF_LEN) {
+    throw new EverfurConfigError(
+      "invalid-argument",
+      `petRef must be 1..${MAX_PET_REF_LEN} characters`
+    );
+  }
+  if (CONTROL_CHAR.test(v)) {
+    throw new EverfurConfigError("invalid-argument", "petRef must be printable (no control characters)");
+  }
+  return v;
+}
+function userRef(raw) {
+  const v = raw;
+  const length = serverLength(v);
+  if (length === 0 || length > MAX_USER_REF_LEN) {
+    throw new EverfurConfigError(
+      "invalid-argument",
+      `userRef must be 1..${MAX_USER_REF_LEN} characters`
+    );
+  }
+  if (v.includes("@")) {
+    throw new EverfurConfigError("invalid-argument", "userRef must not contain '@'");
+  }
+  if (CONTROL_CHAR.test(v)) {
+    throw new EverfurConfigError("invalid-argument", "userRef must be printable (no control characters)");
+  }
+  return v;
+}
+function conversationId(raw) {
+  if (!UUID_RE.test(raw)) {
+    throw new EverfurConfigError("invalid-argument", "conversationId must be a UUID");
+  }
+  return raw;
+}
+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];
+}
+function fromWire(wire) {
+  const contractRow = contractErrorFor(wire);
+  if (contractRow) return contractRow.normalized;
+  const upper = (wire ?? "").trim().toUpperCase();
+  const canonical = upper.replace(/[^A-Z0-9]/g, "");
+  if (canonical === "AUTHREJECTED") return "authRejected";
+  if (upper.startsWith("AUTH")) return "authExpired";
+  switch (canonical) {
+    case "DAILYQUOTAEXCEEDED":
+    case "QUOTAEXCEEDED":
+      return "quotaExceeded";
+    case "RATELIMITED":
+    case "TOOMANYREQUESTS":
+      return "rateLimited";
+    case "IDEMPOTENCYKEYCONFLICT":
+    case "IDEMPOTENCYCONFLICT":
+      return "idempotencyConflict";
+    case "ACCESSDENIED":
+    case "FORBIDDEN":
+      return "accessDenied";
+    case "NOTFOUND":
+    case "CONVERSATIONNOTFOUND":
+      return "conversationNotFound";
+    case "PETNOTFOUND":
+      return "petNotFound";
+    case "TIMEOUT":
+    case "STREAMTIMEOUT":
+      return "streamTimeout";
+    // Analysis-domain deterministic 400s (NON-retryable). Additive per SPEC-00 §3.1 / SPEC-11b §2.6:
+    // fold to a NON-retried target so the SDK never retries a permanently-failing bad-input request.
+    // (Comment above the group so the empty fall-through cases stay lint-clean under no-fallthrough.)
+    case "MEDIAUPLOADFAILED":
+    case "UNRECOGNIZEDVIDEOFORMAT":
+    case "FILETOOSMALL":
+      return "mediaUploadFailed";
+    case "MODERATIONBLOCKED":
+      return "moderationBlocked";
+    case "UPSTREAMLLMTIMEOUT":
+      return "upstreamLlmTimeout";
+    case "INTERNALERROR":
+    case "INTERNALSERVERERROR":
+      return "internalError";
+    case "STREAMINCOMPLETE":
+    case "CHATSTREAMINCOMPLETE":
+      return "streamIncomplete";
+    // Deterministic 400s that can only come from an SDK bug -> unknown (NON-retryable). NEVER internalError
+    // (which IS auto-retried): mapping a bad-input 400 to a retryable code retries a request that never succeeds.
+    case "INVALIDANALYSISTYPE":
+    case "INVALIDUPLOADPURPOSE":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+function fromHttpStatus(status) {
+  if (status === 401) return "authExpired";
+  if (status === 403) return "accessDenied";
+  if (status === 404) return "conversationNotFound";
+  if (status === 409) return "idempotencyConflict";
+  if (status === 421) return "unknown";
+  if (status === 429) return "rateLimited";
+  if (status === 400 || status === 422) return "unknown";
+  if (status >= 500) return "internalError";
+  return "unknown";
+}
+var AUTO_RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "streamTimeout",
+  "rateLimited",
+  "internalError",
+  "upstreamLlmTimeout",
+  "streamIncomplete"
+]);
+function isAutoRetryable(code) {
+  return AUTO_RETRYABLE_CODES.has(code);
+}
+var RETRYABLE_CONTRACT_CODES = /* @__PURE__ */ new Set([
+  "serviceUnavailable",
+  "conflict",
+  "idempotencyInFlight"
+]);
+function isRetryableCode(code) {
+  return isAutoRetryable(code) || RETRYABLE_CONTRACT_CODES.has(code);
+}
+function shouldRetry(code, frameRetryable = false) {
+  return frameRetryable || isAutoRetryable(code);
+}
+var BACKOFF_BASE_MS = 500;
+var BACKOFF_CAP_MS = 8e3;
+var MAX_RETRY_ATTEMPTS = 4;
+function backoffDelayMs(attempt, rng = Math.random) {
+  const bounded = Math.max(0, attempt);
+  const ceiling = Math.min(BACKOFF_BASE_MS * 2 ** bounded, BACKOFF_CAP_MS);
+  return Math.floor(rng() * ceiling);
+}
+function canRecreateOnNotFound(code) {
+  return code === "conversationNotFound";
+}
+
+// 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 ?? isRetryableCode(code),
+    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/core/ports/TelemetryPort.ts
+var noopTelemetry = Object.freeze({
+  track() {
+  },
+  trackExpectedFailure() {
+  }
+});
+
+// src/core/ports/ErrorPolicyPort.ts
+var defaultErrorPolicy = Object.freeze({
+  shouldRetry(code, attempt) {
+    return isAutoRetryable(code) && attempt < MAX_RETRY_ATTEMPTS;
+  },
+  maxAttempts() {
+    return MAX_RETRY_ATTEMPTS;
+  }
+});
+
+// src/core/ports/CameraPort.ts
+var unavailableCamera = Object.freeze({
+  isAvailable: false,
+  async capture() {
+    return Promise.reject(
+      new Error("CameraPort is unavailable; check isAvailable before calling capture")
+    );
+  }
+});
+
+// src/client/protocol/frames.ts
+function assertNever(x) {
+  throw new Error(
+    `assertNever: unhandled discriminated-union member ${JSON.stringify(x)}`
+  );
+}
+function acceptedFrame(streamId, lastEventId, serverRequestId = null) {
+  return Object.freeze({ kind: "accepted", streamId, lastEventId, serverRequestId, terminal: false });
+}
+function heartbeatFrame(lastEventId, serverRequestId = null) {
+  return Object.freeze({ kind: "heartbeat", lastEventId, serverRequestId, terminal: false });
+}
+function deltaFrame(delta, lastEventId, serverRequestId = null) {
+  return Object.freeze({ kind: "delta", delta, lastEventId, serverRequestId, terminal: false });
+}
+function doneFrame(fields, serverRequestId = null) {
+  return Object.freeze({
+    kind: "done",
+    terminal: true,
+    conversationId: fields.conversationId,
+    messageId: fields.messageId,
+    title: fields.title,
+    followUpQuestions: Object.freeze([...fields.followUpQuestions]),
+    citations: Object.freeze([...fields.citations]),
+    citationStatus: fields.citationStatus,
+    urgencyLevel: fields.urgencyLevel,
+    urgencyReason: fields.urgencyReason,
+    resultId: fields.resultId,
+    lastEventId: fields.lastEventId,
+    serverRequestId
+  });
+}
+function errorFrame(fields) {
+  return Object.freeze({
+    kind: "error",
+    terminal: true,
+    code: fields.code,
+    retryable: fields.retryable,
+    wireMessage: fields.wireMessage,
+    synthesized: fields.synthesized,
+    lastEventId: fields.lastEventId,
+    serverRequestId: fields.serverRequestId ?? null
+  });
+}
+function analysisStartedFrame(requestId, lastEventId, serverRequestId = null) {
+  return Object.freeze({
+    kind: "analysisStarted",
+    requestId,
+    lastEventId,
+    serverRequestId,
+    terminal: false
+  });
+}
+function analysisCompleteFrame(fields, serverRequestId = null) {
+  return Object.freeze({
+    kind: "analysisComplete",
+    terminal: false,
+    resultId: fields.resultId,
+    analysisType: fields.analysisType,
+    modelVersion: fields.modelVersion,
+    confidence: fields.confidence,
+    detections: Object.freeze([...fields.detections]),
+    interpretation: fields.interpretation,
+    lastEventId: fields.lastEventId,
+    serverRequestId
+  });
+}
+function unknownFrame(raw, lastEventId, serverRequestId = null) {
+  return Object.freeze({
+    kind: "unknown",
+    raw: { ...raw },
+    lastEventId,
+    serverRequestId,
+    terminal: false
+  });
+}
+
+// src/client/identity.ts
+function createIdentityProvider(userRef2, getToken) {
+  let cached = null;
+  let inFlight = null;
+  let revoked = false;
+  const load = () => {
+    if (inFlight) return inFlight;
+    inFlight = (async () => {
+      try {
+        const token = await getToken();
+        if (typeof token !== "string" || token.length === 0) {
+          throw new EverfurConfigError("invalid-argument", "TokenProvider returned an empty token");
+        }
+        cached = token;
+        return token;
+      } finally {
+        inFlight = null;
+      }
+    })();
+    return inFlight;
+  };
+  return {
+    userRef: userRef2,
+    async currentToken(opts) {
+      if (revoked) {
+        throw new EverfurConfigError("not-initialized", "This identity was cleared (sign-out); mint a new one.");
+      }
+      if (opts?.forceRefresh) cached = null;
+      if (cached !== null) return cached;
+      return load();
+    },
+    hasToken() {
+      return !revoked && cached !== null;
+    },
+    clear() {
+      revoked = true;
+      cached = null;
+    }
+  };
+}
+function newSessionId() {
+  const bytes = new Uint8Array(16);
+  const cryptoObj = globalThis.crypto;
+  if (typeof cryptoObj?.getRandomValues === "function") {
+    cryptoObj.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [];
+  for (let i = 0; i < bytes.length; i += 1) hex.push(bytes[i].toString(16).padStart(2, "0"));
+  return hex.slice(0, 4).join("") + "-" + hex.slice(4, 6).join("") + "-" + hex.slice(6, 8).join("") + "-" + hex.slice(8, 10).join("") + "-" + hex.slice(10, 16).join("");
+}
+function authHeaders(auth) {
+  const headers = {};
+  if (auth.mode === "personalized") {
+    headers.authorization = `Bearer ${auth.token}`;
+  } else {
+    headers["x-everfur-partner-key"] = auth.publishableKey;
+  }
+  if (auth.userRef) headers["x-everfur-user-ref"] = auth.userRef;
+  if (auth.sessionId) headers["x-everfur-session-id"] = auth.sessionId;
+  return headers;
+}
+function withAuthHeaders(req, auth) {
+  return { ...req, headers: { ...stripAuthHeaders(req.headers), ...authHeaders(auth) } };
+}
+function stripAuthHeaders(headers) {
+  if (!headers) return {};
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const lower = key.toLowerCase();
+    if (lower === "authorization" || lower === "x-everfur-partner-key") continue;
+    out[key] = value;
+  }
+  return out;
+}
+async function authedSend(req, ctx) {
+  if (ctx.mode === "anonymous") {
+    return ctx.transport.request(
+      withAuthHeaders(req, {
+        mode: "anonymous",
+        publishableKey: ctx.publishableKey,
+        userRef: ctx.userRef,
+        ...ctx.sessionId ? { sessionId: ctx.sessionId } : {}
+      })
+    );
+  }
+  let token;
+  try {
+    token = await ctx.identity.currentToken();
+  } catch {
+    return err(authRejectedError());
+  }
+  const first = await ctx.transport.request(
+    withAuthHeaders(req, {
+      mode: "personalized",
+      token,
+      userRef: ctx.userRef,
+      ...ctx.sessionId ? { sessionId: ctx.sessionId } : {}
+    })
+  );
+  if (first.ok || first.error.httpStatus !== 401) return first;
+  let refreshed;
+  try {
+    refreshed = await ctx.identity.currentToken({ forceRefresh: true });
+  } catch {
+    return err(authRejectedError());
+  }
+  const retry = await ctx.transport.request(
+    withAuthHeaders(req, {
+      mode: "personalized",
+      token: refreshed,
+      userRef: ctx.userRef,
+      ...ctx.sessionId ? { sessionId: ctx.sessionId } : {}
+    })
+  );
+  if (!retry.ok && retry.error.httpStatus === 401) {
+    return err(authRejectedError(retry.error.httpStatus));
+  }
+  return retry;
+}
+function authRejectedError(httpStatus) {
+  return makeEverfurError("authRejected", {
+    retryable: false,
+    ...httpStatus !== void 0 ? { httpStatus } : {}
+  });
+}
+var BLOCK_SEPARATOR = "\n\n";
+var MAX_PENDING_BLOCK_CHARS = 1048576;
+var wireObjectSchema = z.record(z.string(), z.unknown());
+var URGENCY_LEVELS = ["emergency", "schedule_soon", "home_care"];
+async function* parseSse(bytes, serverRequestId = null) {
+  let resolvedRequestId = null;
+  const requestIdNow = () => {
+    if (resolvedRequestId !== null) return resolvedRequestId;
+    resolvedRequestId = typeof serverRequestId === "function" ? serverRequestId() : serverRequestId;
+    return resolvedRequestId;
+  };
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let scanFrom = 0;
+  let sawDelta = false;
+  for await (const chunk of bytes) {
+    buffer += decoder.decode(chunk, { stream: true });
+    for (; ; ) {
+      const sep = buffer.indexOf(BLOCK_SEPARATOR, scanFrom);
+      if (sep === -1) break;
+      const block = buffer.slice(0, sep);
+      buffer = buffer.slice(sep + BLOCK_SEPARATOR.length);
+      scanFrom = 0;
+      const frame = parseBlock(block, requestIdNow());
+      if (frame === null) continue;
+      if (frame.kind === "delta") sawDelta = true;
+      yield frame;
+      if (frame.terminal) return;
+    }
+    scanFrom = buffer.length > 0 ? buffer.length - 1 : 0;
+    if (buffer.length > MAX_PENDING_BLOCK_CHARS) {
+      yield errorFrame({
+        code: sawDelta ? "CHAT_STREAM_INCOMPLETE" : "internal_error",
+        retryable: true,
+        wireMessage: null,
+        synthesized: true,
+        lastEventId: null,
+        serverRequestId: requestIdNow()
+      });
+      return;
+    }
+  }
+  buffer += decoder.decode();
+  if (buffer.trim().length > 0) {
+    const frame = parseBlock(buffer, requestIdNow());
+    if (frame !== null) {
+      if (frame.kind === "delta") sawDelta = true;
+      yield frame;
+      if (frame.terminal) return;
+    }
+  }
+  yield errorFrame({
+    code: sawDelta ? "CHAT_STREAM_INCOMPLETE" : "internal_error",
+    retryable: true,
+    wireMessage: null,
+    synthesized: true,
+    lastEventId: null,
+    serverRequestId: requestIdNow()
+  });
+}
+function parseBlock(block, serverRequestId) {
+  let id = null;
+  const dataLines = [];
+  for (const rawLine of block.split("\n")) {
+    const line = rawLine.replace(/\s+$/, "");
+    if (line.length === 0 || line.startsWith(":")) continue;
+    if (line.startsWith("id:")) {
+      id = line.slice(3).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).replace(/^ /, ""));
+    }
+  }
+  if (dataLines.length === 0) return null;
+  let decoded;
+  try {
+    decoded = JSON.parse(dataLines.join("\n"));
+  } catch {
+    return null;
+  }
+  if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) return null;
+  const parsed = wireObjectSchema.safeParse(decoded);
+  if (!parsed.success) return null;
+  return frameFromWire(parsed.data, id, serverRequestId);
+}
+function frameFromWire(json, lastEventId, serverRequestId) {
+  const type = json["type"];
+  const event = json["event"];
+  if (type === "error" || "error" in json) {
+    return errorFrame({
+      code: asString(json["code"]) ?? "unknown",
+      retryable: json["retryable"] === true,
+      wireMessage: asString(json["error"]),
+      synthesized: false,
+      lastEventId,
+      serverRequestId
+    });
+  }
+  if (type === "done" || json["done"] === true) {
+    return doneFrame({
+      conversationId: asString(json["conversation_id"]) ?? "",
+      messageId: asString(json["message_id"]),
+      title: asString(json["title"]),
+      followUpQuestions: asStringList(json["follow_up_questions"]),
+      citations: asMapList(json["citations"]),
+      citationStatus: asString(json["citation_status"]),
+      urgencyLevel: asUrgency(json["urgency_level"]),
+      urgencyReason: asString(json["urgency_reason"]),
+      resultId: asString(json["result_id"]),
+      lastEventId
+    }, serverRequestId);
+  }
+  if (type === "accepted" || json["status"] === "reasoning") {
+    return acceptedFrame(asString(json["stream_id"]), lastEventId, serverRequestId);
+  }
+  if (type === "heartbeat" || json["heartbeat"] === true) {
+    return heartbeatFrame(lastEventId, serverRequestId);
+  }
+  if (type === "text.delta" || "delta" in json || "token" in json) {
+    const delta = asString(json["delta"]) ?? asString(json["token"]) ?? "";
+    return deltaFrame(delta, lastEventId, serverRequestId);
+  }
+  if (event === "analysis_started") {
+    return analysisStartedFrame(asString(json["request_id"]), lastEventId, serverRequestId);
+  }
+  if (event === "analysis_complete") {
+    return analysisCompleteFrame({
+      resultId: asString(json["result_id"]),
+      analysisType: asString(json["analysis_type"]),
+      modelVersion: asString(json["model_version"]),
+      confidence: asNumber(json["confidence"]),
+      detections: asMapList(json["detections"]),
+      interpretation: asString(json["interpretation"]),
+      lastEventId
+    }, serverRequestId);
+  }
+  return unknownFrame(json, lastEventId, serverRequestId);
+}
+function asString(v) {
+  return typeof v === "string" ? v : null;
+}
+function asNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function asUrgency(v) {
+  return typeof v === "string" && URGENCY_LEVELS.includes(v) ? v : null;
+}
+function asStringList(v) {
+  if (!Array.isArray(v)) return [];
+  return v.map((e) => typeof e === "string" ? e : String(e));
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function asMapList(v) {
+  if (!Array.isArray(v)) return [];
+  return v.filter(isPlainObject);
+}
+
+// src/client/config.ts
+var SDK_VERSION = "0.1.0";
+var SDK_PLATFORM = "react-native";
+var DEFAULT_CONTRACT_VERSION = "2026-08-01";
+var ENV_API_BASE_URL = "EVERFUR_API_BASE_URL";
+function configFailure(reason, message) {
+  return Object.freeze({ ok: false, failure: Object.freeze({ reason, message }) });
+}
+function checkPublishableKey(raw) {
+  const publishableKey = typeof raw === "string" ? raw.trim() : "";
+  if (publishableKey.length === 0) {
+    return { reason: "missing-publishable-key", message: "publishableKey is required" };
+  }
+  if (/^sk[_-]/i.test(publishableKey)) {
+    return {
+      reason: "secret-key-as-publishable-key",
+      message: "publishableKey looks like a SECRET key (sk_...). A device must never hold a partner secret key: use the pk_ publishable key here, and keep the secret key on your server."
+    };
+  }
+  return null;
+}
+function tryResolveClientConfig(config) {
+  const keyFailure = checkPublishableKey(config?.publishableKey);
+  if (keyFailure !== null) {
+    return Object.freeze({ ok: false, failure: keyFailure });
+  }
+  const publishableKey = config.publishableKey.trim();
+  const baseUrl = tryResolveApiBaseUrl(config.apiBaseUrl);
+  if (!baseUrl.ok) {
+    return baseUrl;
+  }
+  const contractVersion = config.contractVersion?.trim() || DEFAULT_CONTRACT_VERSION;
+  return Object.freeze({
+    ok: true,
+    config: Object.freeze({
+      publishableKey,
+      apiBaseUrl: baseUrl.value,
+      contractVersion,
+      sdkVersion: SDK_VERSION,
+      platform: SDK_PLATFORM,
+      debug: config.debug === true
+    })
+  });
+}
+function tryResolveApiBaseUrl(apiBaseUrl) {
+  const explicit = apiBaseUrl?.trim();
+  const candidate = explicit && explicit.length > 0 ? explicit : readEnv(ENV_API_BASE_URL);
+  if (!candidate) {
+    return configFailure(
+      "missing-api-base-url",
+      `apiBaseUrl is required: pass config.apiBaseUrl or set ${ENV_API_BASE_URL}. The SDK never ships a hardcoded host.`
+    );
+  }
+  return normalizeBaseUrl(candidate);
+}
+function buildBaseHeaders(cfg) {
+  return {
+    "X-Everfur-SDK-Version": cfg.sdkVersion,
+    "X-Everfur-SDK-Platform": cfg.platform,
+    "X-Everfur-Contract": cfg.contractVersion
+  };
+}
+var ABSOLUTE_URL = /^([A-Za-z][A-Za-z0-9+.-]*):\/\/([^/?#]*)/;
+function hostOf(authority) {
+  const afterUserinfo = authority.slice(authority.lastIndexOf("@") + 1);
+  return afterUserinfo.replace(/:\d+$/, "").toLowerCase();
+}
+function isPrintableHost(host) {
+  if (host.length === 0) return false;
+  if (host.includes("@")) return false;
+  if (host.startsWith("[") && host.endsWith("]")) return true;
+  return !host.includes(":");
+}
+function canEchoOrigin(rawTrimmed, host) {
+  const schemeEnd = rawTrimmed.indexOf("://");
+  if (schemeEnd < 0) return false;
+  if (rawTrimmed.slice(schemeEnd + 3).includes("@")) return false;
+  return isPrintableHost(host);
+}
+function safeOrigin(scheme, host) {
+  return `${scheme}://${host}`;
+}
+function normalizeBaseUrl(raw) {
+  const trimmed = raw.trim();
+  const match = ABSOLUTE_URL.exec(trimmed);
+  if (match === null || match[2] === void 0 || match[2].length === 0) {
+    return configFailure("malformed-api-base-url", "apiBaseUrl is not a valid absolute URL");
+  }
+  const scheme = (match[1] ?? "").toLowerCase();
+  const host = hostOf(match[2]);
+  if (host.length === 0) {
+    return configFailure("malformed-api-base-url", "apiBaseUrl is not a valid absolute URL");
+  }
+  const shown = canEchoOrigin(trimmed, host) ? `: ${safeOrigin(scheme, host)}` : "";
+  if (scheme === "https") ; else if (scheme === "http" && isLoopbackHost(host)) ; else if (scheme === "http") {
+    return configFailure(
+      "insecure-api-base-url",
+      `apiBaseUrl must use https (cleartext http is only allowed for localhost)${shown}`
+    );
+  } else {
+    return configFailure("unsupported-api-base-url-scheme", `apiBaseUrl must be http(s)${shown}`);
+  }
+  const value = trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+  return Object.freeze({ ok: true, value });
+}
+function isLoopbackHost(hostname) {
+  const host = hostname.toLowerCase();
+  return host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host === "::1";
+}
+function readEnv(name) {
+  const g = globalThis;
+  const value = g.process?.env?.[name];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+
+// src/client/transport.ts
+var UNARY_TIMEOUT_MS = 3e4;
+var REQUEST_ID_HEADER = "x-request-id";
+async function* fetchByteSource(body) {
+  if (!body) return;
+  const reader = body.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value && value.length > 0) yield value;
+    }
+  } finally {
+    await reader.cancel?.();
+  }
+}
+function eventSourceByteSource(es) {
+  const enc = new TextEncoder();
+  const queue = createByteQueue();
+  let cleaned = false;
+  const onMessage = (ev) => {
+    let block = "";
+    if (ev.lastEventId) block += `id: ${ev.lastEventId}
+`;
+    const data = ev.data ?? "";
+    for (const line of data.split("\n")) block += `data: ${line}
+`;
+    block += "\n";
+    queue.push(enc.encode(block));
+  };
+  const onDone = () => {
+    cleanup();
+    queue.end();
+  };
+  const onError = (ev) => {
+    const status = typeof ev.xhrStatus === "number" ? ev.xhrStatus : 0;
+    if (status >= 400) {
+      const wireCode = statusToWireCode(status);
+      const retryable = isAutoRetryable(fromWire(wireCode));
+      queue.push(enc.encode(`data: ${JSON.stringify({ type: "error", code: wireCode, retryable })}
+
+`));
+    }
+    cleanup();
+    queue.end();
+  };
+  es.addEventListener("message", onMessage);
+  es.addEventListener("done", onDone);
+  es.addEventListener("error", onError);
+  function cleanup() {
+    if (cleaned) return;
+    cleaned = true;
+    es.removeEventListener("message", onMessage);
+    es.removeEventListener("done", onDone);
+    es.removeEventListener("error", onError);
+    try {
+      es.close();
+    } catch {
+    }
+  }
+  return sourceWithCleanup(queue.source, cleanup);
+}
+async function* sourceWithCleanup(source, cleanup) {
+  try {
+    yield* source;
+  } finally {
+    cleanup();
+  }
+}
+function createByteQueue() {
+  const buffer = [];
+  let done = false;
+  let wake = null;
+  const signal = () => {
+    if (wake) {
+      const fn = wake;
+      wake = null;
+      fn();
+    }
+  };
+  async function* gen() {
+    for (; ; ) {
+      const next = buffer.shift();
+      if (next !== void 0) {
+        yield next;
+        continue;
+      }
+      if (done) return;
+      await new Promise((resolve) => {
+        wake = resolve;
+      });
+    }
+  }
+  return {
+    source: gen(),
+    push: (u) => {
+      buffer.push(u);
+      signal();
+    },
+    end: () => {
+      done = true;
+      signal();
+    }
+  };
+}
+async function requestJson(req, deps) {
+  const fetchImpl = deps.fetchImpl ?? getGlobalFetch();
+  const url = buildUrl(deps.config.apiBaseUrl, req.path, req.query);
+  const headers = mergeHeaders(deps.config, req.headers, "application/json", req.body !== void 0 && req.multipart === void 0);
+  const deadline2 = timeoutSignal(UNARY_TIMEOUT_MS);
+  const signal = mergeAbortSignals(deadline2.signal, req.signal);
+  let res;
+  try {
+    res = await fetchImpl(url, buildInit({ ...req, signal }, headers));
+  } catch (cause) {
+    return err(networkError(cause));
+  } finally {
+    deadline2.cancel();
+  }
+  const bodyJson = await safeJson(res);
+  if (!res.ok) return err(errorFromResponse(res.status, bodyJson, requestIdOf(res)));
+  return ok(bodyJson);
+}
+function createHttpTransport(deps) {
+  return {
+    request: (req) => requestJson(req, deps),
+    stream: (req, signal) => streamFrames(withSignal(req, signal), deps)
+  };
+}
+async function* streamFrames(req, deps) {
+  const url = buildUrl(deps.config.apiBaseUrl, req.path, req.query);
+  const headers = mergeHeaders(deps.config, req.headers, "text/event-stream", req.body !== void 0 && req.multipart === void 0);
+  if (deps.eventSourceFactory) {
+    const es = deps.eventSourceFactory(url, buildEventSourceInit(req, headers));
+    yield* parseSse(eventSourceByteSource(es), () => eventSourceRequestId(es));
+    return;
+  }
+  const fetchImpl = deps.fetchImpl ?? getGlobalFetch();
+  let res;
+  try {
+    res = await fetchImpl(url, buildInit(req, headers));
+  } catch (cause) {
+    yield syntheticErrorFrame("", true, describeCause(cause));
+    return;
+  }
+  const requestId = requestIdOf(res);
+  if (!res.ok) {
+    const body = await safeJson(res);
+    const wireCode = extractWireCode(body) ?? statusToWireCode(res.status);
+    const retryable = extractRetryable(body) || isAutoRetryable(fromWire(wireCode));
+    yield syntheticErrorFrame(wireCode, retryable, extractWireMessage(body), requestId);
+    return;
+  }
+  if (res.body) {
+    yield* parseSse(fetchByteSource(res.body), requestId);
+    return;
+  }
+  yield* parseSse(fetchByteSource(null), requestId);
+}
+function buildEventSourceInit(req, headers) {
+  return {
+    method: req.method,
+    headers,
+    pollingInterval: 0,
+    ...req.body !== void 0 ? { body: JSON.stringify(req.body) } : {}
+  };
+}
+function errorFromResponse(status, body, requestId) {
+  const wireCode = extractWireCode(body);
+  const code = wireCode ? fromWire(wireCode) : fromHttpStatus(status);
+  const wireMessage = extractWireMessage(body);
+  return makeEverfurError(code, {
+    httpStatus: status,
+    ...extractRetryable(body) ? { retryable: true } : {},
+    ...requestId ? { requestId } : {},
+    ...wireCode ? { wireCode } : {},
+    ...wireMessage ? { wireMessage } : {},
+    ...body !== null && body !== void 0 ? { raw: body } : {}
+  });
+}
+function networkError(cause) {
+  return makeEverfurError("internalError", { retryable: true, wireMessage: describeCause(cause) });
+}
+function requestIdOf(res) {
+  const value = res.headers.get(REQUEST_ID_HEADER);
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function eventSourceRequestId(es) {
+  if (typeof es.getResponseHeader !== "function") return null;
+  let value;
+  try {
+    value = es.getResponseHeader(REQUEST_ID_HEADER);
+  } catch {
+    return null;
+  }
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function statusToWireCode(status) {
+  if (status === 401) return "AUTH_EXPIRED";
+  if (status === 403) return "ACCESS_DENIED";
+  if (status === 404) return "NOT_FOUND";
+  if (status === 409) return "IDEMPOTENCY_CONFLICT";
+  if (status === 421) return "MISDIRECTED_REQUEST";
+  if (status === 429) return "RATE_LIMITED";
+  if (status === 400 || status === 422) return "INVALID_REQUEST";
+  if (status === 503) return "INTERNAL_ERROR";
+  if (status >= 500) return "INTERNAL_ERROR";
+  return "";
+}
+function syntheticErrorFrame(code, retryable, wireMessage, serverRequestId = null) {
+  return errorFrame({ code, retryable, wireMessage, synthesized: true, lastEventId: null, serverRequestId });
+}
+function getGlobalFetch() {
+  const candidate = globalThis.fetch;
+  if (typeof candidate !== "function") {
+    throw new EverfurConfigError(
+      "missing-peer-dependency",
+      "global fetch is unavailable; provide config.transport or an injected fetch implementation"
+    );
+  }
+  return candidate;
+}
+function buildUrl(base, path, query) {
+  const rel = path.startsWith("/") ? path : `/${path}`;
+  let url = `${base}${rel}`;
+  if (query) {
+    const qs = Object.entries(query).filter((entry) => entry[1] !== void 0).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+    if (qs) url += `?${qs}`;
+  }
+  return url;
+}
+function mergeHeaders(config, reqHeaders, accept, hasJsonBody) {
+  const headers = { ...buildBaseHeaders(config), accept };
+  if (hasJsonBody) headers["content-type"] = "application/json";
+  if (reqHeaders) Object.assign(headers, reqHeaders);
+  return headers;
+}
+function buildInit(req, headers) {
+  const init = { method: req.method, headers };
+  if (req.multipart !== void 0) init.body = req.multipart;
+  else if (req.body !== void 0) init.body = JSON.stringify(req.body);
+  if (req.signal) init.signal = req.signal;
+  return init;
+}
+function withSignal(req, signal) {
+  return req.signal ? req : { ...req, signal };
+}
+function timeoutSignal(ms) {
+  const ctrl = new AbortController();
+  const handle = setTimeout(() => ctrl.abort(), ms);
+  return {
+    signal: ctrl.signal,
+    cancel: () => clearTimeout(handle)
+  };
+}
+function mergeAbortSignals(deadline2, caller) {
+  if (!caller) return deadline2;
+  const ctrl = new AbortController();
+  if (deadline2.aborted || caller.aborted) {
+    ctrl.abort();
+    return ctrl.signal;
+  }
+  const onAbort = () => ctrl.abort();
+  deadline2.addEventListener("abort", onAbort, { once: true });
+  caller.addEventListener("abort", onAbort, { once: true });
+  return ctrl.signal;
+}
+async function safeJson(res) {
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+function extractWireCode(body) {
+  const b = body;
+  const code = b?.error?.code ?? b?.code;
+  return typeof code === "string" && code.length > 0 ? code : null;
+}
+function extractWireMessage(body) {
+  const b = body;
+  const message = b?.error?.message ?? b?.message;
+  return typeof message === "string" && message.length > 0 ? message : null;
+}
+function extractRetryable(body) {
+  const b = body;
+  return b?.error?.retryable === true || b?.retryable === true;
+}
+function describeCause(cause) {
+  if (cause instanceof Error) return cause.message;
+  return typeof cause === "string" ? cause : "network request failed";
+}
+
+// src/client/funnel/requestFunnel.ts
+var FUNNEL_UNARY_TIMEOUT_MS = 3e4;
+var RETRY_OVERRIDE_MAX_MS = BACKOFF_CAP_MS * 2;
+var IDEMPOTENCY_HEADER = "idempotency-key";
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var NOOP_OBSERVER = Object.freeze({
+  onEvent() {
+  }
+});
+var defaultFunnelTimers = Object.freeze({
+  setTimeout: (handler, ms) => setTimeout(handler, ms),
+  clearTimeout: (handle) => clearTimeout(handle),
+  now: () => Date.now()
+});
+function createRequestFunnel(deps) {
+  const observer = deps.observer ?? NOOP_OBSERVER;
+  const timers = deps.timers ?? defaultFunnelTimers;
+  const rng = deps.rng ?? Math.random;
+  const sleep = deps.sleep ?? ((ms, signal) => delayAbortable(ms, timers, signal));
+  const ceiling = deps.maxAttempts ?? MAX_RETRY_ATTEMPTS;
+  const timeoutMs = deps.unaryTimeoutMs ?? FUNNEL_UNARY_TIMEOUT_MS;
+  const mintKey = deps.newIdempotencyKey ?? defaultIdempotencyKeyFactory();
+  const emit = (event) => {
+    try {
+      observer.onEvent(event);
+    } catch {
+    }
+  };
+  async function send(call, req, opts) {
+    const perCallMaxAttempts = opts?.maxAttempts;
+    const maxAttempts = Math.max(1, perCallMaxAttempts ?? ceiling);
+    const idempotent = opts?.idempotent ?? MUTATING_METHODS.has(req.method);
+    const idempotencyKey = idempotent ? mintKey() : null;
+    const base = assembleHeaders(req, idempotencyKey);
+    let attempt = 0;
+    for (; ; ) {
+      const stamp = (extra) => Object.freeze({
+        call,
+        method: req.method,
+        path: req.path,
+        attempt,
+        ...idempotencyKey ? { idempotencyKey } : {},
+        ...extra
+      });
+      emit(stamp({ phase: "attempt" }));
+      const deadline2 = boundedSignal(timeoutMs, timers);
+      const merged = mergeSignals(deadline2.signal, req.signal);
+      let settled;
+      try {
+        settled = await authedSend({ ...base, signal: merged.signal }, deps.auth);
+      } catch (cause) {
+        settled = err(networkError(cause));
+      } finally {
+        merged.dispose();
+        deadline2.cancel();
+      }
+      if (settled.ok) {
+        emit(stamp({ phase: "settled", ok: true, reason: "ok" }));
+        return settled;
+      }
+      const error = settled.error;
+      const decision = decideRetry(error, attempt, {
+        maxAttempts,
+        rng,
+        now: timers.now(),
+        aborted: req.signal?.aborted === true,
+        ...perCallMaxAttempts !== void 0 ? { perCallMaxAttempts } : {},
+        ...deps.errorPolicy !== void 0 ? { policy: deps.errorPolicy } : {}
+      });
+      const settledEvent = {
+        ok: false,
+        code: error.code,
+        reason: decision.reason,
+        ...error.httpStatus !== void 0 ? { httpStatus: error.httpStatus } : {},
+        ...error.requestId !== void 0 ? { requestId: error.requestId } : {}
+      };
+      if (!decision.retry) {
+        emit(stamp({ phase: "settled", ...settledEvent }));
+        return err(error);
+      }
+      emit(stamp({ phase: "retry", ...settledEvent, delayMs: decision.delayMs }));
+      await sleep(decision.delayMs, req.signal);
+      if (req.signal?.aborted === true) {
+        emit(stamp({ phase: "settled", ...settledEvent, reason: "aborted" }));
+        return err(error);
+      }
+      attempt += 1;
+    }
+  }
+  async function authorize(req) {
+    return withAuthHeaders(req, await resolveDeviceAuth(deps.auth));
+  }
+  async function* stream(call, req, signal) {
+    emit(
+      Object.freeze({
+        call,
+        phase: "stream.open",
+        method: req.method,
+        path: req.path,
+        attempt: 0
+      })
+    );
+    try {
+      yield* deps.auth.transport.stream(req, signal);
+    } catch {
+      yield errorFrame({
+        // The same wire spelling sse.ts synthesizes, so `fromWire` folds it to the retryable `internalError`
+        // like any other transport failure. wireMessage stays null: it is the SERVER's text, and a thrown
+        // host exception's `.message` is not that.
+        code: "internal_error",
+        retryable: true,
+        wireMessage: null,
+        synthesized: true,
+        lastEventId: null,
+        serverRequestId: null
+      });
+    }
+  }
+  return Object.freeze({ send, authorize, stream });
+}
+function assembleHeaders(req, idempotencyKey) {
+  const headers = {};
+  for (const [key, value] of Object.entries(req.headers ?? {})) {
+    if (key.toLowerCase() === IDEMPOTENCY_HEADER) continue;
+    headers[key] = value;
+  }
+  if (idempotencyKey !== null) headers["Idempotency-Key"] = idempotencyKey;
+  return { ...req, headers };
+}
+function defaultIdempotencyKeyFactory() {
+  let counter = 0;
+  return () => `efk_${Date.now().toString(36)}_${(counter++).toString(36)}_${Math.random().toString(36).slice(2, 12)}`;
+}
+var POLICY_MAX_ATTEMPTS_CAP = 10;
+function decideRetry(error, attempt, ctx) {
+  if (ctx.aborted) return { retry: false, reason: "aborted" };
+  const throttle = throttleKind(error);
+  if (throttle === "quota") {
+    return { retry: false, reason: "daily-quota-exhausted" };
+  }
+  if (throttle !== "burst" && !isAutoRetryable(error.code)) {
+    return { retry: false, reason: "terminal-code" };
+  }
+  const reason = throttle === "burst" ? "burst-throttle" : "retryable-code";
+  const policyVetoedRetry = () => {
+    if (ctx.policy === void 0) return false;
+    try {
+      return !ctx.policy.shouldRetry(error.code, attempt);
+    } catch {
+      return false;
+    }
+  };
+  if (policyVetoedRetry()) return { retry: false, reason: "terminal-code" };
+  const policyCeiling = () => {
+    if (ctx.policy === void 0) return null;
+    let raw;
+    try {
+      raw = ctx.policy.maxAttempts(error.code);
+    } catch {
+      return null;
+    }
+    if (typeof raw !== "number" || !Number.isFinite(raw)) return null;
+    return Math.max(1, Math.min(POLICY_MAX_ATTEMPTS_CAP, Math.floor(raw)));
+  };
+  const ceiling = ctx.perCallMaxAttempts ?? policyCeiling() ?? ctx.maxAttempts;
+  if (attempt + 1 >= ceiling) return { retry: false, reason: "attempts-exhausted" };
+  const override = retryOverrideMs(error, ctx.now);
+  if (override !== null) {
+    if (override > RETRY_OVERRIDE_MAX_MS) {
+      return { retry: false, reason: "server-reset-beyond-budget" };
+    }
+    return { retry: true, reason, delayMs: override };
+  }
+  return { retry: true, reason, delayMs: backoffDelayMs(attempt, ctx.rng) };
+}
+function throttleKind(error) {
+  const code = error.code === "unknown" ? fromWire(rawWireCode(error.raw)) : error.code;
+  if (code === "quotaExceeded") return "quota";
+  if (code === "rateLimited") return "burst";
+  if (error.httpStatus === 429) {
+    return "burst";
+  }
+  return null;
+}
+function retryOverrideMs(error, now) {
+  const at = findResetsAt(error.raw);
+  if (at === null) return null;
+  const delta = at - now;
+  return delta > 0 ? delta : 0;
+}
+function findResetsAt(raw) {
+  for (const scope of candidateScopes(raw)) {
+    const value = scope["resets_at"];
+    const parsed = parseInstantMs(value);
+    if (parsed !== null) return parsed;
+  }
+  return null;
+}
+function candidateScopes(raw) {
+  if (!isRecord(raw)) return [];
+  const out = [raw];
+  for (const nested of ["error", "detail"]) {
+    const value = raw[nested];
+    if (isRecord(value)) out.push(value);
+  }
+  return out;
+}
+function parseInstantMs(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value < 1e11 ? Math.round(value * 1e3) : Math.round(value);
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function rawWireCode(raw) {
+  for (const scope of candidateScopes(raw)) {
+    const code = scope["code"];
+    if (typeof code === "string" && code.length > 0) return code;
+  }
+  return null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+async function resolveDeviceAuth(auth) {
+  if (auth.mode === "anonymous") {
+    return {
+      mode: "anonymous",
+      publishableKey: auth.publishableKey,
+      userRef: auth.userRef,
+      ...auth.sessionId ? { sessionId: auth.sessionId } : {}
+    };
+  }
+  return {
+    mode: "personalized",
+    token: await auth.identity.currentToken(),
+    userRef: auth.userRef,
+    ...auth.sessionId ? { sessionId: auth.sessionId } : {}
+  };
+}
+function boundedSignal(ms, timers) {
+  const ctrl = new AbortController();
+  const handle = timers.setTimeout(() => ctrl.abort(), ms);
+  return { signal: ctrl.signal, cancel: () => timers.clearTimeout(handle) };
+}
+function mergeSignals(deadline2, caller) {
+  const noop = () => void 0;
+  if (!caller) return { signal: deadline2, dispose: noop };
+  const ctrl = new AbortController();
+  if (deadline2.aborted || caller.aborted) {
+    ctrl.abort();
+    return { signal: ctrl.signal, dispose: noop };
+  }
+  const onAbort = () => ctrl.abort();
+  deadline2.addEventListener("abort", onAbort, { once: true });
+  caller.addEventListener("abort", onAbort, { once: true });
+  return {
+    signal: ctrl.signal,
+    dispose: () => {
+      deadline2.removeEventListener("abort", onAbort);
+      caller.removeEventListener("abort", onAbort);
+    }
+  };
+}
+function delayAbortable(ms, timers, signal) {
+  if (ms <= 0 || signal?.aborted === true) return Promise.resolve();
+  return new Promise((resolve) => {
+    const handle = timers.setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      timers.clearTimeout(handle);
+      resolve();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/core/media/ports.ts
+var unavailableUpload = Object.freeze({
+  async presignedPut() {
+    return Promise.reject(new Error("UploadPort is unavailable; no presigned-upload adapter was injected"));
+  }
+});
+function delayAbortable2(ms, signal, timers) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const holder = { handle: void 0 };
+    const done = () => {
+      timers.clearTimeout(holder.handle);
+      signal.removeEventListener("abort", done);
+      resolve();
+    };
+    holder.handle = timers.setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+function mergeSignals2(a, b) {
+  if (!b) return a;
+  const ctrl = new AbortController();
+  if (a.aborted || b.aborted) {
+    ctrl.abort();
+    return ctrl.signal;
+  }
+  const onAbort = () => ctrl.abort();
+  a.addEventListener("abort", onAbort, { once: true });
+  b.addEventListener("abort", onAbort, { once: true });
+  return ctrl.signal;
+}
+var MediaStore = class {
+  constructor(initial) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.epoch = 0;
+    this.inFlight = null;
+    this.snapshot = Object.freeze({ ...initial });
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  patch(partial) {
+    this.snapshot = Object.freeze({ ...this.snapshot, ...partial });
+    for (const listener of this.listeners) listener();
+  }
+  beginOperation(external) {
+    this.inFlight?.abort();
+    const ctrl = new AbortController();
+    this.inFlight = ctrl;
+    const epoch = this.epoch;
+    const signal = external ? mergeSignals2(ctrl.signal, external) : ctrl.signal;
+    return {
+      signal,
+      epoch,
+      settle: () => {
+        if (this.inFlight === ctrl) this.inFlight = null;
+      }
+    };
+  }
+  alive(epoch) {
+    return epoch === this.epoch;
+  }
+  /** Re-scope on user/pet switch: aborts in-flight and bumps the epoch so a late write drops. */
+  rescope() {
+    this.epoch += 1;
+    this.inFlight?.abort();
+    this.inFlight = null;
+  }
+  /** Idempotent teardown: aborts in-flight, bumps the epoch, drops every listener. */
+  dispose() {
+    this.epoch += 1;
+    this.inFlight?.abort();
+    this.inFlight = null;
+    this.listeners.clear();
+  }
+};
+
+// src/core/chat/chatMappers.ts
+function makeUser(id, text) {
+  return Object.freeze({ id, role: "user", text, pending: true });
+}
+function makeAssistant(id, text) {
+  return Object.freeze({ id, role: "assistant", text });
+}
+function stripPending(m) {
+  return Object.freeze({ id: m.id, role: m.role, text: m.text });
+}
+function appendText(m, text) {
+  const next = {
+    id: m.id,
+    role: m.role,
+    text: m.text + text
+  };
+  if (m.citations) next.citations = m.citations;
+  if (m.responseId) next.responseId = m.responseId;
+  return Object.freeze(next);
+}
+function finalizeAssistant(m, done) {
+  const next = {
+    id: done.messageId ? done.messageId : m.id,
+    role: "assistant",
+    text: m.text
+  };
+  if (done.citations.length > 0) next.citations = done.citations;
+  if (done.messageId) next.responseId = brandResponseId(done.messageId);
+  return Object.freeze(next);
+}
+function freezeSnapshot(s) {
+  return Object.freeze({
+    status: s.status,
+    messages: Object.freeze([...s.messages]),
+    conversationId: s.conversationId,
+    error: s.error,
+    isStreaming: s.isStreaming,
+    isBootstrapping: s.isBootstrapping,
+    suggestedPrompts: Object.freeze([...s.suggestedPrompts])
+  });
+}
+function makeError(code, retryable, wireMessage) {
+  return makeEverfurError(code, { retryable, ...wireMessage ? { wireMessage } : {} });
+}
+function errorFromFrame(frame) {
+  const code = fromWire(frame.code);
+  return makeEverfurError(code, {
+    retryable: frame.retryable || shouldRetry(code),
+    wireCode: frame.code,
+    ...frame.serverRequestId ? { requestId: frame.serverRequestId } : {},
+    ...frame.wireMessage ? { wireMessage: frame.wireMessage } : {},
+    raw: frame
+  });
+}
+function synthErrorFrame(error) {
+  return errorFrame({
+    code: canonicalWireCode(error.code),
+    retryable: error.retryable,
+    wireMessage: error.wireMessage ?? null,
+    synthesized: true,
+    lastEventId: null,
+    serverRequestId: error.requestId ?? null
+  });
+}
+function canonicalWireCode(code) {
+  switch (code) {
+    case "authExpired":
+      return "AUTH_EXPIRED";
+    case "authRejected":
+      return "AuthorizationException";
+    case "sessionRequired":
+      return "session_required";
+    case "accessDenied":
+      return "ACCESS_DENIED";
+    case "paymentRequired":
+      return "TIER_UPGRADE_REQUIRED";
+    case "quotaExceeded":
+      return "QUOTA_EXCEEDED";
+    case "rateLimited":
+      return "RATE_LIMITED";
+    case "validationFailed":
+      return "ValidationException";
+    case "sdkUpdateRequired":
+      return "invalidRequest";
+    case "conflict":
+      return "ConflictException";
+    case "idempotencyConflict":
+      return "IDEMPOTENCY_CONFLICT";
+    case "idempotencyInFlight":
+      return "IDEMPOTENCY_KEY_IN_FLIGHT";
+    case "conversationNotFound":
+      return "CONVERSATION_NOT_FOUND";
+    case "petNotFound":
+      return "PET_NOT_FOUND";
+    case "resourceNotFound":
+      return "ResourceNotFoundException";
+    case "streamTimeout":
+      return "STREAM_TIMEOUT";
+    case "mediaUploadFailed":
+      return "MEDIA_UPLOAD_FAILED";
+    case "moderationBlocked":
+      return "MODERATION_BLOCKED";
+    case "upstreamLlmTimeout":
+      return "UPSTREAM_LLM_TIMEOUT";
+    case "internalError":
+      return "INTERNAL_ERROR";
+    case "notImplemented":
+      return "NotImplementedException";
+    case "serviceUnavailable":
+      return "ServiceUnavailableException";
+    case "streamIncomplete":
+      return "STREAM_INCOMPLETE";
+    case "unknown":
+      return "UNKNOWN";
+    default:
+      return assertNever(code);
+  }
+}
+function parsePromptCategories(raw) {
+  const list = Array.isArray(raw) ? raw : isPlainObject2(raw) && Array.isArray(raw["categories"]) ? raw["categories"] : [];
+  const out = [];
+  for (const entry of list) {
+    if (!isPlainObject2(entry)) continue;
+    const category = asStr(entry["category"]) ?? asStr(entry["title"]) ?? "";
+    const prompts = asPromptTextList(entry["prompts"] ?? entry["questions"]);
+    if (category.length === 0 && prompts.length === 0) continue;
+    out.push(Object.freeze({ category, prompts: Object.freeze(prompts) }));
+  }
+  return Object.freeze(out);
+}
+function flattenPrompts(categories) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const category of categories) {
+    for (const prompt of category.prompts) {
+      const trimmed = prompt.trim();
+      if (trimmed.length === 0 || seen.has(trimmed)) continue;
+      seen.add(trimmed);
+      out.push(trimmed);
+    }
+  }
+  return out;
+}
+function isPlainObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function asStr(v) {
+  return typeof v === "string" ? v : null;
+}
+function asPromptTextList(v) {
+  if (!Array.isArray(v)) return [];
+  const out = [];
+  for (const entry of v) {
+    if (typeof entry === "string") {
+      out.push(entry);
+    } else if (isPlainObject2(entry)) {
+      const text = asStr(entry["text"]) ?? asStr(entry["prompt"]) ?? asStr(entry["title"]);
+      if (text !== null) out.push(text);
+    }
+  }
+  return out;
+}
+function defaultIdFactory() {
+  let counter = 0;
+  return () => `m-${Date.now().toString(36)}-${(counter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function defaultIdempotencyFactory() {
+  let counter = 0;
+  return () => `chat-send-${Date.now().toString(36)}-${(counter++).toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function brandConversationId(raw) {
+  return raw;
+}
+function brandResponseId(raw) {
+  return raw;
+}
+
+// src/core/chat/watchdog.ts
+var defaultTimers2 = {
+  setTimeout: (handler, ms) => setTimeout(handler, ms),
+  clearTimeout: (handle) => clearTimeout(handle),
+  now: () => Date.now()
+};
+async function* withWatchdog(source, budget, signal, timers) {
+  const it = source[Symbol.asyncIterator]();
+  const overall = deadline(budget.overallMs, timers);
+  const idle = deadline(budget.idleMs, timers);
+  const abort = abortPromise(signal);
+  try {
+    for (; ; ) {
+      if (signal.aborted) return;
+      const nextTagged = it.next().then(
+        (value) => ({ tag: "next", value }),
+        // A rejected it.next() is a RAW mid-stream transport drop (WiFi->cellular, backgrounding), NOT a clean
+        // end-of-stream. The prior code coerced it to { done: true }, which silently short-circuited the SDK's
+        // own retry ladder (SPEC-10 §7). Tag it so the loop can emit a retryable frame instead.
+        () => ({ tag: "streamError" })
+      );
+      const outcome = await Promise.race([
+        nextTagged,
+        idle.promise.then(() => ({ tag: "idle" })),
+        overall.promise.then(() => ({ tag: "overall" })),
+        abort.then(() => ({ tag: "abort" }))
+      ]);
+      if (outcome.tag === "abort") return;
+      if (outcome.tag === "streamError") {
+        if (signal.aborted) return;
+        yield synthStreamErrorFrame();
+        return;
+      }
+      if (outcome.tag === "idle" || outcome.tag === "overall") {
+        yield synthTimeoutFrame();
+        return;
+      }
+      const result = outcome.value;
+      if (result.done) return;
+      idle.reset(budget.idleMs);
+      yield result.value;
+      if (result.value.terminal) return;
+    }
+  } finally {
+    idle.cancel();
+    overall.cancel();
+    void Promise.resolve(it.return?.(void 0)).catch(() => {
+    });
+  }
+}
+function synthTimeoutFrame() {
+  return errorFrame({
+    code: "STREAM_TIMEOUT",
+    retryable: true,
+    wireMessage: null,
+    synthesized: true,
+    lastEventId: null
+  });
+}
+function synthStreamErrorFrame() {
+  return errorFrame({
+    code: "STREAM_INCOMPLETE",
+    retryable: true,
+    wireMessage: null,
+    synthesized: true,
+    lastEventId: null
+  });
+}
+function deadline(ms, timers) {
+  let resolveFn = () => {
+  };
+  const promise = new Promise((resolve) => {
+    resolveFn = resolve;
+  });
+  let handle = timers.setTimeout(() => resolveFn(), ms);
+  return {
+    promise,
+    reset(next) {
+      timers.clearTimeout(handle);
+      handle = timers.setTimeout(() => resolveFn(), next);
+    },
+    cancel() {
+      timers.clearTimeout(handle);
+    }
+  };
+}
+function abortPromise(signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    signal.addEventListener("abort", () => resolve(), { once: true });
+  });
+}
+
+// src/core/chat/ChatController.ts
+var DEFAULT_IDLE_MS = 6e4;
+var DEFAULT_OVERALL_MS = 18e4;
+var DELTA_FLUSH_MS = 24;
+var DELTA_FLUSH_CHARS = 512;
+var SEND_IS_SERVER_DEDUPED = false;
+function createChatController(deps) {
+  return new ChatControllerImpl(deps);
+}
+var ChatControllerImpl = class extends MediaStore {
+  constructor(deps) {
+    super(
+      freezeSnapshot({
+        status: "idle",
+        messages: [],
+        conversationId: deps.initialConversationId ?? null,
+        error: null,
+        isStreaming: false,
+        isBootstrapping: false,
+        suggestedPrompts: []
+      })
+    );
+    this.handlerTeardowns = /* @__PURE__ */ new Set();
+    this.lastTurn = null;
+    this.lastResponseIdValue = null;
+    /** Delta coalescing buffer (PERF1): accumulated assistant text not yet flushed to the snapshot. */
+    this.pendingDelta = "";
+    this.flushHandle = null;
+    this.auth = deps.auth;
+    this.funnel = deps.funnel ?? createRequestFunnel({
+      auth: deps.auth,
+      ...deps.errorPolicy ? { errorPolicy: deps.errorPolicy } : {}
+    });
+    this.telemetry = deps.telemetry ?? noopTelemetry;
+    this.errorPolicy = deps.errorPolicy ?? defaultErrorPolicy;
+    this.timers = deps.timers ?? defaultTimers2;
+    this.rng = deps.rng ?? Math.random;
+    this.newId = deps.newId ?? defaultIdFactory();
+    this.makeIdempotencyKey = deps.makeIdempotencyKey ?? defaultIdempotencyFactory();
+    this.budget = {
+      idleMs: deps.budget?.idleMs ?? DEFAULT_IDLE_MS,
+      overallMs: deps.budget?.overallMs ?? DEFAULT_OVERALL_MS
+    };
+  }
+  // ---- store ------------------------------------------------------------
+  // subscribe / getSnapshot / beginOperation / alive are inherited from MediaStore. patch is overridden so the
+  // messages array stays deep-frozen (the base freezes only the snapshot object).
+  patch(partial) {
+    if (partial.messages !== void 0) {
+      const frozen = Object.freeze([...partial.messages]);
+      super.patch({ ...partial, messages: frozen });
+      return;
+    }
+    super.patch(partial);
+  }
+  send(text, opts, handlers) {
+    const options = opts ?? {};
+    const invalid2 = validateMessageText(text);
+    if (invalid2 !== null) {
+      this.telemetry.track("chat.send.rejected", { reason: invalid2.reason });
+      this.patch({ status: "error", isStreaming: false, error: invalid2.error });
+      if (handlers) {
+        handlers.onError(invalid2.error);
+        return () => {
+        };
+      }
+      return singleFrameStream(synthErrorFrame(invalid2.error));
+    }
+    if (handlers) return this.driveWithHandlers(text, options, handlers);
+    const turn = this.beginTurn(text, options);
+    return this.runTurn(turn, options.signal);
+  }
+  retryLast() {
+    const turn = this.lastTurn;
+    if (turn === null) return emptyStream();
+    turn.assistantMessageId = null;
+    turn.sawDelta = false;
+    turn.conversationIdOverride = null;
+    this.discardPendingDelta();
+    const hasUser = this.snapshot.messages.some((m) => m.id === turn.userMessageId);
+    const messages = hasUser ? this.snapshot.messages : [...this.snapshot.messages, makeUser(turn.userMessageId, turn.text)];
+    this.patch({ error: null, messages });
+    return this.runTurn(turn, void 0);
+  }
+  stop() {
+    this.inFlight?.abort();
+    this.inFlight = null;
+    this.discardPendingDelta();
+    this.telemetry.track("chat.cancel", {});
+    const messages = this.snapshot.messages.filter((m) => !(m.role === "user" && m.pending === true));
+    const changed = messages.length !== this.snapshot.messages.length;
+    if (this.snapshot.status === "streaming" || changed) {
+      this.patch({ status: "idle", isStreaming: false, ...changed ? { messages } : {} });
+    }
+  }
+  rescope() {
+    super.rescope();
+    this.discardPendingDelta();
+    if (this.snapshot.status === "streaming") this.patch({ status: "idle", isStreaming: false });
+  }
+  dispose() {
+    this.discardPendingDelta();
+    for (const teardown of this.handlerTeardowns) teardown();
+    this.handlerTeardowns.clear();
+    super.dispose();
+  }
+  adoptConversation(id) {
+    if (this.snapshot.conversationId === id) return;
+    this.patch({ conversationId: id });
+  }
+  adoptPrompts(categories) {
+    const prompts = flattenPrompts(categories);
+    if (prompts.length === 0 && this.snapshot.suggestedPrompts.length === 0) return;
+    this.patch({ suggestedPrompts: Object.freeze(prompts) });
+  }
+  // ---- unary bootstrap helpers (§8) -------------------------------------
+  async createConversation(opts) {
+    return this.createConversationBounded(opts?.petRef ?? null);
+  }
+  /** The bounded create used by both the public helper and the turn pipeline (a caller signal ties it to op). */
+  async createConversationBounded(petRef2, signal) {
+    const req = {
+      method: "POST",
+      path: "/widget/v1/conversations",
+      body: petRef2 ? { pet_ref: petRef2 } : {}
+    };
+    const res = await this.authedUnary(
+      "chat.createConversation",
+      req,
+      signal,
+      // The widget lane does NOT read `Idempotency-Key`: its router is a plain APIRouter with no
+      // idempotency route class, so a replay is a second CREATE, not a dedup, and retrying leaves the
+      // partner with orphan threads nobody asked for. `maxAttempts: 1` stops the replay.
+      //
+      // The key itself is deliberately STILL SENT (no `idempotent: false`): it costs nothing on the wire,
+      // it is what the funnel would mint anyway, and it starts working by itself the day the route dedups.
+      // Deleting this one option is then the whole reversal.
+      { maxAttempts: 1 }
+    );
+    if (!res.ok) return err(res.error);
+    const raw = res.value?.conversation_id ?? res.value?.id;
+    if (typeof raw !== "string" || raw.length === 0) {
+      return err(makeError("internalError", true));
+    }
+    return ok(brandConversationId(raw));
+  }
+  async getPrompts(opts) {
+    const petRef2 = opts?.petRef ?? null;
+    if (petRef2 !== null && hasLoneSurrogate(petRef2)) {
+      return err(
+        makeEverfurError("validationFailed", {
+          retryable: false,
+          wireMessage: "pet_ref contains an unpaired surrogate and cannot be encoded"
+        })
+      );
+    }
+    const query = petRef2 !== null ? `?pet_ref=${encodeURIComponent(petRef2)}` : "";
+    const res = await this.authedUnary("chat.getPrompts", {
+      method: "GET",
+      path: `/widget/v1/suggested-prompts${query}`
+    });
+    if (!res.ok) return err(res.error);
+    return ok(parsePromptCategories(res.value));
+  }
+  /**
+   * A unary authed hop, through the ONE REQUEST FUNNEL. The funnel owns the per-attempt deadline (PERF2:
+   * a stalled connection settles to a retryable error instead of hanging the spinner forever), the auth
+   * spine, retry with full jitter, the client-minted idempotency key, and telemetry. Settles; never throws.
+   */
+  async authedUnary(call, req, external, opts) {
+    return this.funnel.send(call, external ? { ...req, signal: external } : req, opts);
+  }
+  // ---- imperative escape hatch ------------------------------------------
+  driveWithHandlers(text, opts, handlers) {
+    const cancel = new AbortController();
+    const signal = mergeSignals2(cancel.signal, opts.signal);
+    const turn = this.beginTurn(text, opts);
+    const iterable = this.runTurn(turn, signal);
+    let torn = false;
+    const teardown = () => {
+      if (torn) return;
+      torn = true;
+      cancel.abort();
+      this.handlerTeardowns.delete(teardown);
+    };
+    this.handlerTeardowns.add(teardown);
+    void (async () => {
+      for await (const frame of iterable) {
+        if (torn) break;
+        handlers.onFrame(frame);
+        if (frame.kind === "done") handlers.onDone(this.lastResponseIdValue);
+      }
+      if (!torn && this.snapshot.status === "error" && this.snapshot.error !== null) {
+        handlers.onError(this.snapshot.error);
+      }
+      this.handlerTeardowns.delete(teardown);
+    })();
+    return teardown;
+  }
+  // ---- the turn pipeline ------------------------------------------------
+  beginTurn(text, opts) {
+    const turn = {
+      epoch: this.epoch,
+      text,
+      petRef: opts.petRef ?? null,
+      idempotencyKey: opts.idempotencyKey ?? this.makeIdempotencyKey(),
+      userMessageId: this.newId(),
+      assistantMessageId: null,
+      sawDelta: false,
+      conversationIdOverride: opts.conversationId ?? null
+    };
+    this.patch({
+      error: null,
+      messages: [...this.snapshot.messages, makeUser(turn.userMessageId, text)]
+    });
+    return turn;
+  }
+  async *runTurn(turn, external) {
+    const op = this.beginOperation(external);
+    turn.epoch = op.epoch;
+    this.patch({ status: "streaming", isStreaming: true, error: null });
+    this.lastTurn = turn;
+    let retries = 0;
+    let recreated = false;
+    let refreshedOnce = false;
+    try {
+      for (; ; ) {
+        if (op.signal.aborted || !this.alive(op.epoch)) return;
+        const needsConversation = turn.conversationIdOverride === null && this.snapshot.conversationId === null;
+        if (needsConversation) {
+          const created = await this.createConversationBounded(turn.petRef, op.signal);
+          if (op.signal.aborted || !this.alive(op.epoch)) return;
+          if (!created.ok) {
+            yield* this.emitTerminal(turn, created.error, synthErrorFrame(created.error));
+            return;
+          }
+          this.adoptConversation(created.value);
+        }
+        const convId = turn.conversationIdOverride ?? this.snapshot.conversationId;
+        if (convId === null) {
+          const e = makeError("internalError", true);
+          yield* this.emitTerminal(turn, e, synthErrorFrame(e));
+          return;
+        }
+        this.clearAssistantInProgress(turn);
+        const attemptCtrl = new AbortController();
+        const attemptSignal = mergeSignals2(op.signal, attemptCtrl.signal);
+        let terminalError = null;
+        try {
+          let authedReq;
+          try {
+            authedReq = await this.funnel.authorize(this.buildSendRequest(turn, convId));
+          } catch {
+            const e = this.authRejected();
+            yield* this.emitTerminal(turn, e, synthErrorFrame(e));
+            return;
+          }
+          if (op.signal.aborted || !this.alive(op.epoch)) return;
+          const source = this.funnel.stream("chat.send", authedReq, attemptSignal);
+          for await (const frame of withWatchdog(source, this.budget, attemptSignal, this.timers)) {
+            if (!this.alive(op.epoch)) return;
+            if (frame.kind === "error" && frame.terminal) {
+              terminalError = frame;
+              break;
+            }
+            this.applyFrame(frame, turn);
+            yield frame;
+            if (frame.terminal) {
+              op.settle();
+              return;
+            }
+          }
+        } finally {
+          attemptCtrl.abort();
+        }
+        if (op.signal.aborted || !this.alive(op.epoch)) return;
+        if (terminalError === null) {
+          if (this.snapshot.status === "complete") return;
+          const e = makeError("streamIncomplete", true);
+          yield* this.emitTerminal(turn, e, synthErrorFrame(e));
+          return;
+        }
+        const code = fromWire(terminalError.code);
+        if (code === "authExpired" && this.auth.mode === "personalized" && !refreshedOnce) {
+          refreshedOnce = true;
+          this.telemetry.track("chat.auth.refresh", {});
+          const refreshed = await this.tryForceRefresh();
+          if (op.signal.aborted || !this.alive(op.epoch)) return;
+          if (!refreshed) {
+            const e = this.authRejected();
+            yield* this.emitTerminal(turn, e, terminalError);
+            return;
+          }
+          continue;
+        }
+        if (code === "authExpired") {
+          this.telemetry.track("chat.auth.rejected", {});
+          const e = this.authRejected();
+          yield* this.emitTerminal(turn, e, terminalError);
+          return;
+        }
+        if (code === "accessDenied") {
+          this.telemetry.track("chat.access_denied", {});
+          yield* this.emitTerminal(turn, errorFromFrame(terminalError), terminalError);
+          return;
+        }
+        if (canRecreateOnNotFound(code) && !recreated) {
+          recreated = true;
+          this.telemetry.track("chat.conv.recreate", {});
+          this.adoptConversation(null);
+          turn.conversationIdOverride = null;
+          continue;
+        }
+        const framedRetry = terminalError.retryable && shouldRetry(code, true);
+        if (SEND_IS_SERVER_DEDUPED && framedRetry && retries + 1 < this.errorPolicy.maxAttempts(code)) ;
+        yield* this.emitTerminal(turn, errorFromFrame(terminalError), terminalError);
+        return;
+      }
+    } finally {
+      op.settle();
+    }
+  }
+  *emitTerminal(turn, error, frame) {
+    this.applyError(turn, error);
+    yield frame;
+  }
+  // ---- frame -> state ---------------------------------------------------
+  applyFrame(frame, turn) {
+    switch (frame.kind) {
+      case "accepted":
+        if (!this.snapshot.isStreaming) this.patch({ status: "streaming", isStreaming: true });
+        return;
+      case "heartbeat":
+        return;
+      // silent; the watchdog resets its idle timer on any frame
+      case "delta":
+        this.applyDelta(frame.delta, turn);
+        return;
+      case "done":
+        this.applyDone(frame, turn);
+        return;
+      case "analysisStarted":
+      case "analysisComplete":
+        return;
+      // not part of chat render (analyze streams project elsewhere)
+      case "unknown":
+        this.telemetry.track("chat.frame.unknown", {});
+        return;
+      // forward-compat: ignore for render, keep streaming, never crash
+      case "error":
+        return;
+      // terminal errors are driven by the recovery switch, never here
+      default:
+        return assertNever(frame);
+    }
+  }
+  applyDelta(text, turn) {
+    if (turn.assistantMessageId === null) {
+      const assistantId = this.newId();
+      turn.assistantMessageId = assistantId;
+      turn.sawDelta = true;
+      const cleared = this.snapshot.messages.map(
+        (m) => m.id === turn.userMessageId && m.pending === true ? stripPending(m) : m
+      );
+      this.patch({
+        status: "streaming",
+        isStreaming: true,
+        messages: [...cleared, makeAssistant(assistantId, text)]
+      });
+      return;
+    }
+    this.pendingDelta += text;
+    if (this.pendingDelta.length >= DELTA_FLUSH_CHARS) {
+      this.flushPendingDelta(turn);
+      return;
+    }
+    this.scheduleDeltaFlush(turn);
+  }
+  scheduleDeltaFlush(turn) {
+    if (this.flushHandle !== null) return;
+    const scheduledEpoch = this.epoch;
+    this.flushHandle = this.timers.setTimeout(() => {
+      this.flushHandle = null;
+      if (!this.alive(scheduledEpoch)) {
+        this.pendingDelta = "";
+        return;
+      }
+      this.flushPendingDelta(turn);
+    }, DELTA_FLUSH_MS);
+  }
+  /** Fold the buffered deltas into the streaming assistant message as ONE patch (one listener notification). */
+  flushPendingDelta(turn) {
+    this.clearFlushTimer();
+    if (this.pendingDelta.length === 0) return;
+    const chunk = this.pendingDelta;
+    this.pendingDelta = "";
+    const assistantId = turn.assistantMessageId;
+    if (assistantId === null) return;
+    const messages = this.snapshot.messages.map((m) => m.id === assistantId ? appendText(m, chunk) : m);
+    this.patch({ messages });
+  }
+  /** Drop a buffered-but-unflushed delta (cancel / rescope / dispose / retry): no stale text leaks forward. */
+  discardPendingDelta() {
+    this.clearFlushTimer();
+    this.pendingDelta = "";
+  }
+  clearFlushTimer() {
+    if (this.flushHandle !== null) {
+      this.timers.clearTimeout(this.flushHandle);
+      this.flushHandle = null;
+    }
+  }
+  applyDone(done, turn) {
+    this.flushPendingDelta(turn);
+    this.lastResponseIdValue = done.messageId ? brandResponseId(done.messageId) : null;
+    const nextConv = done.conversationId ? brandConversationId(done.conversationId) : this.snapshot.conversationId;
+    let messages;
+    if (turn.assistantMessageId !== null) {
+      messages = this.snapshot.messages.map(
+        (m) => m.id === turn.assistantMessageId ? finalizeAssistant(m, done) : m
+      );
+    } else {
+      const assistantId = this.newId();
+      turn.assistantMessageId = assistantId;
+      turn.sawDelta = true;
+      const cleared = this.snapshot.messages.map(
+        (m) => m.id === turn.userMessageId && m.pending === true ? stripPending(m) : m
+      );
+      messages = [...cleared, finalizeAssistant(makeAssistant(assistantId, ""), done)];
+    }
+    this.patch({
+      status: "complete",
+      isStreaming: false,
+      error: null,
+      conversationId: nextConv,
+      messages
+    });
+  }
+  applyError(turn, error) {
+    this.flushPendingDelta(turn);
+    this.errorPolicy.onExpectedFailure?.(error);
+    const messages = turn.sawDelta ? this.snapshot.messages : this.snapshot.messages.filter((m) => m.id !== turn.userMessageId);
+    this.patch({ status: "error", isStreaming: false, error, messages });
+  }
+  clearAssistantInProgress(turn) {
+    this.discardPendingDelta();
+    if (turn.assistantMessageId === null) return;
+    const assistantId = turn.assistantMessageId;
+    turn.assistantMessageId = null;
+    turn.sawDelta = false;
+    const messages = this.snapshot.messages.filter((m) => m.id !== assistantId);
+    if (messages.length !== this.snapshot.messages.length) this.patch({ messages });
+  }
+  // ---- auth + request build --------------------------------------------
+  buildSendRequest(turn, convId) {
+    const body = { message: turn.text };
+    return {
+      method: "POST",
+      path: `/widget/v1/conversations/${convId}/messages`,
+      body,
+      // The TURN's own key, not a funnel mint. This is the streaming path, which the funnel deliberately
+      // leaves alone, and the key is the identity of one logical turn: the same value is replayed by the
+      // 404 recreate-and-resend and by the mid-stream refresh replay, so neither duplicates the user's
+      // message. It is SDK-minted (`defaultIdempotencyFactory`), never taken from partner code.
+      headers: { "Idempotency-Key": turn.idempotencyKey }
+    };
+  }
+  async tryForceRefresh() {
+    if (this.auth.mode !== "personalized") return false;
+    try {
+      await this.auth.identity.currentToken({ forceRefresh: true });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  authRejected() {
+    return makeError("authRejected", false);
+  }
+};
+var MESSAGE_MAX_CHARS = 4e3;
+function validateMessageText(text) {
+  const raw = typeof text === "string" ? text : "";
+  if (raw.trim().length === 0) {
+    return { reason: "empty", error: makeError("validationFailed", false, "message is empty or whitespace-only") };
+  }
+  const codePoints = [...raw].length;
+  if (codePoints > MESSAGE_MAX_CHARS) {
+    return {
+      reason: "too_long",
+      error: makeError(
+        "validationFailed",
+        false,
+        `message is ${codePoints} characters; the server accepts at most ${MESSAGE_MAX_CHARS}`
+      )
+    };
+  }
+  return null;
+}
+async function* singleFrameStream(frame) {
+  yield frame;
+}
+async function* emptyStream() {
+}
+
+// src/core/bootstrap.ts
+async function bootstrapChat(input, deps) {
+  const { controller } = deps;
+  const petRef2 = input.petRef ?? null;
+  const resume = input.resumeConversationId ?? null;
+  const candidateConversationIds = [];
+  let sawForbidden = false;
+  let sawUnauthorized = false;
+  let sawConversationInitFailure = false;
+  let authBlock = null;
+  const conversationPromise = resume ? Promise.resolve(ok(resume)) : controller.createConversation(petRef2 ? { petRef: petRef2 } : void 0);
+  const promptsPromise = controller.getPrompts(petRef2 !== null ? { petRef: petRef2 } : void 0);
+  const [conversationRes, initialPromptsRes] = await Promise.all([conversationPromise, promptsPromise]);
+  let conversationId2 = null;
+  if (conversationRes.ok) {
+    conversationId2 = conversationRes.value;
+    candidateConversationIds.push(conversationRes.value);
+    controller.adoptConversation(conversationRes.value);
+  } else {
+    const e = conversationRes.error;
+    if (isUnauthorized(e)) {
+      sawUnauthorized = true;
+      authBlock = e;
+    } else if (isForbidden(e)) {
+      sawForbidden = true;
+      sawConversationInitFailure = true;
+    } else {
+      sawConversationInitFailure = true;
+    }
+  }
+  let suggestedPrompts = [];
+  if (initialPromptsRes.ok) {
+    suggestedPrompts = initialPromptsRes.value;
+  } else {
+    recordAuthSignals(initialPromptsRes.error);
+  }
+  function recordAuthSignals(e) {
+    if (isUnauthorized(e)) {
+      sawUnauthorized = true;
+      if (authBlock === null) authBlock = e;
+    } else if (isForbidden(e)) {
+      sawForbidden = true;
+    }
+  }
+  const error = authBlock !== null ? authBlock.displayMessage : null;
+  const warning = error === null && conversationId2 === null && sawConversationInitFailure ? CONVERSATION_NOT_PRIMED_WARNING : null;
+  return Object.freeze({
+    conversationId: conversationId2,
+    petRef: petRef2,
+    suggestedPrompts,
+    error,
+    warning,
+    diagnostics: Object.freeze({
+      candidateConversationIds: Object.freeze([...candidateConversationIds]),
+      sawForbidden,
+      sawUnauthorized,
+      sawConversationInitFailure
+    })
+  });
+}
+var CONVERSATION_NOT_PRIMED_WARNING = "Chat is ready. Your first message will start the conversation.";
+function isUnauthorized(e) {
+  return e.httpStatus === 401 || e.code === "authExpired" || e.code === "authRejected";
+}
+function isForbidden(e) {
+  return e.httpStatus === 403 || e.code === "accessDenied";
+}
+
+// src/client/pets/petsRepository.ts
+var PET_NAME_MAX = 100;
+var PET_SPECIES_MAX = 50;
+var PET_BREED_MAX = 100;
+var PET_AGE_YEARS_MAX = 50;
+var PET_WEIGHT_KG_MAX = 500;
+var PET_REF_MAX = 128;
+function invalid(wireMessage) {
+  return makeEverfurError("validationFailed", { retryable: false, wireMessage });
+}
+function checkString(field, value, max) {
+  if (typeof value !== "string") return invalid(`${field} must be a string`);
+  const length = serverLength(value);
+  if (length <= max) return null;
+  return invalid(`${field} is ${length} characters; the server accepts at most ${max}`);
+}
+function outOfRange(field, value, max) {
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= max) return null;
+  return invalid(`${field} must be a finite number between 0 and ${max}`);
+}
+function validate(petRef2, profile) {
+  if (typeof petRef2 !== "string") return invalid("pet_ref must be a string");
+  if (petRef2.trim().length === 0) return invalid("pet_ref must not be blank");
+  if (hasLoneSurrogate(petRef2)) return invalid("pet_ref contains an unpaired surrogate and cannot be encoded");
+  if (profile !== void 0 && profile !== null && typeof profile !== "object") {
+    return invalid("profile must be an object");
+  }
+  const checks = [checkString("pet_ref", petRef2, PET_REF_MAX)];
+  if (profile?.name !== void 0) checks.push(checkString("name", profile.name, PET_NAME_MAX));
+  if (profile?.species !== void 0) checks.push(checkString("species", profile.species, PET_SPECIES_MAX));
+  if (profile?.breed !== void 0) checks.push(checkString("breed", profile.breed, PET_BREED_MAX));
+  if (profile?.ageYears !== void 0) checks.push(outOfRange("age_years", profile.ageYears, PET_AGE_YEARS_MAX));
+  if (profile?.weightKg !== void 0) checks.push(outOfRange("weight_kg", profile.weightKg, PET_WEIGHT_KG_MAX));
+  return checks.find((c) => c !== null) ?? null;
+}
+function toWire(profile) {
+  if (profile === void 0 || profile === null) return {};
+  return {
+    ...profile.name !== void 0 ? { name: profile.name } : {},
+    ...profile.species !== void 0 ? { species: profile.species } : {},
+    ...profile.breed !== void 0 ? { breed: profile.breed } : {},
+    ...profile.ageYears !== void 0 ? { age_years: profile.ageYears } : {},
+    ...profile.weightKg !== void 0 ? { weight_kg: profile.weightKg } : {}
+  };
+}
+function fromWire2(raw, petRef2) {
+  const o = typeof raw === "object" && raw !== null ? raw : {};
+  const str = (v) => typeof v === "string" ? v : null;
+  const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+  return Object.freeze({
+    petRef: str(o["pet_ref"]) ?? petRef2,
+    name: str(o["name"]),
+    species: str(o["species"]),
+    breed: str(o["breed"]),
+    ageYears: num(o["age_years"]),
+    weightKg: num(o["weight_kg"])
+  });
+}
+function createPetsRepository(auth) {
+  return createPetsRepositoryOver(createRequestFunnel({ auth }));
+}
+function createPetsRepositoryOver(funnel) {
+  return {
+    async registerPet(petRef2, profile, opts) {
+      const invalid2 = validate(petRef2, profile);
+      if (invalid2 !== null) return err(invalid2);
+      const path = `/widget/v1/pets/${encodeURIComponent(petRef2)}`;
+      const base = { method: "POST", path, body: toWire(profile) };
+      const res = await funnel.send(
+        "pets.registerPet",
+        opts?.signal ? { ...base, signal: opts.signal } : base
+      );
+      if (!res.ok) return err(res.error);
+      return ok(fromWire2(res.value, petRef2));
+    }
+  };
+}
+
+// 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 deniedDecisionsFor(level, reason) {
+  const disabled = Object.freeze({ reason, level, recoverable: false });
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of Object.keys(REQUIRES)) {
+    for (const resource of REQUIRES[name]) {
+      if (seen.has(resource)) continue;
+      seen.add(resource);
+      rows.push(Object.freeze({ resource, granted: false, disabled }));
+    }
+  }
+  return Object.freeze(rows);
+}
+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)"
+};
+var EVERFUR_DARK = deepFreeze({
+  brightness: "dark",
+  meta: { displayName: "Everfur", logoUrl: null, placeholder: null, hidePoweredBy: false },
+  color: DARK_COLOR,
+  space: SPACE,
+  radius: RADIUS,
+  type: baseType(),
+  motion: MOTION
+});
+
+// src/client/theme/resolve.ts
+function isEmptyBranding(b) {
+  return b.displayName === null && b.logoUrl === null && b.primaryColor === null && b.accentColor === null && b.brightness === null && b.fontFamily === null && b.fontUrl === null && b.placeholder === null && b.hidePoweredBy === null;
+}
+function parseClientBranding(json) {
+  if (json === null || typeof json !== "object") return null;
+  const raw = json;
+  const branding = {
+    displayName: parseNonEmptyString(pick(raw, "display_name", "displayName")),
+    logoUrl: parseNonEmptyString(pick(raw, "logo_url", "logoUrl")),
+    primaryColor: parseColor(pick(raw, "primary_color", "primaryColor")),
+    accentColor: parseColor(pick(raw, "accent_color", "accentColor")),
+    brightness: parseBrightness(pick(raw, "brightness")),
+    fontFamily: parseNonEmptyString(pick(raw, "font_family", "fontFamily")),
+    fontUrl: parseNonEmptyString(pick(raw, "font_url", "fontUrl")),
+    placeholder: parseNonEmptyString(pick(raw, "chat_placeholder", "placeholder", "chatPlaceholder")),
+    hidePoweredBy: parseBool(pick(raw, "hide_powered_by", "hidePoweredBy"))
+  };
+  return isEmptyBranding(branding) ? null : Object.freeze(branding);
+}
+function parseBool(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const lower = value.trim().toLowerCase();
+    if (lower === "true") return true;
+    if (lower === "false") return false;
+  }
+  return null;
+}
+function pick(raw, ...keys) {
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(raw, key)) {
+      const value = raw[key];
+      if (value !== void 0) return value;
+    }
+  }
+  return void 0;
+}
+function parseNonEmptyString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length === 0 ? null : trimmed;
+}
+function parseBrightness(value) {
+  if (typeof value !== "string") return null;
+  const lower = value.trim().toLowerCase();
+  return lower === "light" || lower === "dark" ? lower : null;
+}
+function parseColor(value) {
+  const rgba = toRgba(value);
+  return rgba === null ? null : normalizeRgba(rgba);
+}
+function toRgba(value) {
+  if (typeof value === "number") return argbIntToRgba(value);
+  if (typeof value !== "string") return null;
+  const s = value.trim();
+  if (s.length === 0) return null;
+  if (s.startsWith("#")) return fromHex(s.slice(1));
+  if (s.toLowerCase().startsWith("0x")) return fromArgbHex(s.slice(2));
+  if (s.toLowerCase().startsWith("rgb")) return fromRgbFunc(s);
+  if (/^[0-9a-fA-F]+$/.test(s)) {
+    const hex = fromHex(s);
+    if (hex !== null) return hex;
+  }
+  if (/^\d+$/.test(s)) return argbIntToRgba(Number.parseInt(s, 10));
+  return null;
+}
+function fromHex(hex) {
+  const h = hex.trim();
+  if (!/^[0-9a-fA-F]+$/.test(h)) return null;
+  if (h.length === 3) {
+    const r = dup(h[0]);
+    const g = dup(h[1]);
+    const b = dup(h[2]);
+    return { r, g, b, a: 1 };
+  }
+  if (h.length === 6) {
+    return { r: byte(h, 0), g: byte(h, 2), b: byte(h, 4), a: 1 };
+  }
+  if (h.length === 8) {
+    const a = byte(h, 0);
+    return { r: byte(h, 2), g: byte(h, 4), b: byte(h, 6), a: a / 255 };
+  }
+  return null;
+}
+function fromArgbHex(hex) {
+  return fromHex(hex);
+}
+function fromRgbFunc(input) {
+  const open = input.indexOf("(");
+  const close = input.indexOf(")");
+  if (open < 0 || close < 0 || close < open) return null;
+  const parts = input.slice(open + 1, close).split(",").map((p) => p.trim());
+  if (parts.length < 3) return null;
+  const r = clampByte(Number(parts[0]));
+  const g = clampByte(Number(parts[1]));
+  const b = clampByte(Number(parts[2]));
+  if (r === null || g === null || b === null) return null;
+  let a = 1;
+  if (parts.length >= 4) {
+    const alpha = Number(parts[3]);
+    if (!Number.isFinite(alpha)) return null;
+    a = Math.min(1, Math.max(0, alpha));
+  }
+  return { r, g, b, a };
+}
+function argbIntToRgba(n) {
+  if (!Number.isFinite(n)) return null;
+  const int = Math.trunc(n) >>> 0;
+  const a = int >>> 24 & 255;
+  return {
+    r: int >>> 16 & 255,
+    g: int >>> 8 & 255,
+    b: int & 255,
+    // A 0x00RRGGBB with no alpha byte reads as fully transparent; treat a zero alpha byte as opaque so a
+    // bare 0xRRGGBB (or small decimal) is not silently invisible.
+    a: a === 0 ? 1 : a / 255
+  };
+}
+function byte(hex, at) {
+  return Number.parseInt(hex.slice(at, at + 2), 16);
+}
+function dup(nibble) {
+  return Number.parseInt(`${nibble ?? "0"}${nibble ?? "0"}`, 16);
+}
+function clampByte(n) {
+  if (!Number.isFinite(n)) return null;
+  return Math.min(255, Math.max(0, Math.round(n)));
+}
+function normalizeRgba(rgba) {
+  if (rgba.a >= 1) {
+    return `#${hex2(rgba.r)}${hex2(rgba.g)}${hex2(rgba.b)}`.toUpperCase();
+  }
+  const a = Math.round(rgba.a * 1e3) / 1e3;
+  return `rgba(${rgba.r},${rgba.g},${rgba.b},${a})`;
+}
+function hex2(n) {
+  return n.toString(16).padStart(2, "0");
+}
+var NEAR_BLACK = "#111111";
+var WHITE = "#FFFFFF";
+function readableOn(background) {
+  const rgba = toRgba(background);
+  if (rgba === null) return WHITE;
+  const bg = relativeLuminance(rgba);
+  const black = relativeLuminance({ r: 17, g: 17, b: 17});
+  const white = relativeLuminance({ r: 255, g: 255, b: 255});
+  const contrastBlack = contrastRatio(bg, black);
+  const contrastWhite = contrastRatio(bg, white);
+  return contrastWhite >= contrastBlack ? WHITE : NEAR_BLACK;
+}
+function relativeLuminance(rgba) {
+  const r = linearize(rgba.r / 255);
+  const g = linearize(rgba.g / 255);
+  const b = linearize(rgba.b / 255);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function linearize(channel) {
+  return channel <= 0.03928 ? channel / 12.92 : Math.pow((channel + 0.055) / 1.055, 2.4);
+}
+function contrastRatio(l1, l2) {
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function hardenHttpsUrl(url) {
+  if (url === null) return null;
+  const trimmed = url.trim();
+  if (trimmed.length === 0) return null;
+  return /^https:\/\/\S+$/i.test(trimmed) ? trimmed : null;
+}
+function withServerBranding(base, b) {
+  if (b === null || isEmptyBranding(b)) return base;
+  const palette = b.brightness !== null && b.brightness !== base.brightness ? b.brightness === "dark" ? EVERFUR_DARK : EVERFUR_LIGHT : base;
+  const primary = b.primaryColor ?? palette.color.primary;
+  const accent = b.accentColor ?? palette.color.accent;
+  const pr = b.primaryColor !== null ? toRgba(primary) : null;
+  const lift = (c) => Math.round(c + (255 - c) * 0.4);
+  const brandFamily = pr !== null ? {
+    brand: primary,
+    bubbleUser: primary,
+    text: { ...palette.color.text, secondary: primary },
+    brandSoft: `rgba(${pr.r}, ${pr.g}, ${pr.b}, 0.10)`,
+    brandSofter: `rgba(${pr.r}, ${pr.g}, ${pr.b}, 0.15)`,
+    brandBorder: `rgba(${pr.r}, ${pr.g}, ${pr.b}, 0.20)`,
+    borderHairlineGreen: `rgba(${pr.r}, ${pr.g}, ${pr.b}, 0.28)`,
+    accentEdge: `rgb(${lift(pr.r)}, ${lift(pr.g)}, ${lift(pr.b)})`
+  } : {};
+  const next = {
+    brightness: palette.brightness,
+    meta: {
+      displayName: b.displayName ?? palette.meta.displayName,
+      logoUrl: b.logoUrl ?? palette.meta.logoUrl,
+      placeholder: b.placeholder ?? palette.meta.placeholder,
+      hidePoweredBy: b.hidePoweredBy ?? palette.meta.hidePoweredBy
+    },
+    color: {
+      ...palette.color,
+      ...brandFamily,
+      primary,
+      accent,
+      // onPrimary/onAccent are recomputed by resolveTheme; carry the palette defaults for a standalone call.
+      onPrimary: palette.color.onPrimary,
+      onAccent: palette.color.onAccent
+    },
+    space: palette.space,
+    radius: palette.radius,
+    type: {
+      ...palette.type,
+      family: b.fontFamily ?? palette.type.family,
+      fontUrl: b.fontUrl ?? palette.type.fontUrl
+    },
+    motion: palette.motion
+  };
+  return deepFreeze(next);
+}
+var DEFAULT_DISPLAY_NAME = "Everfur";
+function resolveTheme(input) {
+  const scheme = input?.colorScheme === "dark" ? "dark" : "light";
+  const systemBase = scheme === "dark" ? EVERFUR_DARK : EVERFUR_LIGHT;
+  const withClient = withServerBranding(systemBase, input?.clientOverride ?? null);
+  const merged = withServerBranding(withClient, input?.branding ?? null);
+  return finalize(merged, input?.reducedMotion === true);
+}
+function finalize(theme, reducedMotion) {
+  const primary = theme.color.primary;
+  const accent = theme.color.accent;
+  const displayName = theme.meta.displayName.trim().length === 0 ? DEFAULT_DISPLAY_NAME : theme.meta.displayName;
+  const logoUrl = hardenHttpsUrl(theme.meta.logoUrl);
+  const fontUrl = hardenHttpsUrl(theme.type.fontUrl);
+  const motion = reducedMotion ? {
+    duration: { instant: 0, fast: 0, normal: 0, slow: 0 },
+    // Stiffen the spring so it settles immediately with no perceptible bounce.
+    spring: { gentle: { damping: 100, stiffness: 1e3 } },
+    easing: theme.motion.easing,
+    reducedMotion: true
+  } : theme.motion;
+  const finalized = {
+    brightness: theme.brightness,
+    meta: { displayName, logoUrl, placeholder: theme.meta.placeholder, hidePoweredBy: theme.meta.hidePoweredBy },
+    color: {
+      ...theme.color,
+      primary,
+      accent,
+      onPrimary: readableOn(primary),
+      onAccent: readableOn(accent)
+    },
+    space: theme.space,
+    radius: theme.radius,
+    type: { ...theme.type, fontUrl },
+    motion
+  };
+  return deepFreeze(finalized);
+}
+
+// src/client/entitlements/entitlementRepository.ts
+var ENTITLEMENTS_PATH = "/widget/v1/entitlements";
+var HTTP_NOT_MODIFIED = 304;
+var NOT_MODIFIED = Object.freeze({ kind: "notModified" });
+async function fetchEntitlements(auth, args = {}, funnel = createRequestFunnel({ auth })) {
+  const result = await funnel.send(
+    "entitlements.fetch",
+    buildRequest(args)
+  );
+  if (!result.ok) {
+    if (result.error.httpStatus === HTTP_NOT_MODIFIED) return NOT_MODIFIED;
+    return { kind: "failed", error: result.error };
+  }
+  return parseUpdated(result.value);
+}
+var REGION_MAX = 64;
+function buildRequest(args) {
+  const headers = {};
+  if (isFiniteNumber(args.cachedRevision)) {
+    headers["if-none-match"] = `"${args.cachedRevision}"`;
+  }
+  if (args.region && args.region.length <= REGION_MAX) {
+    return { method: "GET", path: ENTITLEMENTS_PATH, headers, query: { region: args.region } };
+  }
+  return { method: "GET", path: ENTITLEMENTS_PATH, headers };
+}
+function parseUpdated(body) {
+  if (body === null || typeof body !== "object") return malformed();
+  if (!isFiniteNumber(body.revision)) return malformed();
+  const region = typeof body.region === "string" ? body.region : "";
+  const ttlSeconds = isFiniteNumber(body.ttl_seconds) ? body.ttl_seconds : 0;
+  return Object.freeze({
+    kind: "updated",
+    revision: body.revision,
+    region,
+    ttlSeconds,
+    decisions: mapCapabilities(body.capabilities),
+    // Branding is ADDITIVE and orthogonal to capabilities: a parse fault here NEVER affects the decisions and
+    // fails closed to null (the compiled default theme). It cannot make a granted capability un-render.
+    branding: parseBranding(body)
+  });
+}
+function parseBranding(body) {
+  const direct = parseClientBranding(body.branding);
+  if (direct !== null) return direct;
+  const hints = body.render_hints;
+  if (hints !== null && typeof hints === "object") {
+    const nested = parseClientBranding(hints.branding);
+    if (nested !== null) return nested;
+    return parseClientBranding(hints);
+  }
+  return null;
+}
+function mapCapabilities(capabilities) {
+  if (capabilities === null || typeof capabilities !== "object") return Object.freeze([]);
+  const out = [];
+  for (const [resource, value] of Object.entries(capabilities)) {
+    if (isEnabled(value)) out.push(Object.freeze({ resource, granted: true }));
+  }
+  return Object.freeze(out);
+}
+function isEnabled(value) {
+  return typeof value === "object" && value !== null && value.enabled === true;
+}
+function malformed() {
+  return {
+    kind: "failed",
+    error: makeEverfurError("internalError", {
+      retryable: true,
+      wireMessage: "malformed entitlements response"
+    })
+  };
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+// src/core/entitlements/entitlementPoller.ts
+var MIN_POLL_INTERVAL_SECONDS = 30;
+function createEntitlementPoller(deps) {
+  const scheduler = deps.scheduler ?? defaultScheduler;
+  const resolve = deps.resolve ?? fetchEntitlements;
+  const floorSeconds = Math.max(1, deps.floorSeconds ?? MIN_POLL_INTERVAL_SECONDS);
+  const rng = deps.rng ?? Math.random;
+  const jitteredFloorSeconds = () => floorSeconds + rng() * floorSeconds;
+  let started = false;
+  let stopped = false;
+  let timer = null;
+  let cachedRevision = null;
+  let lastCadenceSeconds = floorSeconds;
+  let generation = 0;
+  const clearTimer = () => {
+    if (timer !== null) {
+      scheduler.clear(timer);
+      timer = null;
+    }
+  };
+  const schedule = (seconds) => {
+    if (stopped) return;
+    lastCadenceSeconds = Math.max(floorSeconds, seconds);
+    timer = scheduler.set(() => {
+      timer = null;
+      void tick();
+    }, lastCadenceSeconds * 1e3);
+  };
+  const tick = async () => {
+    if (stopped) return;
+    const myGen = generation;
+    const args = deps.region ? { cachedRevision, region: deps.region } : { cachedRevision };
+    let resolution;
+    try {
+      resolution = await resolve(deps.authFor(), args);
+    } catch (cause) {
+      deps.telemetry?.track("sdk.entitlements.poll_error", { reason: describe(cause) });
+      if (!stopped && myGen === generation) schedule(jitteredFloorSeconds());
+      return;
+    }
+    if (stopped || myGen !== generation) return;
+    switch (resolution.kind) {
+      case "updated":
+        cachedRevision = resolution.revision;
+        deps.update(resolution.decisions, resolution.branding ?? null);
+        schedule(resolution.ttlSeconds);
+        return;
+      case "notModified":
+        schedule(lastCadenceSeconds);
+        return;
+      case "failed":
+        deps.telemetry?.track("sdk.entitlements.poll_failed", { code: resolution.error.code });
+        schedule(jitteredFloorSeconds());
+        return;
+      default:
+        schedule(jitteredFloorSeconds());
+    }
+  };
+  return {
+    start() {
+      if (started || stopped) return;
+      started = true;
+      void tick();
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      generation++;
+      clearTimer();
+    },
+    refresh() {
+      if (stopped || !started) return;
+      generation++;
+      cachedRevision = null;
+      clearTimer();
+      void tick();
+    }
+  };
+}
+var defaultScheduler = {
+  set(callback, ms) {
+    const handle = setTimeout(callback, ms);
+    handle.unref?.();
+    return handle;
+  },
+  clear(handle) {
+    clearTimeout(handle);
+  }
+};
+function describe(cause) {
+  return cause instanceof Error ? cause.message : "poll failed";
+}
+
+// src/core/runtime.ts
+function compiledDefaultDecisions() {
+  return Object.freeze([Object.freeze({ resource: "chat.message.create", granted: true })]);
+}
+function createEntitlementStore(floorDecisions = compiledDefaultDecisions) {
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = Object.freeze({
+    decisions: floorDecisions(),
+    isPending: false,
+    branding: null
+  });
+  const emit = () => {
+    for (const listener of listeners) listener();
+  };
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot() {
+      return snapshot;
+    },
+    set(next) {
+      snapshot = Object.freeze({
+        decisions: Object.freeze([...next.decisions]),
+        isPending: next.isPending,
+        // Branding is additive; default to null (the compiled Everfur theme) when a caller omits it.
+        branding: next.branding ?? null
+      });
+      emit();
+    },
+    reset() {
+      snapshot = Object.freeze({
+        decisions: floorDecisions(),
+        isPending: false,
+        branding: null
+      });
+      emit();
+    }
+  };
+}
+function createEverfurRuntime(input, opts) {
+  return new EverfurRuntimeImpl(input, opts);
+}
+var PER_USER_KV_KEYS = Object.freeze([]);
+var EverfurRuntimeImpl = class {
+  constructor(input, opts) {
+    /**
+     * One `x-everfur-session-id` for the life of this runtime. It MUST be stable across requests: the server
+     * derives the anonymous identity from it, so a per-request value makes every call a different user and the
+     * create/send pair can never agree. Minted here, never persisted, never a credential.
+     */
+    /**
+     * Rotated on sign-out. The server derives the ANONYMOUS identity from this
+     * (`user_ref = f"anon-{session_id}"`), so keeping it across a logout would leave the next anonymous
+     * session inheriting the previous user's server-side conversation history.
+     */
+    this.sessionId = newSessionId();
+    // ONE ref-counted controller table keyed by `${epoch}|${kind}|${scopeKey}`, plus each controller's
+    // destroyer, so a re-scope / dispose can tear every open controller down without naming its type.
+    this.entries = /* @__PURE__ */ new Map();
+    this.destroyers = /* @__PURE__ */ new Map();
+    this.epoch = 0;
+    this.disposed = false;
+    const cfg = input.config;
+    if (cfg.secureStore !== void 0 && cfg.secureStore.isAvailable === true) {
+      throw new EverfurConfigError(
+        "invalid-argument",
+        "config.secureStore is not yet consumable: SDK token persistence is unimplemented. Omit secureStore to keep memory-only tokens (SPEC-10 \xA75.3)."
+      );
+    }
+    this.telemetry = cfg.telemetry ?? noopTelemetry;
+    const publishableKey = typeof cfg?.publishableKey === "string" ? cfg.publishableKey.trim() : "";
+    let failure = checkPublishableKey(cfg?.publishableKey);
+    const transportInjected = cfg.transport !== void 0;
+    let resolvedTransport;
+    if (failure !== null) {
+      resolvedTransport = refusingTransport(failure);
+    } else if (cfg.transport !== void 0) {
+      resolvedTransport = cfg.transport;
+    } else {
+      const resolved = tryResolveClient(cfg);
+      if (resolved.ok) {
+        resolvedTransport = createHttpTransport({
+          config: resolved.config,
+          ...opts?.eventSourceFactory ? { eventSourceFactory: opts.eventSourceFactory } : {}
+        });
+      } else {
+        failure = resolved.failure;
+        resolvedTransport = refusingTransport(resolved.failure);
+      }
+    }
+    this.configFailure = failure;
+    this.publishableKey = failure === null ? publishableKey : "";
+    this.transport = resolvedTransport;
+    if (failure !== null) {
+      reportConfigFailure(failure, this.telemetry);
+    }
+    this.errorPolicy = cfg.errorPolicy;
+    this.camera = cfg.camera ?? unavailableCamera;
+    this.upload = cfg.upload ?? unavailableUpload;
+    this.uploadTransport = cfg.uploadTransport ?? unavailableUploadTransport;
+    this.imageCache = cfg.imageCache ?? noopImageCache;
+    this.kv = cfg.storage ?? createInMemoryKv();
+    this.currentUser = input.user;
+    this.identity = input.user ? createIdentityProvider(input.user.userRef, input.user.getToken) : null;
+    this.activePet = input.activePet;
+    this.store = failure === null ? createEntitlementStore() : createEntitlementStore(() => deniedDecisionsFor("sdk_config", userFacingError("accessDenied")));
+    this.services = {
+      authFor: (userRef2) => this.buildAuth(userRef2),
+      telemetry: this.telemetry,
+      errorPolicy: this.errorPolicy,
+      camera: this.camera,
+      upload: this.upload,
+      uploadTransport: this.uploadTransport,
+      imageCache: this.imageCache,
+      kv: this.kv
+    };
+    this.registry = {
+      services: this.services,
+      acquireChat: (scope) => this.acquireInternal(
+        "chat",
+        `${scope.userRef ?? ""}|${scope.petRef ?? ""}|${scope.conversationId ?? ""}`,
+        () => this.buildChatController(scope),
+        (controller) => controller.dispose()
+      ),
+      releaseChat: (controller) => this.releaseInternal(controller),
+      acquire: (kind, scopeKey, create, destroy) => this.acquireInternal(kind, scopeKey, create, destroy),
+      release: (controller) => this.releaseInternal(controller)
+    };
+    this.entitlements = this.store;
+    const shouldPoll = failure === null && (opts?.startEntitlementPolling ?? !transportInjected);
+    this.poller = shouldPoll ? this.buildPoller(opts?.pollScheduler) : null;
+    this.poller?.start();
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  /**
+   * Build the entitlement poller. `authFor` re-derives the device AuthContext each poll (so a token refresh /
+   * re-scope is reflected), and `update` feeds the resolved decisions into the render store. The SERVER stays
+   * authoritative; this only populates what the SDK renders.
+   */
+  buildPoller(scheduler) {
+    return createEntitlementPoller({
+      authFor: () => this.buildAuth(this.currentUser?.userRef ?? null),
+      update: (decisions, branding) => this.updateEntitlements({ decisions, isPending: false, branding }),
+      telemetry: this.telemetry,
+      ...scheduler ? { scheduler } : {}
+    });
+  }
+  // ---- ref-counted acquire / release (epoch-keyed) -----------------------
+  acquireInternal(kind, scopeKey, create, destroy) {
+    const key = `${this.epoch}|${kind}|${scopeKey}`;
+    const existing = this.entries.get(key);
+    if (existing) {
+      existing.refCount += 1;
+      return existing.controller;
+    }
+    const controller = create();
+    this.entries.set(key, { controller, refCount: 1 });
+    this.destroyers.set(controller, destroy);
+    return controller;
+  }
+  releaseInternal(controller) {
+    for (const [key, entry] of this.entries) {
+      if (entry.controller !== controller) continue;
+      entry.refCount -= 1;
+      if (entry.refCount <= 0) {
+        this.runDestroyer(controller);
+        this.entries.delete(key);
+      }
+      return;
+    }
+  }
+  runDestroyer(controller) {
+    const destroy = this.destroyers.get(controller);
+    this.destroyers.delete(controller);
+    if (destroy) destroy(controller);
+  }
+  // ---- controller construction (only the spine capability is built here) -
+  buildChatController(scope) {
+    const controller = createChatController({
+      auth: this.buildAuth(scope.userRef),
+      telemetry: this.telemetry,
+      ...this.errorPolicy ? { errorPolicy: this.errorPolicy } : {},
+      initialConversationId: scope.conversationId
+    });
+    const input = {};
+    if (scope.petRef !== null) input.petRef = scope.petRef;
+    if (scope.conversationId !== null) input.resumeConversationId = scope.conversationId;
+    void bootstrapChat(input, { controller }).then((result) => controller.adoptPrompts(result.suggestedPrompts)).catch(() => {
+    });
+    return controller;
+  }
+  buildAuth(scopeUserRef) {
+    if (this.identity !== null && this.currentUser !== null) {
+      return {
+        mode: "personalized",
+        transport: this.transport,
+        identity: this.identity,
+        userRef: this.currentUser.userRef,
+        sessionId: this.sessionId
+      };
+    }
+    return {
+      mode: "anonymous",
+      transport: this.transport,
+      publishableKey: this.publishableKey,
+      // Only name a user while one is actually signed in. `scopeUserRef` is the REGISTRY scope key,
+      // taken from the host's `user` prop, which a `logout()` call does not touch — so carrying it here
+      // meant that after sign-out the SDK kept sending `x-everfur-user-ref` for the signed-out user
+      // alongside the publishable key, and the widget plane resolves identity from exactly that pair.
+      userRef: this.currentUser === null ? null : scopeUserRef,
+      sessionId: this.sessionId
+    };
+  }
+  // ---- imperative verbs (re-scope in one commit; SPEC-10 §3) -------------
+  setUser(user) {
+    if (this.disposed) return;
+    const nextRef = user?.userRef ?? null;
+    const currentRef = this.currentUser?.userRef ?? null;
+    if (nextRef === currentRef) {
+      this.currentUser = user;
+      if (user && this.identity === null) {
+        this.identity = createIdentityProvider(user.userRef, user.getToken);
+      }
+      return;
+    }
+    this.identity?.clear();
+    this.currentUser = user;
+    this.identity = user ? createIdentityProvider(user.userRef, user.getToken) : null;
+    this.rescopeAll();
+  }
+  async logout() {
+    if (this.disposed) return;
+    const wasAnonymous = this.currentUser === null;
+    this.sessionId = newSessionId();
+    this.setUser(null);
+    if (wasAnonymous) this.rescopeAll();
+    await this.sweepPerUserKv();
+  }
+  async sweepPerUserKv() {
+    if (PER_USER_KV_KEYS.length === 0) return;
+    const results = await Promise.allSettled(
+      PER_USER_KV_KEYS.map((key) => this.kv.removeItem(key))
+    );
+    const failedCount = results.filter((result) => result.status === "rejected").length;
+    if (failedCount > 0) {
+      this.telemetry.track("sdk.logout.sweepPartialFailure", {
+        failedCount,
+        totalCount: results.length
+      });
+    }
+  }
+  async registerPet(pet, profile) {
+    if (this.disposed) {
+      return err(
+        makeEverfurError("validationFailed", {
+          retryable: false,
+          wireMessage: "the Everfur runtime is disposed; registerPet was called after unmount"
+        })
+      );
+    }
+    const repo = createPetsRepository(this.buildAuth(this.currentUser?.userRef ?? null));
+    return profile === void 0 ? repo.registerPet(pet) : repo.registerPet(pet, profile);
+  }
+  setActivePet(pet) {
+    if (this.disposed) return;
+    const next = pet ?? null;
+    if (next === this.activePet) return;
+    this.activePet = next;
+    this.rescopeAll();
+  }
+  updateEntitlements(next) {
+    if (this.disposed) return;
+    if (this.configFailure !== null) return;
+    this.store.set(next);
+  }
+  open(capability) {
+    this.telemetry.track("sdk.open", { capability });
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.epoch += 1;
+    this.poller?.stop();
+    this.identity?.clear();
+    this.disposeAllControllers();
+  }
+  rescopeAll() {
+    this.epoch += 1;
+    this.disposeAllControllers();
+    this.store.reset();
+    this.poller?.refresh();
+  }
+  disposeAllControllers() {
+    for (const entry of this.entries.values()) this.runDestroyer(entry.controller);
+    this.entries.clear();
+    this.destroyers.clear();
+  }
+};
+function tryResolveClient(cfg) {
+  const clientCfg = {
+    publishableKey: cfg.publishableKey,
+    ...cfg.apiBaseUrl !== void 0 ? { apiBaseUrl: cfg.apiBaseUrl } : {},
+    ...cfg.contractVersion !== void 0 ? { contractVersion: cfg.contractVersion } : {},
+    ...cfg.debug !== void 0 ? { debug: cfg.debug } : {}
+  };
+  return tryResolveClientConfig(clientCfg);
+}
+function reportConfigFailure(failure, telemetry) {
+  try {
+    telemetry.trackExpectedFailure("sdk.config.invalid", { reason: failure.reason });
+  } catch {
+  }
+  const globalConsole = globalThis.console;
+  globalConsole?.error?.(
+    `[everfur] SDK disabled: ${failure.message}
+[everfur] Every Everfur capability will render its off-state until this is fixed. If the value is set in your environment, note that babel-preset-expo inlines only EXPO_PUBLIC_* variables into a release bundle.`
+  );
+}
+function refusingTransport(failure) {
+  const build = () => (
+    // NOT `internalError`: the funnel's `decideRetry` keys on `isAutoRetryable(code)` and deliberately
+    // ignores `error.retryable`, so `internalError` would be retried with backoff on every call even though
+    // it can never succeed; and `categoryFor('internalError')` is `server`, i.e. "the server admits fault",
+    // which would blame Everfur's backend for the partner's own config defect on their dashboards. The
+    // whole point of the `sdk_config` level is to attribute this correctly. `validationFailed` is terminal
+    // (`invalidRequest`: "retrying it unchanged can never succeed"), which is exactly true here.
+    makeEverfurError("validationFailed", {
+      retryable: false,
+      // Developer-facing only: `wireMessage` is NON-ENUMERABLE and never rendered (EverfurError.ts).
+      wireMessage: `Everfur SDK is not configured: ${failure.message}`
+    })
+  );
+  return Object.freeze({
+    request() {
+      return Promise.resolve(err(build()));
+    },
+    stream(_req, signal) {
+      const frame = errorFrame({
+        code: "sdk_not_configured",
+        retryable: false,
+        wireMessage: `Everfur SDK is not configured: ${failure.message}`,
+        synthesized: true,
+        lastEventId: null
+      });
+      return {
+        async *[Symbol.asyncIterator]() {
+          if (signal.aborted) return;
+          yield frame;
+        }
+      };
+    }
+  });
+}
+function createInMemoryKv() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    async getItem(key) {
+      return map.get(key) ?? null;
+    },
+    async setItem(key, value) {
+      map.set(key, value);
+    },
+    async removeItem(key) {
+      map.delete(key);
+    },
+    async keys(prefix) {
+      return [...map.keys()].filter((k) => k.startsWith(prefix));
+    }
+  };
+}
+var unavailableUploadTransport = Object.freeze({
+  postMultipart() {
+    return Promise.reject(
+      new Error("UploadTransport is unavailable; no records upload adapter was injected")
+    );
+  }
+});
+var noopImageCache = Object.freeze({
+  clearMemoryCache() {
+  },
+  clearDiskCache() {
+  }
+});
+var HEADERS_RECEIVED = 2;
+function readEventSourceResponseHeader(instance, name) {
+  const xhr = instance?._xhr;
+  if (!xhr || typeof xhr.getResponseHeader !== "function") return null;
+  if (typeof xhr.readyState === "number" && xhr.readyState < HEADERS_RECEIVED) return null;
+  let value;
+  try {
+    value = xhr.getResponseHeader(name);
+  } catch {
+    return null;
+  }
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function createRnEventSourceFactory() {
+  const Ctor = EventSource;
+  return (url, init) => {
+    const instance = new Ctor(url, {
+      method: init.method,
+      headers: init.headers,
+      pollingInterval: init.pollingInterval ?? 0,
+      ...init.body !== void 0 ? { body: init.body } : {}
+    });
+    return Object.assign(instance, {
+      getResponseHeader: (name) => readEventSourceResponseHeader(instance, name)
+    });
+  };
+}
+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/theme/EverfurThemeProvider.tsx
+function EverfurThemeProvider(props) {
+  const { runtime } = useEverfurContext();
+  const store = runtime.entitlements;
+  const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+  const colorScheme = useColorScheme();
+  const reducedMotion = useReducedMotion();
+  const clientKey = props.clientTheme ? stableKey(props.clientTheme) : "";
+  const clientOverride = useMemo(
+    () => props.clientTheme ? parseClientBranding(props.clientTheme) : null,
+    [clientKey]
+  );
+  const serverBranding = snapshot.branding ?? null;
+  const scheme = colorScheme === "dark" ? "dark" : colorScheme === "light" ? "light" : null;
+  const theme = useMemo(
+    () => resolveTheme({
+      branding: serverBranding,
+      clientOverride,
+      colorScheme: scheme,
+      reducedMotion
+    }),
+    [serverBranding, clientOverride, scheme, reducedMotion]
+  );
+  return createElement(EverfurThemeContext.Provider, { value: theme }, props.children);
+}
+function useReducedMotion() {
+  const [reduced, setReduced] = useState(false);
+  useEffect(() => {
+    let mounted = true;
+    const query = AccessibilityInfo?.isReduceMotionEnabled;
+    if (typeof query === "function") {
+      const result = query.call(AccessibilityInfo);
+      if (result != null && typeof result.then === "function") {
+        result.then(
+          (value) => {
+            if (mounted) setReduced(value === true);
+          },
+          () => {
+          }
+        );
+      }
+    }
+    const subscription = AccessibilityInfo?.addEventListener?.(
+      "reduceMotionChanged",
+      (value) => setReduced(value === true)
+    );
+    return () => {
+      mounted = false;
+      subscription?.remove?.();
+    };
+  }, []);
+  return reduced;
+}
+function stableKey(input) {
+  const keys = Object.keys(input).sort();
+  return keys.map((k) => `${k}=${String(input[k])}`).join("&");
+}
+
+// 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;
+}
+function EverfurProvider(props) {
+  const { config, user, activePet, theme, children } = props;
+  const configKey = `${config?.publishableKey ?? ""}|${config?.apiBaseUrl ?? ""}|${config?.contractVersion ?? ""}`;
+  const runtimeRef = useRef(null);
+  const supersededRef = useRef(null);
+  const [, scheduleRender] = useReducer((n) => n + 1, 0);
+  const imperativeUserRef = useRef(null);
+  const lastPropUserRef = useRef(void 0);
+  const propUserRefKey = user?.userRef ?? null;
+  if (lastPropUserRef.current !== propUserRefKey) {
+    if (lastPropUserRef.current !== void 0) imperativeUserRef.current = null;
+    lastPropUserRef.current = propUserRefKey;
+  }
+  const effectiveUser = imperativeUserRef.current !== null ? imperativeUserRef.current.user : user ?? null;
+  const imperativePetRef = useRef(null);
+  const lastPropPetRef = useRef(void 0);
+  const propPetRef = activePet ?? null;
+  if (lastPropPetRef.current !== propPetRef) {
+    if (lastPropPetRef.current !== void 0) imperativePetRef.current = null;
+    lastPropPetRef.current = propPetRef;
+  }
+  const effectivePet = imperativePetRef.current !== null ? imperativePetRef.current.pet : activePet ?? null;
+  if (runtimeRef.current === null || runtimeRef.current.key !== configKey || runtimeRef.current.runtime.isDisposed) {
+    if (runtimeRef.current !== null && !runtimeRef.current.runtime.isDisposed) {
+      supersededRef.current = runtimeRef.current.runtime;
+    }
+    runtimeRef.current = {
+      key: configKey,
+      runtime: createEverfurRuntime(
+        {
+          config,
+          user: effectiveUser,
+          activePet: effectivePet,
+          theme: theme ?? null
+        },
+        // Inject the RN EventSource factory as the streaming fallback for the built HTTP transport. Ignored
+        // when the host injects its own transport (the test seam); harmless on web/expo where fetch streams
+        // res.body.
+        { eventSourceFactory: createRnEventSourceFactory() }
+      )
+    };
+  }
+  const runtime = runtimeRef.current.runtime;
+  const bumpedForRef = useRef(null);
+  useEffect(() => {
+    const current = runtimeRef.current?.runtime;
+    if (current === void 0 || !current.isDisposed) return;
+    if (bumpedForRef.current === current) return;
+    bumpedForRef.current = current;
+    scheduleRender();
+  });
+  useEffect(() => {
+    const superseded = supersededRef.current;
+    if (superseded === null) return;
+    supersededRef.current = null;
+    superseded.dispose();
+  });
+  const userRefKey = effectiveUser?.userRef ?? null;
+  useLayoutEffect(() => {
+    runtime.setUser(effectiveUser);
+  }, [runtime, userRefKey]);
+  useLayoutEffect(() => {
+    runtime.setActivePet(effectivePet);
+  }, [runtime, effectivePet]);
+  useEffect(() => () => runtime.dispose(), [runtime]);
+  const handle = useMemo(
+    () => ({
+      // Each re-scoping verb records the imperative intent, mutates the runtime, THEN schedules a render.
+      // The render is not cosmetic: rescopeAll() has just disposed every controller the mounted hooks hold,
+      // and only a re-render lets them re-acquire under the new epoch.
+      setUser: (u) => {
+        imperativeUserRef.current = { user: u };
+        runtime.setUser(u);
+        scheduleRender();
+      },
+      setActivePet: (p) => {
+        imperativePetRef.current = { pet: p };
+        runtime.setActivePet(p);
+        scheduleRender();
+      },
+      open: (c) => runtime.open(c),
+      registerPet: (pet, profile) => runtime.registerPet(pet, profile),
+      logout: () => {
+        imperativeUserRef.current = { user: null };
+        const settled = runtime.logout();
+        scheduleRender();
+        return settled;
+      }
+      // logout returns the runtime's Promise<void> so a host can await the KV sweep before setUser(next).
+    }),
+    [runtime, scheduleRender]
+  );
+  const value = useMemo(
+    () => ({
+      runtime,
+      handle,
+      userRef: userRefKey,
+      activePet: effectivePet
+    }),
+    [runtime, handle, userRefKey, effectivePet]
+  );
+  return createElement(
+    EverfurContext.Provider,
+    { value },
+    /*
+     * SafeAreaProvider, supplied by the SDK rather than demanded from the host.
+     *
+     * Without it the chat surface had no device insets and used a fixed paddingTop, so on any notched
+     * iPhone the newest message rendered UNDER the Dynamic Island and could not be scrolled clear.
+     * Observed on a simulator following the quickstart verbatim: the message the user had just sent was
+     * the unreadable one.
+     *
+     * Providing it here rather than telling partners to wrap the tree keeps the promise the surface
+     * already makes, that it renders its own complete chrome. Nesting is supported by the library, so a
+     * host that already has its own provider is unaffected: the inner one reads the same window insets.
+     */
+    createElement(
+      SafeAreaProvider,
+      null,
+      createElement(EverfurThemeProvider, { clientTheme: theme ?? null, children })
+    )
+  );
+}
+function useEverfur() {
+  return useEverfurContext().handle;
+}
+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 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: userRef2, activePet } = useEverfurContext();
+  const petRef2 = opts?.petRef ?? activePet ?? null;
+  const conversationId2 = opts?.conversationId ?? null;
+  const [controller, setController] = useState(null);
+  useEffect(() => {
+    const acquired = runtime.registry.acquireChat({ userRef: userRef2, petRef: petRef2, conversationId: conversationId2 });
+    setController(acquired);
+    return () => {
+      setController((current) => current === acquired ? null : current);
+      runtime.registry.releaseChat(acquired);
+    };
+  }, [runtime, userRef2, petRef2, conversationId2]);
+  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 })
+  );
+}
+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: petRef2, conversationId: conversationId2, style } = props;
+  return /* @__PURE__ */ jsx(CapabilityGate, { capability: "chat", style, children: /* @__PURE__ */ jsx(ChatBody, { petRef: petRef2, conversationId: conversationId2, 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: petRef2,
+  conversationId: conversationId2,
+  style
+}) {
+  const { theme, styles } = useChatTheme();
+  const chatOpts = useMemo(
+    () => buildChatOpts(petRef2, conversationId2),
+    [petRef2, conversationId2]
+  );
+  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(petRef2, conversationId2) {
+  const opts = {};
+  if (petRef2 !== void 0) opts.petRef = petRef2;
+  if (conversationId2 !== void 0) opts.conversationId = conversationId2;
+  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 { CapabilityGate, EverfurChat, EverfurConfigError, EverfurProvider, EverfurThemeProvider, EverfurThrownError, categoryFor, conversationId, isErr, isOk, isRetryableCode, petRef, unwrap, useCapability, useEverfur, useEverfurChat, useEverfurTheme, userFacingError, userRef };