@everfur/sdk 0.1.0

package/dist/video/index.js

@@ -0,0 +1,1938 @@
+import { createContext, useState, useEffect, useCallback, useSyncExternalStore, useMemo, useContext } from 'react';
+import 'react-native-safe-area-context';
+import { View, ActivityIndicator, Pressable, Text, ScrollView, StyleSheet } from 'react-native';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/rn/video/useVideo.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 mediaDurationMs(source) {
+  const seconds = source.durationSeconds;
+  return typeof seconds === "number" && Number.isFinite(seconds) && seconds >= 0 ? Math.round(seconds * 1e3) : 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 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 detectNoGate() {
+  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/video/VideoController.ts
+function createVideoController(deps) {
+  return new VideoController(deps);
+}
+var VideoController = class extends MediaStore {
+  constructor(deps) {
+    super({
+      status: "idle",
+      job: null,
+      result: null,
+      error: null,
+      isCaptureAvailable: isCaptureAvailable(deps.camera),
+      progress: 0
+    });
+    this.funnel = deps.funnel ?? createRequestFunnel({
+      auth: deps.auth,
+      ...deps.errorPolicy ? { errorPolicy: deps.errorPolicy } : {}
+    });
+    this.camera = deps.camera;
+    this.upload = deps.upload;
+    this.defaultPetRef = deps.petRef ?? null;
+    this.telemetry = deps.telemetry ?? noopTelemetry;
+    this.timers = deps.timers ?? defaultTimers;
+    this.makeIdempotencyKey = deps.makeIdempotencyKey ?? defaultIdempotencyFactory();
+  }
+  /** Open the CameraPort (video), then submit. No-op when capture is unavailable; a cancel returns to idle. */
+  async capture(opts) {
+    if (!isCaptureAvailable(this.camera)) {
+      return err(makeEverfurError("unknown", { retryable: false }));
+    }
+    let source;
+    try {
+      source = await this.camera.capture(captureOptionsFor("video", 15));
+    } catch {
+      if (this.snapshot.status !== "idle") this.patch({ status: "idle", progress: 0 });
+      return err(makeEverfurError("unknown", { retryable: false }));
+    }
+    return this.submit(source, opts?.petRef !== void 0 ? { petRef: opts.petRef } : void 0);
+  }
+  /** Capture -> presigned PUT -> POST /video/analyze -> poll. Returns the JobId or a domain error. */
+  async submit(source, opts) {
+    const op = this.beginOperation(opts?.signal);
+    const petRef = opts?.petRef ?? this.defaultPetRef;
+    const idempotencyKey = this.makeIdempotencyKey();
+    const startedAt = this.timers.now();
+    this.patch({ status: "uploading", progress: 0, error: null, result: null, job: null });
+    try {
+      const initiated = await initiateUpload(this.funnel, {
+        purpose: "gait_video",
+        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) {
+        this.telemetry.track("analysis.upload", {
+          capability: "video",
+          purpose: "gait_video",
+          outcome: "failed"
+        });
+        return this.fail(op, staged.error);
+      }
+      this.patch({ progress: 1 });
+      this.telemetry.track("analysis.upload", {
+        capability: "video",
+        purpose: "gait_video",
+        byteSize: mediaByteSize(source) ?? 0,
+        durationMs: mediaDurationMs(source) ?? 0,
+        outcome: "ok"
+      });
+      this.patch({ status: "analyzing" });
+      const outcome = await submitAnalyze(
+        this.funnel,
+        ENDPOINTS.videoAnalyze,
+        analyzeBody(initiated.value.s3Key, { petRef }),
+        detectNoGate,
+        op.signal
+      );
+      if (op.signal.aborted || !this.alive(op.epoch)) return abortedResult();
+      if (outcome.kind === "error") return this.fail(op, outcome.error);
+      if (outcome.kind === "gate") return this.fail(op, makeEverfurError("unknown", { retryable: false }));
+      if (outcome.kind === "sync") {
+        const jobId = brandJobId(resultIdOf(outcome.body) ?? "");
+        return this.complete(op, outcome.body, jobId, startedAt);
+      }
+      const job = outcome.job;
+      this.patch({ job: { id: job.jobId, state: "processing" } });
+      const poll = await pollJob(this.funnel, job.jobId, {
+        timers: this.timers,
+        signal: op.signal,
+        alive: () => this.alive(op.epoch),
+        estimatedSeconds: 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, job.jobId, startedAt);
+        case "failed":
+          return this.fail(op, poll.error);
+        case "timeout":
+          return this.fail(op, makeEverfurError("streamTimeout", { retryable: true }));
+        case "notFound":
+          this.patch({ job: null });
+          return this.fail(op, makeEverfurError("conversationNotFound", { retryable: false, httpStatus: 404 }));
+        default:
+          return this.fail(op, makeEverfurError("internalError", { retryable: false }));
+      }
+    } finally {
+      op.settle();
+    }
+  }
+  /** Abort upload/poll; status returns to idle (aborted !== error). */
+  cancel() {
+    this.inFlight?.abort();
+    this.inFlight = null;
+    if (this.snapshot.status === "uploading" || this.snapshot.status === "analyzing") {
+      this.patch({ status: "idle", progress: 0 });
+    }
+  }
+  // ---- terminal transitions ---------------------------------------------
+  complete(op, body, jobId, startedAt) {
+    if (!this.alive(op.epoch)) return abortedResult();
+    const mapped = mapVideoResult(body, jobId);
+    if (mapped.droppedOperatorKeys > 0) {
+      this.telemetry.track("analysis.metadata_leak_guard", { droppedKeyCount: mapped.droppedOperatorKeys });
+    }
+    this.telemetry.track("analysis.quality_gate", {
+      usable: mapped.result.quality.usable,
+      reasons: mapped.result.quality.reasons
+    });
+    this.patch({
+      status: "complete",
+      progress: 1,
+      result: mapped.result,
+      error: null,
+      job: { id: jobId, state: "complete" }
+    });
+    this.telemetry.track("analysis.result", {
+      capability: "video",
+      modelVersion: mapped.result.modelVersion ?? "",
+      timeToResultMs: this.timers.now() - startedAt
+    });
+    return ok(jobId);
+  }
+  fail(op, error) {
+    if (!this.alive(op.epoch)) return abortedResult();
+    this.patch({ status: "error", error, progress: 0 });
+    this.telemetry.trackExpectedFailure("analysis.error", {
+      code: error.code,
+      ...error.httpStatus !== void 0 ? { httpStatus: error.httpStatus } : {}
+    });
+    return err(error);
+  }
+};
+function mapVideoResult(body, jobId) {
+  const projection = projectDetectionMetadata(locateDetectionMetadata(body));
+  const interpretation = parseInterpretation(locateInterpretation(body));
+  const modelVersion = asString(projection.metadata["model_version"]) ?? (isRecord2(body) ? asString(body["model_version"]) : null);
+  const result = Object.freeze({
+    jobId,
+    analysisType: "gait",
+    detections: parseVideoDetections(body),
+    interpretation,
+    modelVersion,
+    quality: parseQuality(body)
+  });
+  return { result, droppedOperatorKeys: projection.droppedOperatorKeys };
+}
+function parseVideoDetections(body) {
+  const raw = isRecord2(body) ? body["detections"] : null;
+  if (!Array.isArray(raw)) return Object.freeze([]);
+  const out = [];
+  for (const entry of raw) {
+    if (!isRecord2(entry)) continue;
+    const label = asString(entry["label"]) ?? asString(entry["name"]);
+    if (label === null) continue;
+    out.push(
+      Object.freeze({
+        label,
+        confidence: asUnitNumber(entry["confidence"]) ?? 0,
+        timestampMs: asFiniteNumber(entry["timestamp_ms"] ?? entry["timestamp"]),
+        durationMs: asFiniteNumber(entry["duration_ms"] ?? entry["duration"])
+      })
+    );
+  }
+  return Object.freeze(out);
+}
+function parseQuality(body) {
+  const raw = isRecord2(body) ? body["quality"] : null;
+  if (!isRecord2(raw)) return Object.freeze({ usable: true, reasons: Object.freeze([]) });
+  const usable = raw["usable"];
+  return Object.freeze({
+    usable: typeof usable === "boolean" ? usable : true,
+    reasons: Object.freeze(asStringList(raw["reasons"]))
+  });
+}
+function resultIdOf(body) {
+  if (!isRecord2(body)) return null;
+  return asString(body["result_id"]) ?? asString(body["request_id"]) ?? asString(body["job_id"]);
+}
+function abortedResult() {
+  return err(makeEverfurError("unknown", { retryable: false }));
+}
+function defaultIdempotencyFactory() {
+  let counter = 0;
+  return () => `video-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] = createContext(EVERFUR_LIGHT));
+EverfurThemeContext.displayName ??= "EverfurThemeContext";
+function useEverfurTheme() {
+  return useContext(EverfurThemeContext);
+}
+
+// src/rn/facade.ts
+var EVERFUR_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("@everfur/sdk#EverfurContext@v1");
+var globalContextHost = globalThis;
+var EverfurContext = globalContextHost[EVERFUR_CONTEXT_SYMBOL] ?? (globalContextHost[EVERFUR_CONTEXT_SYMBOL] = createContext(null));
+EverfurContext.displayName ??= "EverfurContext";
+function useEverfurContext() {
+  const ctx = useContext(EverfurContext);
+  if (ctx === null) {
+    throw new EverfurConfigError(
+      "not-initialized",
+      "Everfur hooks must be called inside <EverfurProvider>. Wrap your tree once, high."
+    );
+  }
+  return ctx;
+}
+
+// src/rn/video/useVideo.ts
+var BOOTSTRAP_SNAPSHOT = Object.freeze({
+  status: "idle",
+  job: null,
+  result: null,
+  error: null,
+  isCaptureAvailable: false,
+  progress: 0
+});
+var NOOP_UNSUBSCRIBE = () => {
+};
+function useEverfurVideo(opts) {
+  const { runtime, userRef, activePet } = useEverfurContext();
+  const petRef = opts?.petRef ?? activePet ?? null;
+  const [controller, setController] = useState(null);
+  useEffect(() => {
+    const { services } = runtime.registry;
+    const acquired = runtime.registry.acquire(
+      "video",
+      `${userRef ?? ""}|${petRef ?? ""}`,
+      () => createVideoController({
+        ...services.errorPolicy ? { errorPolicy: services.errorPolicy } : {},
+        auth: services.authFor(userRef),
+        camera: services.camera,
+        upload: services.upload,
+        petRef,
+        telemetry: services.telemetry
+      }),
+      (controller2) => controller2.dispose()
+    );
+    setController(acquired);
+    return () => {
+      setController((current) => current === acquired ? null : current);
+      runtime.registry.release(acquired);
+    };
+  }, [runtime, userRef, petRef]);
+  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 submit = useCallback(
+    (source) => controller ? controller.submit(source) : Promise.resolve(notReadyError()),
+    [controller]
+  );
+  const capture = useCallback(
+    () => controller ? controller.capture() : Promise.resolve(notReadyError()),
+    [controller]
+  );
+  const cancel = useCallback(() => {
+    controller?.cancel();
+  }, [controller]);
+  return useMemo(
+    () => ({
+      status: snapshot.status,
+      job: snapshot.job,
+      result: snapshot.result,
+      error: snapshot.error,
+      isCaptureAvailable: snapshot.isCaptureAvailable,
+      progress: snapshot.progress,
+      isBootstrapping: controller === null,
+      submit,
+      capture,
+      cancel
+    }),
+    [snapshot, controller, submit, capture, cancel]
+  );
+}
+function notReadyError() {
+  return err(
+    makeEverfurError("internalError", { retryable: true })
+  );
+}
+function useCapability(name) {
+  const { runtime } = useEverfurContext();
+  const store = runtime.entitlements;
+  const snapshot = useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot
+  );
+  return useMemo(
+    () => decideCapability(name, snapshot.decisions, { isPending: snapshot.isPending }),
+    [name, snapshot]
+  );
+}
+var MIN_OFFSTATE_HEIGHT = 48;
+function selectView(decision) {
+  if (decision.isPending) return "pending";
+  return decision.enabled ? "enabled" : "disabled";
+}
+function CapabilityGate(props) {
+  const { capability, children, renderDisabled, renderPending, style } = props;
+  const decision = useCapability(capability);
+  const view = useMemo(() => selectView(decision), [decision]);
+  switch (view) {
+    case "enabled":
+      return children;
+    case "pending":
+      return renderPending ? renderPending() : /* @__PURE__ */ jsx(PendingSkeleton, { capability, style });
+    case "disabled":
+      return renderDisabled ? renderDisabled(decision) : /* @__PURE__ */ jsx(OffState, { decision, style });
+    default:
+      return assertNever(view);
+  }
+}
+function PendingSkeleton({
+  capability,
+  style
+}) {
+  const theme = useEverfurTheme();
+  const styles = useMemo(() => makeStyles(theme), [theme]);
+  return /* @__PURE__ */ jsx(
+    View,
+    {
+      style: [styles.offstate, style],
+      accessible: true,
+      accessibilityState: { busy: true },
+      accessibilityLabel: `Loading ${capability}`,
+      children: /* @__PURE__ */ jsx(View, { style: styles.skeletonBar })
+    }
+  );
+}
+function OffState({
+  decision,
+  style
+}) {
+  const theme = useEverfurTheme();
+  const styles = useMemo(() => makeStyles(theme), [theme]);
+  const message = decision.disabled?.reason ?? "";
+  return /* @__PURE__ */ jsx(
+    View,
+    {
+      style: [styles.offstate, style],
+      accessible: true,
+      accessibilityRole: "text",
+      accessibilityLabel: message,
+      children: message.length > 0 ? /* @__PURE__ */ jsx(Text, { style: styles.offstateText, children: message }) : null
+    }
+  );
+}
+function makeStyles(theme) {
+  const { color, space, radius, type } = theme;
+  return StyleSheet.create({
+    // A deliberate cream card with a soft brand hairline, never a bare grey slab.
+    offstate: {
+      minHeight: MIN_OFFSTATE_HEIGHT,
+      justifyContent: "center",
+      paddingHorizontal: space.lg,
+      paddingVertical: space.md,
+      backgroundColor: color.surfaceCream,
+      borderRadius: radius.md,
+      borderWidth: StyleSheet.hairlineWidth,
+      borderColor: color.brandBorder
+    },
+    offstateText: {
+      fontFamily: type.family,
+      fontSize: type.size.body,
+      lineHeight: Math.round(type.size.body * type.lineHeight.normal),
+      color: color.text.muted
+    },
+    // A soft green shimmer bar (brand wash) that stays legible on the cream card in both light and dark,
+    // where the neutral `skeleton` token would collide with the dark cream surface.
+    skeletonBar: {
+      height: space.md,
+      borderRadius: radius.xs,
+      backgroundColor: color.brandSofter
+    }
+  });
+}
+var CLINICAL_DISCLAIMER = Object.freeze({
+  title: "For educational use only",
+  body: "Everfur is for educational purposes only. It helps you track visible changes through AI checkups. It does not diagnose, treat, prescribe, or replace veterinary care. For urgent symptoms or emergencies, contact a veterinarian immediately."
+});
+function ClinicalDisclaimer(props) {
+  const theme = useEverfurTheme();
+  const styles = useMemo(() => makeStyles2(theme), [theme]);
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      style: [styles.container, props.style],
+      accessible: true,
+      accessibilityRole: "text",
+      accessibilityLabel: `${CLINICAL_DISCLAIMER.title}. ${CLINICAL_DISCLAIMER.body}`,
+      children: [
+        /* @__PURE__ */ jsx(Text, { style: styles.title, children: CLINICAL_DISCLAIMER.title }),
+        /* @__PURE__ */ jsx(Text, { style: styles.body, children: CLINICAL_DISCLAIMER.body })
+      ]
+    }
+  );
+}
+function makeStyles2(theme) {
+  const { color, space, type } = theme;
+  return StyleSheet.create({
+    container: {
+      paddingHorizontal: space.lg,
+      paddingVertical: space.md,
+      borderTopWidth: StyleSheet.hairlineWidth,
+      borderTopColor: color.borderHairlineGreen,
+      backgroundColor: color.surfaceCream,
+      gap: space.xs
+    },
+    title: {
+      fontFamily: type.family,
+      fontSize: type.size.caption,
+      lineHeight: Math.round(type.size.caption * type.lineHeight.snug),
+      color: color.text.secondary,
+      fontWeight: type.weight.bold,
+      letterSpacing: type.letterSpacing.eyebrow
+    },
+    body: {
+      fontFamily: type.family,
+      fontSize: type.size.caption,
+      lineHeight: Math.round(type.size.caption * type.lineHeight.snug),
+      color: color.text.muted,
+      fontWeight: type.weight.regular
+    }
+  });
+}
+var SPINNER_DELAY_MS = 300;
+var MIN_SURFACE_HEIGHT = 120;
+var TOUCH_TARGET = 44;
+var GLYPH_SIZE = 40;
+var PROGRESS_TRACK_WIDTH = 160;
+function EverfurVideo(props) {
+  const { petRef, style } = props;
+  return /* @__PURE__ */ jsx(CapabilityGate, { capability: "video", style, children: /* @__PURE__ */ jsx(VideoBody, { petRef, style }) });
+}
+function selectView2(state) {
+  if (state.isBootstrapping) return "loading";
+  if (state.status === "uploading" || state.status === "analyzing") return "loading";
+  if (state.status === "error" && state.error) return "error";
+  if (state.status === "complete" && state.result) return "populated";
+  if (!state.isCaptureAvailable) return "native";
+  return "empty";
+}
+function VideoBody({
+  petRef,
+  style
+}) {
+  const videoOpts = useMemo(() => petRef !== void 0 ? { petRef } : void 0, [petRef]);
+  const video = useEverfurVideo(videoOpts);
+  const view = selectView2(video);
+  const { styles } = useVideoStyles();
+  return /* @__PURE__ */ jsxs(View, { style: [styles.container, style], children: [
+    /* @__PURE__ */ jsx(View, { style: styles.body, children: renderView(view, video) }),
+    /* @__PURE__ */ jsx(ClinicalDisclaimer, {})
+  ] });
+}
+function renderView(view, video) {
+  switch (view) {
+    case "loading":
+      return /* @__PURE__ */ jsx(LoadingState, { progress: video.progress });
+    case "native":
+      return /* @__PURE__ */ jsx(NativeUnavailableState, {});
+    case "empty":
+      return /* @__PURE__ */ jsx(EmptyState, { onCapture: video.capture });
+    case "error":
+      return /* @__PURE__ */ jsx(ErrorState, { error: video.error, onRetry: video.capture });
+    case "populated":
+      return /* @__PURE__ */ jsx(ResultState, { result: video.result });
+    default:
+      return assertNever(view);
+  }
+}
+function LoadingState({ progress }) {
+  const { theme, styles } = useVideoStyles();
+  const [visible, setVisible] = useState(false);
+  useEffect(() => {
+    const id = setTimeout(() => setVisible(true), SPINNER_DELAY_MS);
+    return () => clearTimeout(id);
+  }, []);
+  const pct = Math.max(0, Math.min(1, progress));
+  return /* @__PURE__ */ jsxs(View, { style: styles.centered, accessible: true, accessibilityState: { busy: true }, accessibilityLabel: "Analyzing video", children: [
+    visible ? /* @__PURE__ */ jsx(ActivityIndicator, { color: theme.color.brand }) : null,
+    visible && pct > 0 && pct < 1 ? /* @__PURE__ */ jsx(View, { style: styles.progressTrack, accessibilityRole: "progressbar", children: /* @__PURE__ */ jsx(View, { style: [styles.progressFill, { width: `${Math.round(pct * 100)}%` }] }) }) : null
+  ] });
+}
+function NativeUnavailableState() {
+  const { styles } = useVideoStyles();
+  return /* @__PURE__ */ jsx(View, { style: styles.offstate, accessible: true, accessibilityRole: "text", accessibilityLabel: "Camera is unavailable", children: /* @__PURE__ */ jsx(View, { style: styles.emptyGlyph }) });
+}
+function EmptyState({ onCapture }) {
+  const { styles } = useVideoStyles();
+  return /* @__PURE__ */ jsx(View, { style: styles.centered, accessible: true, accessibilityRole: "summary", accessibilityLabel: "Record a short clip to check gait", children: /* @__PURE__ */ jsx(
+    Pressable,
+    {
+      onPress: onCapture,
+      accessibilityRole: "button",
+      accessibilityLabel: "Record video",
+      style: styles.primaryButton,
+      children: /* @__PURE__ */ jsx(Text, { style: styles.primaryLabel, children: "Record video" })
+    }
+  ) });
+}
+function ErrorState({ error, onRetry }) {
+  const { styles } = useVideoStyles();
+  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.primaryButton, children: /* @__PURE__ */ jsx(Text, { style: styles.primaryLabel, children: "Try again" }) }) : null
+  ] });
+}
+function ResultState({ result }) {
+  const { styles } = useVideoStyles();
+  if (!result.quality.usable) {
+    return /* @__PURE__ */ jsx(View, { style: styles.centered, accessible: true, accessibilityRole: "summary", accessibilityLabel: "Result uncertain", children: /* @__PURE__ */ jsx(Text, { style: styles.uncertainText, children: "We could not get a clear read from this clip. Try recording again." }) });
+  }
+  return /* @__PURE__ */ jsxs(ScrollView, { style: styles.list, contentContainerStyle: styles.listContent, accessibilityLabel: "Gait analysis result", children: [
+    result.detections.map((detection, index) => /* @__PURE__ */ jsx(View, { style: styles.resultRow, children: /* @__PURE__ */ jsx(Text, { style: styles.resultLabel, children: detection.label }) }, `${detection.label}-${index}`)),
+    result.interpretation ? /* @__PURE__ */ jsxs(View, { style: styles.interpretationBlock, children: [
+      /* @__PURE__ */ jsx(Text, { style: styles.summaryText, children: result.interpretation.summary }),
+      /* @__PURE__ */ jsx(Text, { style: styles.disclaimerText, children: result.interpretation.disclaimer })
+    ] }) : null
+  ] });
+}
+function useVideoStyles() {
+  const theme = useEverfurTheme();
+  return useMemo(() => ({ theme, styles: makeStyles3(theme) }), [theme]);
+}
+function makeStyles3(theme) {
+  const { color, space, radius, type } = theme;
+  const boldWeight = type.weight.bold;
+  const mediumWeight = type.weight.medium;
+  return StyleSheet.create({
+    // Themed ground so the surface is never a bare/transparent region and holds contrast in both schemes.
+    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
+    },
+    // Camera-unavailable placeholder: a cream disc ringed with the brand hairline (intentional, not a grey dot).
+    emptyGlyph: {
+      width: GLYPH_SIZE,
+      height: GLYPH_SIZE,
+      borderRadius: radius.pill,
+      backgroundColor: color.surfaceCream,
+      borderWidth: StyleSheet.hairlineWidth,
+      borderColor: color.borderHairlineGreen
+    },
+    // Capture / retry CTA: brand-green pill on a soft brand shadow (alpha baked into the token color).
+    primaryButton: {
+      minHeight: TOUCH_TARGET,
+      minWidth: TOUCH_TARGET,
+      alignItems: "center",
+      justifyContent: "center",
+      paddingHorizontal: space.xl,
+      paddingVertical: space.md,
+      borderRadius: radius.pill,
+      backgroundColor: color.primary,
+      shadowColor: color.brandSofter,
+      shadowOffset: { width: 0, height: space.xs },
+      shadowOpacity: 1,
+      shadowRadius: space.sm,
+      elevation: space.xs
+    },
+    primaryLabel: {
+      color: color.onPrimary,
+      fontFamily: type.family,
+      fontSize: type.size.body,
+      fontWeight: boldWeight,
+      letterSpacing: type.letterSpacing.tight
+    },
+    errorText: {
+      color: color.danger,
+      fontFamily: type.family,
+      fontSize: type.size.subtitle,
+      lineHeight: type.size.subtitle * type.lineHeight.normal,
+      fontWeight: mediumWeight,
+      textAlign: "center",
+      marginBottom: space.md
+    },
+    uncertainText: {
+      color: color.text.muted,
+      fontFamily: type.family,
+      fontSize: type.size.subtitle,
+      lineHeight: type.size.subtitle * type.lineHeight.normal,
+      textAlign: "center"
+    },
+    // Progress groove (skeleton wash) with a brand-green fill -- replaces the grey-track / blue-fill default.
+    progressTrack: {
+      marginTop: space.lg,
+      height: space.sm,
+      width: PROGRESS_TRACK_WIDTH,
+      borderRadius: radius.pill,
+      backgroundColor: color.skeleton,
+      overflow: "hidden"
+    },
+    progressFill: { height: space.sm, borderRadius: radius.pill, backgroundColor: color.brand },
+    list: { flex: 1 },
+    listContent: { padding: space.lg, gap: space.md },
+    // Detection rows: cream cards lifted off the ground by a hairline brand border (depth via layering).
+    resultRow: {
+      paddingVertical: space.sm,
+      paddingHorizontal: space.md,
+      borderRadius: radius.sm,
+      backgroundColor: color.surfaceCream,
+      borderWidth: StyleSheet.hairlineWidth,
+      borderColor: color.brandBorder
+    },
+    resultLabel: {
+      color: color.text.primary,
+      fontFamily: type.family,
+      fontSize: type.size.body,
+      lineHeight: type.size.body * type.lineHeight.normal,
+      fontWeight: mediumWeight
+    },
+    interpretationBlock: { marginTop: space.sm, gap: space.sm },
+    summaryText: {
+      color: color.text.primary,
+      fontFamily: type.family,
+      fontSize: type.size.subtitle,
+      lineHeight: type.size.subtitle * type.lineHeight.normal
+    },
+    disclaimerText: {
+      color: color.text.muted,
+      fontFamily: type.family,
+      fontSize: type.size.caption,
+      lineHeight: type.size.caption * type.lineHeight.relaxed
+    }
+  });
+}
+
+export { EverfurVideo, useEverfurVideo };