@everfur/sdk 0.1.0

package/dist/photo/index.cjs

@@ -0,0 +1,2189 @@
+'use strict';
+
+var react = require('react');
+require('react-native-safe-area-context');
+var reactNative = require('react-native');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/rn/photo/usePhoto.ts
+var CONTRACT_RETRYABILITY = Object.freeze([
+  Object.freeze({ wireCode: "AccessDeniedException", envelope: "http_envelope", httpStatus: 403, retryable: false }),
+  Object.freeze({ wireCode: "AuthorizationException", envelope: "http_envelope", httpStatus: 401, retryable: false }),
+  Object.freeze({ wireCode: "ConflictException", envelope: "http_envelope", httpStatus: 409, retryable: true }),
+  Object.freeze({ wireCode: "DAILY_QUOTA_EXCEEDED", envelope: "http_envelope", httpStatus: 429, retryable: true }),
+  Object.freeze({ wireCode: "IDEMPOTENCY_KEY_IN_FLIGHT", envelope: "http_envelope", httpStatus: 409, retryable: true }),
+  Object.freeze({ wireCode: "IDEMPOTENCY_KEY_REUSED_DIFFERENT_REQUEST", envelope: "http_envelope", httpStatus: 409, retryable: false }),
+  Object.freeze({ wireCode: "InternalFailureException", envelope: "http_envelope", httpStatus: 500, retryable: true }),
+  Object.freeze({ wireCode: "NotImplementedException", envelope: "http_envelope", httpStatus: 501, retryable: false }),
+  Object.freeze({ wireCode: "PaymentRequiredException", envelope: "http_envelope", httpStatus: 402, retryable: false }),
+  Object.freeze({ wireCode: "ResourceNotFoundException", envelope: "http_envelope", httpStatus: 404, retryable: false }),
+  Object.freeze({ wireCode: "ServiceUnavailableException", envelope: "http_envelope", httpStatus: 503, retryable: true }),
+  Object.freeze({ wireCode: "TIER_UPGRADE_REQUIRED", envelope: "http_envelope", httpStatus: 402, retryable: false }),
+  Object.freeze({ wireCode: "ThrottlingException", envelope: "http_envelope", httpStatus: 429, retryable: true }),
+  Object.freeze({ wireCode: "ValidationException", envelope: "http_envelope", httpStatus: 400, retryable: false }),
+  Object.freeze({ wireCode: "accessDenied", envelope: "http_envelope", httpStatus: 403, retryable: false }),
+  Object.freeze({ wireCode: "authExpired", envelope: "http_envelope", httpStatus: 401, retryable: true }),
+  Object.freeze({ wireCode: "internal_error", envelope: "sse_frame", httpStatus: 200, retryable: false }),
+  Object.freeze({ wireCode: "invalidRequest", envelope: "http_envelope", httpStatus: 400, retryable: false }),
+  Object.freeze({ wireCode: "not_found", envelope: "sse_frame", httpStatus: 200, retryable: false }),
+  Object.freeze({ wireCode: "session_required", envelope: "http_envelope", httpStatus: 403, retryable: false }),
+  Object.freeze({ wireCode: "timeout", envelope: "sse_frame", httpStatus: 200, retryable: true }),
+  Object.freeze({ wireCode: "unavailable", envelope: "http_envelope", httpStatus: 503, retryable: true })
+]);
+Object.freeze(
+  CONTRACT_RETRYABILITY.map((row) => row.wireCode)
+);
+
+// src/client/errors/contract.ts
+var NORMALIZED_FOLD = Object.freeze({
+  // the default status-mapped envelope
+  ValidationException: "validationFailed",
+  AuthorizationException: "authRejected",
+  PaymentRequiredException: "paymentRequired",
+  AccessDeniedException: "accessDenied",
+  ResourceNotFoundException: "resourceNotFound",
+  ConflictException: "conflict",
+  ThrottlingException: "rateLimited",
+  InternalFailureException: "internalError",
+  NotImplementedException: "notImplemented",
+  ServiceUnavailableException: "serviceUnavailable",
+  // dict-detail codes on the widget surface
+  authExpired: "authExpired",
+  unavailable: "serviceUnavailable",
+  session_required: "sessionRequired",
+  accessDenied: "accessDenied",
+  invalidRequest: "sdkUpdateRequired",
+  // typed codes
+  IDEMPOTENCY_KEY_IN_FLIGHT: "idempotencyInFlight",
+  IDEMPOTENCY_KEY_REUSED_DIFFERENT_REQUEST: "idempotencyConflict",
+  DAILY_QUOTA_EXCEEDED: "quotaExceeded",
+  TIER_UPGRADE_REQUIRED: "paymentRequired",
+  // SSE error frames
+  not_found: "conversationNotFound",
+  timeout: "streamTimeout",
+  internal_error: "internalError"
+});
+var CONTRACT_ERROR_ROWS = Object.freeze(
+  CONTRACT_RETRYABILITY.map(
+    (generated) => Object.freeze({
+      wireCode: generated.wireCode,
+      envelope: generated.envelope,
+      retryable: generated.retryable,
+      normalized: NORMALIZED_FOLD[generated.wireCode]
+    })
+  )
+);
+var BY_UPPER = new Map(
+  CONTRACT_ERROR_ROWS.map((r) => [r.wireCode.toUpperCase(), r])
+);
+function contractErrorFor(wireCode) {
+  if (typeof wireCode !== "string") return void 0;
+  const key = wireCode.trim().toUpperCase();
+  return key.length > 0 ? BY_UPPER.get(key) : void 0;
+}
+var CATEGORY_OF = Object.freeze({
+  // the caller's sign-in state is wrong and a credential change is the remedy
+  authExpired: "authentication",
+  authRejected: "authentication",
+  sessionRequired: "authentication",
+  // signed in, correctly identified, and still not allowed
+  accessDenied: "authorization",
+  // a plan gate, not a permission failure: the remedy is commercial
+  paymentRequired: "entitlement",
+  // slow down / come back later
+  quotaExceeded: "rateLimit",
+  rateLimited: "rateLimit",
+  // the request itself was wrong; retrying it unchanged can never succeed
+  validationFailed: "invalidRequest",
+  sdkUpdateRequired: "invalidRequest",
+  // the target is gone, hidden, or was never visible to this caller
+  conversationNotFound: "notFound",
+  petNotFound: "notFound",
+  resourceNotFound: "notFound",
+  // something else already holds the thing
+  conflict: "conflict",
+  idempotencyConflict: "conflict",
+  idempotencyInFlight: "conflict",
+  // the pipe, not the request: timeouts, drops, a briefly unreachable dependency
+  streamTimeout: "connection",
+  streamIncomplete: "connection",
+  upstreamLlmTimeout: "connection",
+  serviceUnavailable: "connection",
+  // the server admits fault
+  internalError: "server",
+  notImplemented: "server",
+  mediaUploadFailed: "media",
+  moderationBlocked: "policy",
+  unknown: "unknown"
+});
+function categoryFor(code) {
+  return CATEGORY_OF[code];
+}
+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";
+  }
+}
+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);
+}
+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);
+}
+
+// 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/client/errors/EverfurResult.ts
+function ok(value, warning) {
+  return Object.freeze(
+    { ok: true, value } 
+  );
+}
+function err(error) {
+  return Object.freeze({ ok: false, error });
+}
+var EverfurConfigError = class _EverfurConfigError extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.name = "EverfurConfigError";
+    this.kind = kind;
+    Object.setPrototypeOf(this, _EverfurConfigError.prototype);
+  }
+};
+
+// src/client/protocol/frames.ts
+function assertNever(x) {
+  throw new Error(
+    `assertNever: unhandled discriminated-union member ${JSON.stringify(x)}`
+  );
+}
+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: null
+  });
+}
+
+// src/client/identity.ts
+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 } : {}
+  });
+}
+
+// src/client/transport.ts
+function networkError(cause) {
+  return makeEverfurError("internalError", { retryable: true, wireMessage: describeCause(cause) });
+}
+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 deadline = boundedSignal(timeoutMs, timers);
+      const merged = mergeSignals(deadline.signal, req.signal);
+      let settled;
+      try {
+        settled = await authedSend({ ...base, signal: merged.signal }, deps.auth);
+      } catch (cause) {
+        settled = err(networkError(cause));
+      } finally {
+        merged.dispose();
+        deadline.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});
+    }
+  }
+  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(deadline, caller) {
+  const noop = () => void 0;
+  if (!caller) return { signal: deadline, dispose: noop };
+  const ctrl = new AbortController();
+  if (deadline.aborted || caller.aborted) {
+    ctrl.abort();
+    return { signal: ctrl.signal, dispose: noop };
+  }
+  const onAbort = () => ctrl.abort();
+  deadline.addEventListener("abort", onAbort, { once: true });
+  caller.addEventListener("abort", onAbort, { once: true });
+  return {
+    signal: ctrl.signal,
+    dispose: () => {
+      deadline.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/ports/TelemetryPort.ts
+var noopTelemetry = Object.freeze({
+  track() {
+  },
+  trackExpectedFailure() {
+  }
+});
+function fileHandleFromMedia(source) {
+  const handle = {
+    uri: source.uri,
+    mimeType: source.mimeType
+  };
+  const size = mediaByteSize(source);
+  if (size !== null) handle.sizeBytes = size;
+  return Object.freeze(handle);
+}
+function mediaByteSize(source) {
+  const candidate = source.byteSize ?? source.sizeBytes;
+  return typeof candidate === "number" && Number.isFinite(candidate) && candidate >= 0 ? candidate : null;
+}
+function captureOptionsFor(mode, maxDurationSeconds) {
+  return maxDurationSeconds === void 0 ? Object.freeze({ mode }) : Object.freeze({ mode, maxDurationSeconds });
+}
+function isCaptureAvailable(camera) {
+  return camera != null && camera.isAvailable === true;
+}
+var defaultTimers = Object.freeze({
+  setTimeout: (handler, ms) => setTimeout(handler, ms),
+  clearTimeout: (handle) => clearTimeout(handle),
+  now: () => Date.now()
+});
+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/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;
+}
+
+// src/core/media/projection.ts
+var CONSUMER_SAFE_DETECTION_KEYS = Object.freeze([
+  "primary_label",
+  "primary_confidence",
+  "subtype_label",
+  "subtype_display",
+  "subtype_confidence",
+  "risk_tier",
+  "confidence_tier",
+  "copy_short",
+  "disease_name",
+  "disease_framing",
+  "model_version",
+  "skin_v2",
+  "eye_v2",
+  "llm_checkup"
+]);
+var OPERATOR_INTERNAL_KEYS = Object.freeze([
+  "decision_audit",
+  "decision_thresholds",
+  "per_class_auroc",
+  "ood_layers",
+  "gate1_score",
+  "possible_conditions",
+  "top_class"
+]);
+var BOOLEAN_KEYS = /* @__PURE__ */ new Set(["skin_v2", "eye_v2", "llm_checkup"]);
+var CONFIDENCE_KEYS = /* @__PURE__ */ new Set(["primary_confidence", "subtype_confidence"]);
+var RISK_TIER_VALUES = /* @__PURE__ */ new Set(["low_risk", "concern", "uncertain"]);
+var CONFIDENCE_TIER_VALUES = /* @__PURE__ */ new Set(["possible", "probable"]);
+var STRING_LIMITS = Object.freeze({
+  primary_label: 64,
+  subtype_label: 64,
+  subtype_display: 128,
+  copy_short: 512,
+  disease_name: 128,
+  disease_framing: 512,
+  model_version: 64
+});
+function projectDetectionMetadata(raw) {
+  const source = isRecord2(raw) ? raw : {};
+  const out = {};
+  for (const key of CONSUMER_SAFE_DETECTION_KEYS) {
+    if (!(key in source)) continue;
+    const value = source[key];
+    const accepted = acceptKey(key, value);
+    if (accepted !== DROP) out[key] = accepted;
+  }
+  let dropped = 0;
+  for (const key of OPERATOR_INTERNAL_KEYS) {
+    if (key in source) dropped += 1;
+  }
+  return Object.freeze({ metadata: Object.freeze(out), droppedOperatorKeys: dropped });
+}
+var DROP = /* @__PURE__ */ Symbol("drop");
+function acceptKey(key, value) {
+  if (BOOLEAN_KEYS.has(key)) return typeof value === "boolean" ? value : DROP;
+  if (CONFIDENCE_KEYS.has(key)) return isUnitConfidence(value) ? value : DROP;
+  if (key === "risk_tier") return typeof value === "string" && RISK_TIER_VALUES.has(value) ? value : DROP;
+  if (key === "confidence_tier") {
+    return typeof value === "string" && CONFIDENCE_TIER_VALUES.has(value) ? value : DROP;
+  }
+  if (typeof value !== "string") return DROP;
+  const limit = STRING_LIMITS[key] ?? 256;
+  return value.length > limit ? value.slice(0, limit) : value;
+}
+function isUnitConfidence(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function parseInterpretation(raw) {
+  if (!isRecord2(raw)) return null;
+  const summary = asString(raw["summary"]);
+  const disclaimer = asString(raw["disclaimer"]);
+  const recommendations = asStringList(raw["recommendations"] ?? raw["recommendation"]);
+  if (summary === null && disclaimer === null && recommendations.length === 0) return null;
+  return Object.freeze({
+    summary: summary ?? "",
+    recommendations: Object.freeze(recommendations),
+    disclaimer: disclaimer ?? ""
+  });
+}
+function locateDetectionMetadata(body) {
+  if (!isRecord2(body)) return {};
+  if (isRecord2(body["metadata"])) return body["metadata"];
+  const detections = body["detections"];
+  if (Array.isArray(detections) && detections.length > 0) {
+    const first = detections[0];
+    if (isRecord2(first) && isRecord2(first["metadata"])) return first["metadata"];
+    if (isRecord2(first)) return first;
+  }
+  return body;
+}
+function locateInterpretation(body) {
+  if (!isRecord2(body)) return null;
+  if (isRecord2(body["interpretation"])) return body["interpretation"];
+  return body;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function asStringList(value) {
+  if (typeof value === "string") return value.length > 0 ? [value] : [];
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+function asUnitNumber(value) {
+  return isUnitConfidence(value) ? value : null;
+}
+function asFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+// src/core/media/pipeline.ts
+var ENDPOINTS = Object.freeze({
+  initiate: "/widget/v1/uploads/initiate",
+  precheck: "/widget/v1/photo/precheck",
+  photoAnalyze: "/widget/v1/photo/analyze",
+  videoAnalyze: "/widget/v1/video/analyze",
+  // `jobId` arrives from the WIRE, so it is not under this SDK's control, and `encodeURIComponent` throws
+  // URIError on a lone surrogate. Returning null lets the caller settle instead of throwing out of the
+  // poller. These routes are dark today, which is exactly why the guard goes in now: it costs one line and
+  // the gap re-opens silently the moment they land.
+  job: (jobId) => hasLoneSurrogate(jobId) ? null : `/widget/v1/analysis/jobs/${encodeURIComponent(jobId)}`
+});
+function brandJobId(raw) {
+  return raw;
+}
+async function initiateUpload(funnel, params) {
+  const body = { purpose: params.purpose, content_type: params.contentType };
+  if (params.byteSize !== null) body.byte_size = params.byteSize;
+  const req = {
+    method: "POST",
+    path: ENDPOINTS.initiate,
+    body,
+    ...params.signal ? { signal: params.signal } : {}
+  };
+  const res = await funnel.send("media.initiateUpload", req);
+  if (!res.ok) return err(res.error);
+  const policy = parsePresigned(res.value);
+  if (policy === null) return err(makeEverfurError("mediaUploadFailed", { retryable: false }));
+  return ok(policy);
+}
+function parsePresigned(raw) {
+  if (!isRecord2(raw)) return null;
+  const url = asString(raw["url"]);
+  const s3Key = asString(raw["s3_key"]);
+  if (url === null || s3Key === null) return null;
+  const fieldsRaw = raw["fields"];
+  const fields = {};
+  if (isRecord2(fieldsRaw)) {
+    for (const [key, value] of Object.entries(fieldsRaw)) {
+      if (typeof value === "string") fields[key] = value;
+    }
+  }
+  return Object.freeze({
+    url,
+    fields: Object.freeze(fields),
+    s3Key,
+    expiresAt: asFiniteNumber(raw["expires_at"])
+  });
+}
+async function stageUpload(upload, source, policy, idempotencyKey, signal) {
+  try {
+    await upload.presignedPut(fileHandleFromMedia(source), {
+      target: policy,
+      idempotencyKey,
+      ...signal ? { signal } : {}
+    });
+    return ok(void 0);
+  } catch {
+    return err(makeEverfurError("mediaUploadFailed", { retryable: false }));
+  }
+}
+async function runPrecheck(funnel, params) {
+  const req = {
+    method: "POST",
+    path: ENDPOINTS.precheck,
+    body: { s3_key: params.s3Key, type: params.type },
+    ...params.signal ? { signal: params.signal } : {}
+  };
+  const res = await funnel.send("media.precheck", req);
+  if (!res.ok) return { verdict: "proceed", reasonCodes: [], precheckToken: null };
+  return parsePrecheck(res.value);
+}
+function parsePrecheck(raw) {
+  if (!isRecord2(raw)) return { verdict: "proceed", reasonCodes: [], precheckToken: null };
+  const verdictRaw = asString(raw["verdict"]);
+  const verdict = verdictRaw === "retake" || verdictRaw === "reject" ? verdictRaw : "proceed";
+  const reasonCodes = Array.isArray(raw["reason_codes"]) ? raw["reason_codes"].filter((c) => typeof c === "string") : [];
+  return Object.freeze({
+    verdict,
+    reasonCodes: Object.freeze(reasonCodes),
+    precheckToken: asString(raw["precheck_token"])
+  });
+}
+async function submitAnalyze(funnel, path, body, detectGate, signal) {
+  const req = {
+    method: "POST",
+    path,
+    body,
+    ...signal ? { signal } : {}
+  };
+  const res = await funnel.send("media.analyze", req);
+  if (res.ok) {
+    const job = parseAsyncJob(res.value);
+    return job !== null ? { kind: "async", job } : { kind: "sync", body: res.value };
+  }
+  const gate = detectGate(res.error.httpStatus, res.error);
+  if (gate !== null) return { kind: "gate", gate };
+  return { kind: "error", error: res.error };
+}
+function parseAsyncJob(raw) {
+  if (!isRecord2(raw)) return null;
+  const jobId = asString(raw["job_id"]);
+  if (jobId === null) return null;
+  const status = asString(raw["status"]);
+  if (status !== null && isTerminalStatus(status)) return null;
+  return Object.freeze({
+    jobId: brandJobId(jobId),
+    estimatedSeconds: asFiniteNumber(raw["estimated_completion_seconds"])
+  });
+}
+var POLL_FIRST_DELAY_MS = 2e3;
+var POLL_MAX_DELAY_MS = 5e3;
+var POLL_BUDGET_MS = 9e4;
+async function pollJob(funnel, jobId, deps) {
+  const { timers, signal, alive } = deps;
+  const start = timers.now();
+  const budget = Math.max(POLL_BUDGET_MS, (deps.estimatedSeconds ?? 0) * 1e3);
+  let delay = POLL_FIRST_DELAY_MS;
+  for (; ; ) {
+    if (signal.aborted || !alive()) return { kind: "aborted" };
+    await delayAbortable2(delay, signal, timers);
+    if (signal.aborted || !alive()) return { kind: "aborted" };
+    if (timers.now() - start > budget) return { kind: "timeout" };
+    const path = ENDPOINTS.job(jobId);
+    if (path === null) return { kind: "notFound" };
+    const res = await funnel.send(
+      "media.pollJob",
+      { method: "GET", path, ...signal ? { signal } : {} },
+      { maxAttempts: 1 }
+    );
+    if (signal.aborted || !alive()) return { kind: "aborted" };
+    if (!res.ok) {
+      if (res.error.httpStatus === 404) return { kind: "notFound" };
+      delay = Math.min(POLL_MAX_DELAY_MS, delay + 1e3);
+      continue;
+    }
+    const status = jobStatusOf(res.value);
+    if (status === "COMPLETED") return { kind: "complete", body: res.value };
+    if (status === "FAILED") return { kind: "failed", error: jobFailureError(res.value) };
+    delay = Math.min(POLL_MAX_DELAY_MS, delay + 1e3);
+  }
+}
+function jobStatusOf(body) {
+  if (!isRecord2(body)) return "PROCESSING";
+  return (asString(body["status"]) ?? "PROCESSING").toUpperCase();
+}
+function isTerminalStatus(status) {
+  const upper = status.toUpperCase();
+  return upper === "COMPLETED" || upper === "FAILED";
+}
+function jobFailureError(body) {
+  const wire = isRecord2(body) ? asString(body["error"]) ?? asString(body["error_code"]) : null;
+  return makeEverfurError("internalError", { retryable: false, ...wire ? { wireMessage: wire } : {} });
+}
+function detectPhotoGate(httpStatus, _error) {
+  if (httpStatus === 422) return { kind: "species_unsupported", species: "cat" };
+  if (httpStatus === 400) return { kind: "pet_context_required" };
+  return null;
+}
+function analyzeBody(s3Key, extra) {
+  const body = { s3_key: s3Key };
+  if (extra.type !== void 0) body.type = extra.type;
+  if (extra.petRef != null) body.pet_id = extra.petRef;
+  if (extra.precheckToken != null) body.precheck_token = extra.precheckToken;
+  return body;
+}
+
+// src/core/photo/PhotoController.ts
+var ACCEPTED = Object.freeze({ kind: "accepted" });
+function createPhotoController(deps) {
+  return new PhotoController(deps);
+}
+var PhotoController = class extends MediaStore {
+  constructor(deps) {
+    super({
+      status: "idle",
+      region: deps.region ?? "skin",
+      result: null,
+      gate: ACCEPTED,
+      error: null,
+      isCaptureAvailable: isCaptureAvailable(deps.camera)
+    });
+    this.funnel = deps.funnel ?? createRequestFunnel({
+      auth: deps.auth,
+      ...deps.errorPolicy ? { errorPolicy: deps.errorPolicy } : {}
+    });
+    this.camera = deps.camera;
+    this.upload = deps.upload;
+    this.telemetry = deps.telemetry ?? noopTelemetry;
+    this.timers = deps.timers ?? defaultTimers;
+    this.makeIdempotencyKey = deps.makeIdempotencyKey ?? defaultIdempotencyFactory();
+  }
+  /** Open the CameraPort (photo), then analyze. No-op when capture is unavailable; a cancel returns to idle. */
+  async capture(region, opts) {
+    if (!isCaptureAvailable(this.camera)) {
+      return err(makeEverfurError("unknown", { retryable: false }));
+    }
+    let source;
+    try {
+      source = await this.camera.capture(captureOptionsFor("photo"));
+    } catch {
+      if (this.snapshot.status !== "idle") this.patch({ status: "idle" });
+      return err(makeEverfurError("unknown", { retryable: false }));
+    }
+    return this.analyze(source, region, opts);
+  }
+  /**
+   * Server enforces the species gate (§6). The SDK NEVER runs a model and NEVER guesses species. `petRef` is
+   * REQUIRED so a skin/eye request always carries pet context (§6.3 client invariant / PAR-07).
+   */
+  async analyze(source, region, opts) {
+    const op = this.beginOperation(opts.signal);
+    const idempotencyKey = this.makeIdempotencyKey();
+    const startedAt = this.timers.now();
+    this.patch({ status: "capturing", region, error: null, result: null, gate: ACCEPTED });
+    try {
+      const initiated = await initiateUpload(this.funnel, {
+        purpose: "skin_scan",
+        contentType: source.mimeType,
+        byteSize: mediaByteSize(source),
+        signal: op.signal
+      });
+      if (op.signal.aborted || !this.alive(op.epoch)) return abortedResult();
+      if (!initiated.ok) return this.fail(op, initiated.error);
+      const staged = await stageUpload(this.upload, source, initiated.value, idempotencyKey, op.signal);
+      if (op.signal.aborted || !this.alive(op.epoch)) return abortedResult();
+      if (!staged.ok) return this.fail(op, staged.error);
+      const precheck = await runPrecheck(this.funnel, {
+        s3Key: initiated.value.s3Key,
+        type: region,
+        signal: op.signal
+      });
+      if (op.signal.aborted || !this.alive(op.epoch)) return abortedResult();
+      if (precheck.verdict !== "proceed") {
+        return this.gateRetake(op, region, precheck.reasonCodes);
+      }
+      this.patch({ status: "analyzing" });
+      const outcome = await submitAnalyze(
+        this.funnel,
+        ENDPOINTS.photoAnalyze,
+        analyzeBody(initiated.value.s3Key, {
+          type: region,
+          petRef: opts.petRef,
+          precheckToken: precheck.precheckToken
+        }),
+        detectPhotoGate,
+        op.signal
+      );
+      if (op.signal.aborted || !this.alive(op.epoch)) return abortedResult();
+      switch (outcome.kind) {
+        case "error":
+          return this.fail(op, outcome.error);
+        case "gate":
+          return this.gateDomain(op, region, outcome.gate);
+        case "sync":
+          return this.complete(op, outcome.body, region, null, startedAt);
+        case "async": {
+          const poll = await pollJob(this.funnel, outcome.job.jobId, {
+            timers: this.timers,
+            signal: op.signal,
+            alive: () => this.alive(op.epoch),
+            estimatedSeconds: outcome.job.estimatedSeconds
+          });
+          if (op.signal.aborted || !this.alive(op.epoch)) return abortedResult();
+          switch (poll.kind) {
+            case "aborted":
+              return abortedResult();
+            case "complete":
+              return this.complete(op, poll.body, region, outcome.job.jobId, startedAt);
+            case "failed":
+              return this.fail(op, poll.error);
+            case "timeout":
+              return this.fail(op, makeEverfurError("streamTimeout", { retryable: true }));
+            case "notFound":
+              return this.fail(op, makeEverfurError("conversationNotFound", { retryable: false, httpStatus: 404 }));
+            default:
+              return this.fail(op, makeEverfurError("internalError", { retryable: false }));
+          }
+        }
+        default:
+          return this.fail(op, makeEverfurError("internalError", { retryable: false }));
+      }
+    } finally {
+      op.settle();
+    }
+  }
+  /** Clear the gate/result back to idle for a retake. */
+  reset() {
+    this.inFlight?.abort();
+    this.inFlight = null;
+    this.patch({ status: "idle", result: null, gate: ACCEPTED, error: null });
+  }
+  // ---- terminal transitions ---------------------------------------------
+  complete(op, body, region, jobId, startedAt) {
+    if (!this.alive(op.epoch)) return abortedResult();
+    const mapped = mapPhotoResult(body, region, jobId);
+    if (mapped.droppedOperatorKeys > 0) {
+      this.telemetry.track("analysis.metadata_leak_guard", { droppedKeyCount: mapped.droppedOperatorKeys });
+    }
+    this.patch({ status: "complete", result: mapped.result, gate: ACCEPTED, error: null });
+    this.telemetry.track("analysis.species_gate", { outcome: "accepted", region });
+    this.telemetry.track("analysis.result", {
+      capability: "photo",
+      region,
+      riskTier: mapped.result.riskTier ?? "",
+      confidenceTier: mapped.result.confidenceTier ?? "",
+      modelVersion: mapped.result.modelVersion ?? "",
+      timeToResultMs: this.timers.now() - startedAt
+    });
+    return ok(mapped.result);
+  }
+  gateDomain(op, region, gate) {
+    if (!this.alive(op.epoch)) return abortedResult();
+    const outcome = gate.kind === "species_unsupported" ? Object.freeze({ kind: "species_unsupported", species: "cat" }) : Object.freeze({ kind: "pet_context_required" });
+    this.patch({ status: "idle", gate: outcome, error: null, result: null });
+    this.telemetry.track("analysis.species_gate", {
+      outcome: gate.kind,
+      region,
+      ...gate.kind === "species_unsupported" ? { species: "cat" } : {}
+    });
+    return err(makeEverfurError("unknown", { retryable: false }));
+  }
+  gateRetake(op, region, reasons) {
+    if (!this.alive(op.epoch)) return abortedResult();
+    this.patch({
+      status: "idle",
+      gate: Object.freeze({ kind: "retake", reasons: Object.freeze([...reasons]) }),
+      error: null,
+      result: null
+    });
+    this.telemetry.track("analysis.quality_gate", { usable: false, reasons });
+    const outcome = reasons.includes("wrong_species") ? "species_unsupported" : "retake";
+    this.telemetry.track("analysis.species_gate", { outcome, region });
+    return err(makeEverfurError("unknown", { retryable: false }));
+  }
+  fail(op, error) {
+    if (!this.alive(op.epoch)) return abortedResult();
+    this.patch({ status: "error", error, gate: ACCEPTED });
+    this.telemetry.trackExpectedFailure("analysis.error", {
+      code: error.code,
+      ...error.httpStatus !== void 0 ? { httpStatus: error.httpStatus } : {}
+    });
+    return err(error);
+  }
+};
+function mapPhotoResult(body, region, jobId) {
+  const projection = projectDetectionMetadata(locateDetectionMetadata(body));
+  const meta = projection.metadata;
+  const interpretation = parseInterpretation(locateInterpretation(body));
+  const result = Object.freeze({
+    jobId,
+    analysisType: region,
+    primaryLabel: asString(meta["primary_label"]) ?? "Uncertain",
+    riskTier: asRiskTier(meta["risk_tier"]),
+    confidence: asUnitNumber(meta["primary_confidence"]),
+    subtypeDisplay: asString(meta["subtype_display"]),
+    confidenceTier: asConfidenceTier(meta["confidence_tier"]),
+    diseaseName: asString(meta["disease_name"]),
+    diseaseFraming: asString(meta["disease_framing"]),
+    copyShort: asString(meta["copy_short"]),
+    interpretation,
+    modelVersion: asString(meta["model_version"]) ?? (isRecord2(body) ? asString(body["model_version"]) : null)
+  });
+  return { result, droppedOperatorKeys: projection.droppedOperatorKeys };
+}
+function asRiskTier(value) {
+  return value === "low_risk" || value === "concern" || value === "uncertain" ? value : null;
+}
+function asConfidenceTier(value) {
+  return value === "possible" || value === "probable" ? value : null;
+}
+function abortedResult() {
+  return err(makeEverfurError("unknown", { retryable: false }));
+}
+function defaultIdempotencyFactory() {
+  let counter = 0;
+  return () => `photo-analyze-${Date.now().toString(36)}-${(counter++).toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// src/client/entitlements/resolve.ts
+var REQUIRES = Object.freeze({
+  chat: Object.freeze(["chat.message.create"]),
+  records: Object.freeze(["records.upload.create", "records.record.read"]),
+  video: Object.freeze(["video.gait.execute"]),
+  photo: Object.freeze(["photo.checkup.execute"]),
+  animations: Object.freeze(["animations.state.read"])
+});
+function requires(name) {
+  return REQUIRES[name];
+}
+function decideCapability(name, decisions, opts) {
+  if (opts?.isPending === true) {
+    return freezeDecision({ name, enabled: false, isPending: true, limits: {} });
+  }
+  const keys = requires(name);
+  const byResource = /* @__PURE__ */ new Map();
+  for (const decision of decisions) byResource.set(decision.resource, decision);
+  const limits = mergeLimits(keys, byResource);
+  const missing = keys.filter((key) => byResource.get(key)?.granted !== true);
+  if (missing.length === 0) {
+    return freezeDecision({ name, enabled: true, isPending: false, limits });
+  }
+  return freezeDecision({
+    name,
+    enabled: false,
+    isPending: false,
+    limits,
+    disabled: disabledFor(keys, byResource)
+  });
+}
+function mergeLimits(keys, byResource) {
+  const out = {};
+  for (const key of keys) {
+    const decisionLimits = byResource.get(key)?.limits;
+    if (!decisionLimits) continue;
+    for (const [limitKey, limitValue] of Object.entries(decisionLimits)) {
+      const existing = out[limitKey];
+      out[limitKey] = existing === void 0 ? limitValue : Math.min(existing, limitValue);
+    }
+  }
+  return out;
+}
+function disabledFor(keys, byResource) {
+  for (const key of keys) {
+    const explicit = byResource.get(key)?.disabled;
+    if (explicit) {
+      return Object.freeze({
+        reason: explicit.reason,
+        level: explicit.level,
+        recoverable: explicit.recoverable
+      });
+    }
+  }
+  return Object.freeze({
+    reason: userFacingError("accessDenied"),
+    level: "user_entitlement",
+    recoverable: false
+  });
+}
+function freezeDecision(d) {
+  const base = {
+    name: d.name,
+    enabled: d.enabled,
+    isPending: d.isPending,
+    limits: Object.freeze({ ...d.limits })
+  };
+  if (d.disabled !== void 0) base.disabled = d.disabled;
+  return Object.freeze(base);
+}
+
+// src/client/theme/tokens.ts
+function deepFreeze(value) {
+  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const key of Object.keys(value)) {
+      deepFreeze(value[key]);
+    }
+  }
+  return value;
+}
+var SPACE = { xs: 4, sm: 8, md: 12, lg: 16, xl: 24, xxl: 32 };
+var RADIUS = { tile: 5, xs: 6, sm: 10, md: 14, lg: 20, xl: 28, pill: 500 };
+var TYPE_SIZE = {
+  nano: 8,
+  small: 9,
+  micro: 10,
+  tiny: 11,
+  caption: 12,
+  bodyTight: 13,
+  body: 14,
+  subtitle: 16,
+  heading: 18,
+  verdict: 24
+};
+var LINE_HEIGHT = { tight: 1.15, snug: 1.3, normal: 1.4, relaxed: 1.55 };
+var WEIGHT = { regular: "400", medium: "500", bold: "700" };
+var LETTER_SPACING = {
+  eyebrow: 1,
+  monoWide: 0.9,
+  headerBrand: -0.42,
+  tight: -0.35
+};
+function baseType() {
+  return {
+    family: "System",
+    mono: "monospace",
+    fontUrl: null,
+    size: TYPE_SIZE,
+    lineHeight: LINE_HEIGHT,
+    weight: WEIGHT,
+    letterSpacing: LETTER_SPACING
+  };
+}
+var MOTION = {
+  duration: { instant: 80, fast: 140, normal: 220, slow: 320 },
+  spring: { gentle: { damping: 18, stiffness: 200 } },
+  easing: { standard: "cubic-bezier(0.4, 0, 0.2, 1)" },
+  reducedMotion: false
+};
+var LIGHT_COLOR = {
+  brand: "#10462E",
+  brandSoft: "rgba(16,70,46,0.10)",
+  brandSofter: "rgba(16,70,46,0.15)",
+  brandBorder: "rgba(16,70,46,0.18)",
+  borderHairlineGreen: "rgba(16,70,46,0.25)",
+  surface: "#FFFFFF",
+  surfaceCream: "#FDFBF8",
+  surfaceSubtle: "#EFE9E3",
+  background: "#FFFFFF",
+  borderRingCream: "#D8D2C8",
+  text: {
+    primary: "#111111",
+    secondary: "#0E462E",
+    muted: "#6E6660",
+    placeholder: "rgba(0,0,0,0.30)",
+    onBrand: "#FFFFFF",
+    metaCool: "#3D3D3D"
+  },
+  primary: "#10462E",
+  onPrimary: "#FFFFFF",
+  accent: "#10462E",
+  onAccent: "#FFFFFF",
+  accentEdge: "#07C168",
+  success: "#07C168",
+  danger: "#B91C1C",
+  errorRed: "#FF1B00",
+  warningStrong: "#A45610",
+  cautionAccent: "#D9821D",
+  riskConcern: "#EFA700",
+  badgeBgPositive: "rgba(7,193,104,0.12)",
+  badgeBgCaution: "rgba(217,130,29,0.14)",
+  badgeBgCritical: "rgba(185,28,28,0.12)",
+  badgeBgNeutral: "rgba(110,102,96,0.12)",
+  bubbleUser: "#10462E",
+  bubbleAssistant: "#FFFFFF",
+  skeleton: "#EFE9E3",
+  scanButtonPink: "#FFC3BC",
+  checkupCardLowRiskBg: "rgba(7,193,104,0.10)",
+  checkupCardConcernBg: "rgba(239,167,0,0.10)"
+};
+var EVERFUR_LIGHT = deepFreeze({
+  brightness: "light",
+  meta: { displayName: "Everfur", logoUrl: null, placeholder: null, hidePoweredBy: false },
+  color: LIGHT_COLOR,
+  space: SPACE,
+  radius: RADIUS,
+  type: baseType(),
+  motion: MOTION
+});
+var DARK_COLOR = {
+  brand: "#6BD39A",
+  brandSoft: "rgba(107,211,154,0.12)",
+  brandSofter: "rgba(107,211,154,0.18)",
+  brandBorder: "rgba(107,211,154,0.22)",
+  borderHairlineGreen: "rgba(107,211,154,0.28)",
+  surface: "#1C1F23",
+  surfaceCream: "#23272C",
+  surfaceSubtle: "#23272C",
+  background: "#15171A",
+  borderRingCream: "#3A3F45",
+  text: {
+    primary: "#F5F3F0",
+    secondary: "#A9E4C4",
+    muted: "#9A938C",
+    placeholder: "rgba(255,255,255,0.35)",
+    onBrand: "#0E1F17",
+    metaCool: "#C9C9C9"
+  },
+  primary: "#6BD39A",
+  onPrimary: "#0E1F17",
+  accent: "#6BD39A",
+  onAccent: "#0E1F17",
+  accentEdge: "#34D888",
+  success: "#07C168",
+  danger: "#B91C1C",
+  errorRed: "#FF1B00",
+  warningStrong: "#A45610",
+  cautionAccent: "#D9821D",
+  riskConcern: "#EFA700",
+  badgeBgPositive: "rgba(7,193,104,0.18)",
+  badgeBgCaution: "rgba(217,130,29,0.20)",
+  badgeBgCritical: "rgba(185,28,28,0.22)",
+  badgeBgNeutral: "rgba(255,255,255,0.10)",
+  bubbleUser: "#6BD39A",
+  bubbleAssistant: "#1C1F23",
+  skeleton: "#23272C",
+  scanButtonPink: "#FFC3BC",
+  checkupCardLowRiskBg: "rgba(7,193,104,0.16)",
+  checkupCardConcernBg: "rgba(239,167,0,0.16)"
+};
+deepFreeze({
+  brightness: "dark",
+  meta: { displayName: "Everfur", logoUrl: null, placeholder: null, hidePoweredBy: false },
+  color: DARK_COLOR,
+  space: SPACE,
+  radius: RADIUS,
+  type: baseType(),
+  motion: MOTION
+});
+var EVERFUR_THEME_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("@everfur/sdk#EverfurThemeContext@v1");
+var globalThemeHost = globalThis;
+var EverfurThemeContext = globalThemeHost[EVERFUR_THEME_CONTEXT_SYMBOL] ?? (globalThemeHost[EVERFUR_THEME_CONTEXT_SYMBOL] = react.createContext(EVERFUR_LIGHT));
+EverfurThemeContext.displayName ??= "EverfurThemeContext";
+function useEverfurTheme() {
+  return react.useContext(EverfurThemeContext);
+}
+
+// src/rn/facade.ts
+var EVERFUR_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("@everfur/sdk#EverfurContext@v1");
+var globalContextHost = globalThis;
+var EverfurContext = globalContextHost[EVERFUR_CONTEXT_SYMBOL] ?? (globalContextHost[EVERFUR_CONTEXT_SYMBOL] = react.createContext(null));
+EverfurContext.displayName ??= "EverfurContext";
+function useEverfurContext() {
+  const ctx = react.useContext(EverfurContext);
+  if (ctx === null) {
+    throw new EverfurConfigError(
+      "not-initialized",
+      "Everfur hooks must be called inside <EverfurProvider>. Wrap your tree once, high."
+    );
+  }
+  return ctx;
+}
+
+// src/rn/photo/usePhoto.ts
+var BOOTSTRAP_SNAPSHOT = Object.freeze({
+  status: "idle",
+  region: "skin",
+  result: null,
+  gate: Object.freeze({ kind: "accepted" }),
+  error: null,
+  isCaptureAvailable: false
+});
+var NOOP_UNSUBSCRIBE = () => {
+};
+function usePhotoCheckup(opts) {
+  const { runtime, userRef } = useEverfurContext();
+  const petRef = opts.petRef;
+  const [controller, setController] = react.useState(null);
+  react.useEffect(() => {
+    const { services } = runtime.registry;
+    const acquired = runtime.registry.acquire(
+      "photo",
+      `${userRef ?? ""}|${petRef}`,
+      () => createPhotoController({
+        ...services.errorPolicy ? { errorPolicy: services.errorPolicy } : {},
+        auth: services.authFor(userRef),
+        camera: services.camera,
+        upload: services.upload,
+        telemetry: services.telemetry
+      }),
+      (controller2) => controller2.dispose()
+    );
+    setController(acquired);
+    return () => {
+      setController((current) => current === acquired ? null : current);
+      runtime.registry.release(acquired);
+    };
+  }, [runtime, userRef, petRef]);
+  const subscribe = react.useCallback(
+    (onChange) => controller ? controller.subscribe(onChange) : NOOP_UNSUBSCRIBE,
+    [controller]
+  );
+  const getSnapshot = react.useCallback(
+    () => controller ? controller.getSnapshot() : BOOTSTRAP_SNAPSHOT,
+    [controller]
+  );
+  const snapshot = react.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const analyze = react.useCallback(
+    (source, region) => controller ? controller.analyze(source, region, { petRef }) : Promise.resolve(notReadyError()),
+    [controller, petRef]
+  );
+  const capture = react.useCallback(
+    (region) => controller ? controller.capture(region, { petRef }) : Promise.resolve(notReadyError()),
+    [controller, petRef]
+  );
+  const reset = react.useCallback(() => {
+    controller?.reset();
+  }, [controller]);
+  return react.useMemo(
+    () => ({
+      status: snapshot.status,
+      region: snapshot.region,
+      result: snapshot.result,
+      gate: snapshot.gate,
+      error: snapshot.error,
+      isCaptureAvailable: snapshot.isCaptureAvailable,
+      isBootstrapping: controller === null,
+      analyze,
+      capture,
+      reset
+    }),
+    [snapshot, controller, analyze, capture, reset]
+  );
+}
+function notReadyError() {
+  return err(
+    makeEverfurError("internalError", { retryable: true })
+  );
+}
+function useCapability(name) {
+  const { runtime } = useEverfurContext();
+  const store = runtime.entitlements;
+  const snapshot = react.useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot
+  );
+  return react.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 = react.useMemo(() => selectView(decision), [decision]);
+  switch (view) {
+    case "enabled":
+      return children;
+    case "pending":
+      return renderPending ? renderPending() : /* @__PURE__ */ jsxRuntime.jsx(PendingSkeleton, { capability, style });
+    case "disabled":
+      return renderDisabled ? renderDisabled(decision) : /* @__PURE__ */ jsxRuntime.jsx(OffState, { decision, style });
+    default:
+      return assertNever(view);
+  }
+}
+function PendingSkeleton({
+  capability,
+  style
+}) {
+  const theme = useEverfurTheme();
+  const styles = react.useMemo(() => makeStyles(theme), [theme]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.View,
+    {
+      style: [styles.offstate, style],
+      accessible: true,
+      accessibilityState: { busy: true },
+      accessibilityLabel: `Loading ${capability}`,
+      children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles.skeletonBar })
+    }
+  );
+}
+function OffState({
+  decision,
+  style
+}) {
+  const theme = useEverfurTheme();
+  const styles = react.useMemo(() => makeStyles(theme), [theme]);
+  const message = decision.disabled?.reason ?? "";
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.View,
+    {
+      style: [styles.offstate, style],
+      accessible: true,
+      accessibilityRole: "text",
+      accessibilityLabel: message,
+      children: message.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.offstateText, children: message }) : null
+    }
+  );
+}
+function makeStyles(theme) {
+  const { color, space, radius, type } = theme;
+  return reactNative.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: reactNative.StyleSheet.hairlineWidth,
+      borderColor: color.brandBorder
+    },
+    offstateText: {
+      fontFamily: type.family,
+      fontSize: type.size.body,
+      lineHeight: Math.round(type.size.body * type.lineHeight.normal),
+      color: color.text.muted
+    },
+    // A soft green shimmer bar (brand wash) that stays legible on the cream card in both light and dark,
+    // where the neutral `skeleton` token would collide with the dark cream surface.
+    skeletonBar: {
+      height: space.md,
+      borderRadius: radius.xs,
+      backgroundColor: color.brandSofter
+    }
+  });
+}
+var CLINICAL_DISCLAIMER = Object.freeze({
+  title: "For educational use only",
+  body: "Everfur is for educational purposes only. It helps you track visible changes through AI checkups. It does not diagnose, treat, prescribe, or replace veterinary care. For urgent symptoms or emergencies, contact a veterinarian immediately."
+});
+function ClinicalDisclaimer(props) {
+  const theme = useEverfurTheme();
+  const styles = react.useMemo(() => makeStyles2(theme), [theme]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactNative.View,
+    {
+      style: [styles.container, props.style],
+      accessible: true,
+      accessibilityRole: "text",
+      accessibilityLabel: `${CLINICAL_DISCLAIMER.title}. ${CLINICAL_DISCLAIMER.body}`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.title, children: CLINICAL_DISCLAIMER.title }),
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.body, children: CLINICAL_DISCLAIMER.body })
+      ]
+    }
+  );
+}
+function makeStyles2(theme) {
+  const { color, space, type } = theme;
+  return reactNative.StyleSheet.create({
+    container: {
+      paddingHorizontal: space.lg,
+      paddingVertical: space.md,
+      borderTopWidth: reactNative.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 ROTATION_PERIOD_MS = 1400;
+var REVEAL_DELAY_MS = 300;
+function AnalyzingIndicator() {
+  const theme = useEverfurTheme();
+  const styles = react.useMemo(() => makeStyles3(theme), [theme]);
+  const reduced = theme.motion.reducedMotion;
+  const [visible, setVisible] = react.useState(false);
+  react.useEffect(() => {
+    const id = setTimeout(() => setVisible(true), REVEAL_DELAY_MS);
+    return () => clearTimeout(id);
+  }, []);
+  const spin = react.useRef(new reactNative.Animated.Value(0)).current;
+  react.useEffect(() => {
+    if (reduced || !visible) return;
+    const loop = reactNative.Animated.loop(
+      reactNative.Animated.timing(spin, {
+        toValue: 1,
+        duration: ROTATION_PERIOD_MS,
+        easing: reactNative.Easing.linear,
+        useNativeDriver: true
+      })
+    );
+    loop.start();
+    return () => loop.stop();
+  }, [reduced, visible, spin]);
+  const arcMotionStyle = reduced ? null : { transform: [{ rotate: spin.interpolate({ inputRange: [0, 1], outputRange: ["0deg", "360deg"] }) }] };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.View,
+    {
+      style: styles.wrap,
+      accessible: true,
+      accessibilityState: { busy: true },
+      accessibilityLabel: "Analyzing photo",
+      children: visible ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.Animated.View, { style: [styles.ring, arcMotionStyle] }),
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.statusLine, children: "Analyzing" })
+      ] }) : null
+    }
+  );
+}
+function makeStyles3(theme) {
+  const { color, space, radius, type } = theme;
+  const medium = type.weight.medium;
+  const ringSize = space.xxl * 2;
+  const ringThickness = space.xs;
+  return reactNative.StyleSheet.create({
+    wrap: {
+      flexGrow: 1,
+      alignItems: "center",
+      justifyContent: "center",
+      padding: space.xl,
+      gap: space.md
+    },
+    // One rotating ring: success on the top/right, cream on the remainder. Only the success sweep is perceptible
+    // (the cream half is uniform), so this reads as a cream ring with a rotating success arc - the mobile look.
+    ring: {
+      width: ringSize,
+      height: ringSize,
+      borderRadius: radius.pill,
+      borderWidth: ringThickness,
+      borderTopColor: color.success,
+      borderRightColor: color.success,
+      borderBottomColor: color.borderRingCream,
+      borderLeftColor: color.borderRingCream
+    },
+    // Neutral SDK-owned structural status word (not clinical / product copy), on the brand-green secondary ramp
+    // so it sits in the same family as the verdict hero. Legible in both themes via the token.
+    statusLine: {
+      color: color.text.secondary,
+      fontFamily: type.family,
+      fontSize: type.size.subtitle,
+      lineHeight: type.size.subtitle * type.lineHeight.snug,
+      fontWeight: medium,
+      letterSpacing: type.letterSpacing.tight,
+      textAlign: "center"
+    }
+  });
+}
+var PULSE_PERIOD_MS = 1100;
+var PULSE_MAX_SCALE = 1.6;
+var PULSE_START_OPACITY = 0.35;
+function toneSpec(theme, tier) {
+  const { color } = theme;
+  switch (tier) {
+    case "low_risk":
+      return { accent: color.success, wash: color.badgeBgPositive, label: "Low risk", pulse: false };
+    case "concern":
+      return { accent: color.cautionAccent, wash: color.badgeBgCaution, label: "Concern", pulse: true };
+    case "uncertain":
+      return { accent: color.text.muted, wash: color.badgeBgNeutral, label: "Uncertain", pulse: false };
+  }
+}
+function SeverityBadge({ riskTier }) {
+  const theme = useEverfurTheme();
+  const styles = react.useMemo(() => makeStyles4(theme), [theme]);
+  const pulse = react.useRef(new reactNative.Animated.Value(0)).current;
+  const spec = riskTier === null ? null : toneSpec(theme, riskTier);
+  const shouldPulse = spec !== null && spec.pulse && !theme.motion.reducedMotion;
+  react.useEffect(() => {
+    if (!shouldPulse) return;
+    const loop = reactNative.Animated.loop(
+      reactNative.Animated.timing(pulse, {
+        toValue: 1,
+        duration: PULSE_PERIOD_MS,
+        easing: reactNative.Easing.out(reactNative.Easing.quad),
+        useNativeDriver: true
+      })
+    );
+    loop.start();
+    return () => loop.stop();
+  }, [shouldPulse, pulse]);
+  if (spec === null) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactNative.View,
+    {
+      style: [styles.pill, { backgroundColor: spec.wash }],
+      accessible: true,
+      accessibilityRole: "text",
+      accessibilityLabel: spec.label,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles.dotWrap, children: [
+          shouldPulse ? /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.Animated.View,
+            {
+              pointerEvents: "none",
+              style: [
+                styles.dotRing,
+                {
+                  backgroundColor: spec.accent,
+                  opacity: pulse.interpolate({ inputRange: [0, 1], outputRange: [PULSE_START_OPACITY, 0] }),
+                  transform: [{ scale: pulse.interpolate({ inputRange: [0, 1], outputRange: [1, PULSE_MAX_SCALE] }) }]
+                }
+              ]
+            }
+          ) : null,
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [styles.dot, { backgroundColor: spec.accent }] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles.label, { color: spec.accent }], children: spec.label })
+      ]
+    }
+  );
+}
+function makeStyles4(theme) {
+  const { space, radius, type } = theme;
+  const bold = type.weight.bold;
+  const dotSize = space.sm;
+  return reactNative.StyleSheet.create({
+    pill: {
+      alignSelf: "flex-start",
+      flexDirection: "row",
+      alignItems: "center",
+      gap: space.sm,
+      paddingHorizontal: space.md,
+      paddingVertical: space.xs,
+      borderRadius: radius.pill
+    },
+    dotWrap: {
+      width: dotSize,
+      height: dotSize,
+      alignItems: "center",
+      justifyContent: "center"
+    },
+    dot: {
+      width: dotSize,
+      height: dotSize,
+      borderRadius: radius.pill
+    },
+    // The pulsing attention ring behind the dot (concern only). backgroundColor + animated opacity/scale set inline.
+    dotRing: {
+      position: "absolute",
+      width: dotSize,
+      height: dotSize,
+      borderRadius: radius.pill
+    },
+    label: {
+      fontFamily: type.family,
+      fontSize: type.size.caption,
+      lineHeight: type.size.caption * type.lineHeight.snug,
+      fontWeight: bold,
+      letterSpacing: type.letterSpacing.eyebrow
+    }
+  });
+}
+var MIN_SURFACE_HEIGHT = 120;
+var MIN_TOUCH_TARGET = 44;
+function PhotoCheckup(props) {
+  const { petRef, region, style } = props;
+  return /* @__PURE__ */ jsxRuntime.jsx(CapabilityGate, { capability: "photo", style, children: /* @__PURE__ */ jsxRuntime.jsx(PhotoBody, { petRef, region, style }) });
+}
+function selectView2(state) {
+  if (state.isBootstrapping) return "loading";
+  if (state.status === "capturing" || state.status === "analyzing") return "loading";
+  if (state.status === "error" && state.error) return "error";
+  if (state.status === "complete" && state.result) return "populated";
+  if (state.gate.kind !== "accepted") return "gate";
+  if (!state.isCaptureAvailable) return "native";
+  return "empty";
+}
+function PhotoBody({
+  petRef,
+  region,
+  style
+}) {
+  const photo = usePhotoCheckup({ petRef });
+  const activeRegion = region ?? "skin";
+  const view = selectView2(photo);
+  const capture = react.useMemo(() => () => void photo.capture(activeRegion), [photo, activeRegion]);
+  const theme = useEverfurTheme();
+  const styles = react.useMemo(() => makeStyles5(theme), [theme]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [styles.container, style], children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles.body, children: renderView(view, photo, capture) }),
+    /* @__PURE__ */ jsxRuntime.jsx(ClinicalDisclaimer, {})
+  ] });
+}
+function renderView(view, photo, capture) {
+  switch (view) {
+    case "loading":
+      return /* @__PURE__ */ jsxRuntime.jsx(AnalyzingIndicator, {});
+    case "native":
+      return /* @__PURE__ */ jsxRuntime.jsx(NativeUnavailableState, {});
+    case "empty":
+      return /* @__PURE__ */ jsxRuntime.jsx(EmptyState, { onCapture: capture });
+    case "error":
+      return /* @__PURE__ */ jsxRuntime.jsx(ErrorState, { error: photo.error, onRetry: capture });
+    case "gate":
+      return /* @__PURE__ */ jsxRuntime.jsx(GateState, { gate: photo.gate, onRetry: photo.reset });
+    case "populated":
+      return /* @__PURE__ */ jsxRuntime.jsx(ResultState, { result: photo.result });
+    default:
+      return assertNever(view);
+  }
+}
+function NativeUnavailableState() {
+  const theme = useEverfurTheme();
+  const styles = react.useMemo(() => makeStyles5(theme), [theme]);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles.offstate, accessible: true, accessibilityRole: "text", accessibilityLabel: "Camera is unavailable", children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles.emptyGlyph }) });
+}
+function EmptyState({ onCapture }) {
+  const theme = useEverfurTheme();
+  const styles = react.useMemo(() => makeStyles5(theme), [theme]);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles.centered, accessible: true, accessibilityRole: "summary", accessibilityLabel: "Take a photo to check", children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { onPress: onCapture, accessibilityRole: "button", accessibilityLabel: "Take photo", style: styles.scanButton, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.scanLabel, children: "Take photo" }) }) });
+}
+function ErrorState({ error, onRetry }) {
+  const theme = useEverfurTheme();
+  const styles = react.useMemo(() => makeStyles5(theme), [theme]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles.centered, accessible: true, accessibilityRole: "alert", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.errorText, children: error.displayMessage }),
+    error.retryable ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { onPress: onRetry, accessibilityRole: "button", accessibilityLabel: "Try again", style: styles.primaryButton, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.primaryLabel, children: "Try again" }) }) : null
+  ] });
+}
+function GateState({ gate, onRetry }) {
+  const theme = useEverfurTheme();
+  const styles = react.useMemo(() => makeStyles5(theme), [theme]);
+  const message = gateMessage(gate);
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles.centered, accessible: true, accessibilityRole: "summary", accessibilityLabel: message, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.guidanceText, children: message }),
+    gate.kind !== "species_unsupported" ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { onPress: onRetry, accessibilityRole: "button", accessibilityLabel: "Try again", style: styles.primaryButton, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.primaryLabel, children: "Try again" }) }) : null
+  ] });
+}
+function gateMessage(gate) {
+  switch (gate.kind) {
+    case "species_unsupported":
+      return "Photo checks are coming soon for this pet.";
+    case "pet_context_required":
+      return "Choose a pet first, then take the photo.";
+    case "retake":
+      return "That photo was hard to read. Please take another.";
+    case "accepted":
+      return "";
+    default:
+      return assertNever(gate);
+  }
+}
+function ResultState({ result }) {
+  const theme = useEverfurTheme();
+  const styles = react.useMemo(() => makeStyles5(theme), [theme]);
+  const headline = result.subtypeDisplay ?? result.diseaseName ?? result.primaryLabel;
+  const cardTint = resultCardTint(theme, result.riskTier);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactNative.ScrollView,
+    {
+      style: styles.list,
+      contentContainerStyle: [styles.listContent, { backgroundColor: cardTint }],
+      accessibilityLabel: "Photo checkup result",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.resultHeadline, children: headline }),
+        /* @__PURE__ */ jsxRuntime.jsx(SeverityBadge, { riskTier: result.riskTier }),
+        result.diseaseFraming ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.summaryText, children: result.diseaseFraming }) : null,
+        result.copyShort ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.summaryText, children: result.copyShort }) : null,
+        result.interpretation ? /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles.interpretationBlock, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.summaryText, children: result.interpretation.summary }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.disclaimerText, children: result.interpretation.disclaimer })
+        ] }) : null
+      ]
+    }
+  );
+}
+function resultCardTint(theme, riskTier) {
+  switch (riskTier) {
+    case "low_risk":
+      return theme.color.checkupCardLowRiskBg;
+    case "concern":
+      return theme.color.checkupCardConcernBg;
+    default:
+      return theme.color.surfaceCream;
+  }
+}
+function makeStyles5(theme) {
+  const { color, space, radius, type } = theme;
+  const bold = type.weight.bold;
+  const medium = type.weight.medium;
+  const regular = type.weight.regular;
+  const scanInk = theme.brightness === "dark" ? color.onAccent : color.brand;
+  return reactNative.StyleSheet.create({
+    container: { flex: 1, minHeight: MIN_SURFACE_HEIGHT, backgroundColor: color.background },
+    body: { flex: 1 },
+    centered: {
+      minHeight: MIN_SURFACE_HEIGHT,
+      flexGrow: 1,
+      alignItems: "center",
+      justifyContent: "center",
+      padding: space.xl
+    },
+    offstate: {
+      minHeight: MIN_SURFACE_HEIGHT,
+      alignItems: "center",
+      justifyContent: "center",
+      padding: space.xl
+    },
+    emptyGlyph: {
+      width: space.xxl,
+      height: space.xxl,
+      borderRadius: radius.pill,
+      backgroundColor: color.surfaceSubtle,
+      borderWidth: reactNative.StyleSheet.hairlineWidth,
+      borderColor: color.brandBorder
+    },
+    // Capture CTA — the Everfur pink scan pill (brief: scanButtonPink, radius pill, subtle depth).
+    scanButton: {
+      minHeight: MIN_TOUCH_TARGET,
+      minWidth: MIN_TOUCH_TARGET,
+      alignItems: "center",
+      justifyContent: "center",
+      paddingHorizontal: space.xl,
+      paddingVertical: space.md,
+      borderRadius: radius.pill,
+      backgroundColor: color.scanButtonPink,
+      shadowColor: color.brand,
+      shadowOpacity: 0.18,
+      shadowRadius: radius.xs,
+      shadowOffset: { width: 0, height: space.xs },
+      elevation: 3
+    },
+    scanLabel: {
+      color: scanInk,
+      fontFamily: type.family,
+      fontSize: type.size.subtitle,
+      lineHeight: type.size.subtitle * type.lineHeight.snug,
+      fontWeight: bold,
+      letterSpacing: type.letterSpacing.tight
+    },
+    // Secondary CTA — retry / try-again, brand fill with WCAG-legible onPrimary.
+    primaryButton: {
+      minHeight: MIN_TOUCH_TARGET,
+      minWidth: MIN_TOUCH_TARGET,
+      alignItems: "center",
+      justifyContent: "center",
+      paddingHorizontal: space.xl,
+      paddingVertical: space.sm,
+      borderRadius: radius.pill,
+      backgroundColor: color.brand
+    },
+    primaryLabel: {
+      color: color.onPrimary,
+      fontFamily: type.family,
+      fontSize: type.size.body,
+      lineHeight: type.size.body * type.lineHeight.snug,
+      fontWeight: medium
+    },
+    errorText: {
+      color: color.danger,
+      fontFamily: type.family,
+      fontSize: type.size.body,
+      lineHeight: type.size.body * type.lineHeight.relaxed,
+      textAlign: "center",
+      marginBottom: space.md
+    },
+    guidanceText: {
+      color: color.text.muted,
+      fontFamily: type.family,
+      fontSize: type.size.body,
+      lineHeight: type.size.body * type.lineHeight.relaxed,
+      textAlign: "center",
+      marginBottom: space.md
+    },
+    list: { flex: 1 },
+    // The checkup card — cream/risk-washed surface (backgroundColor supplied inline from resultCardTint), a
+    // brand hairline border, and a subtle brand-tinted shadow for depth.
+    listContent: {
+      padding: space.lg,
+      gap: space.sm,
+      borderRadius: radius.lg,
+      borderWidth: reactNative.StyleSheet.hairlineWidth,
+      borderColor: color.brandBorder,
+      shadowColor: color.brand,
+      shadowOpacity: 0.08,
+      shadowRadius: radius.xs,
+      shadowOffset: { width: 0, height: space.xs },
+      elevation: 2
+    },
+    // Verdict hero (brief: type.verdict 24) in brand green for character.
+    resultHeadline: {
+      color: color.text.secondary,
+      fontFamily: type.family,
+      fontSize: type.size.verdict,
+      lineHeight: type.size.verdict * type.lineHeight.tight,
+      fontWeight: bold,
+      letterSpacing: type.letterSpacing.tight
+    },
+    summaryText: {
+      color: color.text.primary,
+      fontFamily: type.family,
+      fontSize: type.size.body,
+      lineHeight: type.size.body * type.lineHeight.relaxed,
+      fontWeight: regular
+    },
+    interpretationBlock: {
+      marginTop: space.sm,
+      paddingTop: space.sm,
+      gap: space.xs,
+      borderTopWidth: reactNative.StyleSheet.hairlineWidth,
+      borderTopColor: color.borderHairlineGreen
+    },
+    disclaimerText: {
+      color: color.text.muted,
+      fontFamily: type.family,
+      fontSize: type.size.caption,
+      lineHeight: type.size.caption * type.lineHeight.normal,
+      fontWeight: regular
+    }
+  });
+}
+
+exports.PhotoCheckup = PhotoCheckup;
+exports.usePhotoCheckup = usePhotoCheckup;