@everfur/sdk 0.1.0

package/dist/animations/index.js

@@ -0,0 +1,1972 @@
+import { createContext, useState, useEffect, useCallback, useSyncExternalStore, useMemo, useRef, useContext } from 'react';
+import { AccessibilityInfo, View, Image, Text, ActivityIndicator, StyleSheet } from 'react-native';
+import 'react-native-safe-area-context';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { z } from 'zod';
+
+// src/rn/animations/PetStateView.tsx
+
+// 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/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
+});
+
+// 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/core/ports/TelemetryPort.ts
+var noopTelemetry = Object.freeze({
+  track() {
+  },
+  trackExpectedFailure() {
+  }
+});
+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/identity.ts
+function newSessionId() {
+  const bytes = new Uint8Array(16);
+  const cryptoObj = globalThis.crypto;
+  if (typeof cryptoObj?.getRandomValues === "function") {
+    cryptoObj.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [];
+  for (let i = 0; i < bytes.length; i += 1) hex.push(bytes[i].toString(16).padStart(2, "0"));
+  return hex.slice(0, 4).join("") + "-" + hex.slice(4, 6).join("") + "-" + hex.slice(6, 8).join("") + "-" + hex.slice(8, 10).join("") + "-" + hex.slice(10, 16).join("");
+}
+function authHeaders(auth) {
+  const headers = {};
+  if (auth.mode === "personalized") {
+    headers.authorization = `Bearer ${auth.token}`;
+  } else {
+    headers["x-everfur-partner-key"] = auth.publishableKey;
+  }
+  if (auth.userRef) headers["x-everfur-user-ref"] = auth.userRef;
+  if (auth.sessionId) headers["x-everfur-session-id"] = auth.sessionId;
+  return headers;
+}
+function withAuthHeaders(req, auth) {
+  return { ...req, headers: { ...stripAuthHeaders(req.headers), ...authHeaders(auth) } };
+}
+function stripAuthHeaders(headers) {
+  if (!headers) return {};
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const lower = key.toLowerCase();
+    if (lower === "authorization" || lower === "x-everfur-partner-key") continue;
+    out[key] = value;
+  }
+  return out;
+}
+async function authedSend(req, ctx) {
+  if (ctx.mode === "anonymous") {
+    return ctx.transport.request(
+      withAuthHeaders(req, {
+        mode: "anonymous",
+        publishableKey: ctx.publishableKey,
+        userRef: ctx.userRef,
+        ...ctx.sessionId ? { sessionId: ctx.sessionId } : {}
+      })
+    );
+  }
+  let token;
+  try {
+    token = await ctx.identity.currentToken();
+  } catch {
+    return err(authRejectedError());
+  }
+  const first = await ctx.transport.request(
+    withAuthHeaders(req, {
+      mode: "personalized",
+      token,
+      userRef: ctx.userRef,
+      ...ctx.sessionId ? { sessionId: ctx.sessionId } : {}
+    })
+  );
+  if (first.ok || first.error.httpStatus !== 401) return first;
+  let refreshed;
+  try {
+    refreshed = await ctx.identity.currentToken({ forceRefresh: true });
+  } catch {
+    return err(authRejectedError());
+  }
+  const retry = await ctx.transport.request(
+    withAuthHeaders(req, {
+      mode: "personalized",
+      token: refreshed,
+      userRef: ctx.userRef,
+      ...ctx.sessionId ? { sessionId: ctx.sessionId } : {}
+    })
+  );
+  if (!retry.ok && retry.error.httpStatus === 401) {
+    return err(authRejectedError(retry.error.httpStatus));
+  }
+  return retry;
+}
+function authRejectedError(httpStatus) {
+  return makeEverfurError("authRejected", {
+    retryable: false,
+    ...httpStatus !== void 0 ? { httpStatus } : {}
+  });
+}
+
+// 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/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/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/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;
+}
+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);
+}
+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
+    }
+  });
+}
+
+// src/client/animations/types.ts
+function mapTier(wire) {
+  const tier = {
+    url: wire.url,
+    kind: wire.kind,
+    expiresAt: wire.expires_at
+  };
+  if (typeof wire.loop_duration_ms === "number") tier.loopDurationMs = wire.loop_duration_ms;
+  if (typeof wire.cache_key === "string" && wire.cache_key.length > 0) tier.cacheKey = wire.cache_key;
+  return Object.freeze(tier);
+}
+function mapPetStateResponse(wire) {
+  const tiers = {};
+  if (wire.tiers.animation) tiers.animation = mapTier(wire.tiers.animation);
+  if (wire.tiers.image) tiers.image = mapTier(wire.tiers.image);
+  const overlays = {};
+  if (wire.overlays.weather_alert) overlays.weatherAlert = mapTier(wire.overlays.weather_alert);
+  const response = {
+    category: wire.category,
+    tiers: Object.freeze(tiers),
+    overlays: Object.freeze(overlays),
+    idle: "bundled",
+    ttlSeconds: wire.ttl_seconds,
+    degraded: wire.degraded
+  };
+  if (typeof wire.cache_epoch === "number") response.cacheEpoch = wire.cache_epoch;
+  return Object.freeze(response);
+}
+var mediaKindWireSchema = z.enum(["webp", "video"]);
+var categoryWireSchema = z.enum(["health", "attention", "moment", "activity", "mood", "idle"]);
+var petStateTierWireSchema = z.object({
+  url: z.string(),
+  kind: mediaKindWireSchema.default("webp"),
+  loop_duration_ms: z.number().nullish(),
+  expires_at: z.string(),
+  // SERVER-OWNED identity `{s3_key}@r{asset_revision}`; absent on an older backend (defaults to the
+  // presign-stripped path downstream). Never derived from `url`.
+  cache_key: z.string().nullish()
+});
+var petStateResponseWireSchema = z.object({
+  category: categoryWireSchema,
+  tiers: z.object({
+    animation: petStateTierWireSchema.optional(),
+    image: petStateTierWireSchema.optional()
+  }).default({}),
+  overlays: z.object({
+    weather_alert: petStateTierWireSchema.optional()
+  }).default({}),
+  idle: z.literal("bundled").default("bundled"),
+  ttl_seconds: z.number(),
+  // TRANSIENT server idle (derive timeout / shed / IAM drift), NOT a dark pet.
+  degraded: z.boolean().default(false),
+  // Monotonic fleet-wide purge counter; 0 / absent == never purged.
+  cache_epoch: z.number().default(0)
+});
+function parsePetStateWire(raw) {
+  const parsed = petStateResponseWireSchema.safeParse(raw);
+  return parsed.success ? parsed.data : null;
+}
+
+// src/client/animations/petStateRepository.ts
+function createPetStateRepository(auth) {
+  return createPetStateRepositoryOver(createRequestFunnel({ auth }));
+}
+function createPetStateRepositoryOver(funnel) {
+  return {
+    async getState(petRef, opts) {
+      if (hasLoneSurrogate(petRef)) {
+        return err(
+          makeEverfurError("validationFailed", {
+            retryable: false,
+            wireMessage: "pet_ref contains an unpaired surrogate and cannot be encoded"
+          })
+        );
+      }
+      const path = `/widget/v1/pets/${encodeURIComponent(petRef)}/state`;
+      const res = await funnel.send(
+        "animations.getState",
+        opts?.signal ? { method: "GET", path, signal: opts.signal } : { method: "GET", path }
+      );
+      if (res.ok) {
+        const wire = parsePetStateWire(res.value);
+        if (wire === null) {
+          return err(makeEverfurError("internalError", { retryable: true }));
+        }
+        return ok(mapPetStateResponse(wire));
+      }
+      if (res.error.httpStatus === 404) return ok(null);
+      return err(res.error);
+    }
+  };
+}
+
+// src/client/animations/tier.ts
+function stableMediaKey(source) {
+  if (source === void 0) return "bundled:none";
+  if (typeof source === "number") return `bundled:${source}`;
+  if ("kind" in source) return `bundled:${source.id}`;
+  const uri = source.uri;
+  const q = uri.indexOf("?");
+  return q === -1 ? uri : uri.slice(0, q);
+}
+function selectTier(i) {
+  if (i.hasPhoto && !i.photoFailed) return "photo";
+  if (i.canAnimate && !i.animationFailed) return "animation";
+  if (i.hasImage && !i.imageFailed) return "image";
+  return "idle";
+}
+function retireTier(current, failed) {
+  switch (current) {
+    case "photo":
+      return { failed: freezeFailed({ ...failed, photo: true }), reason: "network_error" };
+    case "animation":
+      return { failed: freezeFailed({ ...failed, animation: true }), reason: "network_error" };
+    case "image":
+      return { failed: freezeFailed({ ...failed, image: true }), reason: "network_error" };
+    case "idle":
+      return { failed: freezeFailed(failed), reason: "idle_asset_failed" };
+    default:
+      return { failed: freezeFailed(failed), reason: "network_error" };
+  }
+}
+var NO_FAILURES = Object.freeze({ photo: false, animation: false, image: false });
+function freezeFailed(f) {
+  return Object.freeze({ photo: f.photo, animation: f.animation, image: f.image });
+}
+function isLoaderSafeCategory(category) {
+  switch (category) {
+    case "activity":
+    case "mood":
+    case "moment":
+    case "idle":
+      return true;
+    case "health":
+    case "attention":
+      return false;
+    default:
+      return false;
+  }
+}
+
+// src/core/animations/cacheEpoch.ts
+var CACHE_EPOCH_STORAGE_KEY = "everfur.petState.cacheEpoch";
+function createCacheEpochGuard(deps) {
+  let lastActed = 0;
+  let loaded = false;
+  let inFlight = null;
+  const run = async (serverEpoch) => {
+    if (!loaded) {
+      lastActed = await readStoredEpoch(deps.kv);
+      loaded = true;
+    }
+    if (serverEpoch <= lastActed) return false;
+    try {
+      await deps.kv.setItem(CACHE_EPOCH_STORAGE_KEY, String(serverEpoch));
+    } catch {
+    }
+    lastActed = serverEpoch;
+    try {
+      await deps.cache.clearMemoryCache();
+    } catch {
+    }
+    try {
+      await deps.cache.clearDiskCache();
+    } catch {
+    }
+    return true;
+  };
+  return {
+    async sync(serverEpoch) {
+      if (typeof serverEpoch !== "number" || !Number.isFinite(serverEpoch) || serverEpoch <= 0) {
+        return false;
+      }
+      if (loaded && serverEpoch <= lastActed) return false;
+      if (inFlight) return inFlight;
+      inFlight = run(serverEpoch).finally(() => {
+        inFlight = null;
+      });
+      return inFlight;
+    }
+  };
+}
+async function readStoredEpoch(kv) {
+  let raw;
+  try {
+    raw = await kv.getItem(CACHE_EPOCH_STORAGE_KEY);
+  } catch {
+    return 0;
+  }
+  if (raw === null) return 0;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+var SUPPORTED_SCHEMA_VERSION = 1;
+var MANIFEST_LKG_STORAGE_KEY = "everfur.manifest.lastKnownGood";
+var COMPILED_DEFAULT_IDLE = Object.freeze({ kind: "bundled", id: "everfur-idle" });
+var COMPILED_DEFAULT_MANIFEST = Object.freeze({
+  schemaVersion: SUPPORTED_SCHEMA_VERSION,
+  revision: "compiled-default",
+  surfaces: Object.freeze({
+    animations: Object.freeze({ enabled: true, idle: COMPILED_DEFAULT_IDLE })
+  })
+});
+var bundledIdleSchema = z.object({ kind: z.literal("bundled"), id: z.string().min(1) });
+var animationsSurfaceWireSchema = z.object({
+  enabled: z.boolean().default(true),
+  idle: bundledIdleSchema.optional()
+});
+var manifestWireSchema = z.object({
+  schema_version: z.number().int(),
+  revision: z.string().default(""),
+  surfaces: z.object({ animations: animationsSurfaceWireSchema.optional() }).default({})
+});
+function parseManifest(raw) {
+  const parsed = manifestWireSchema.safeParse(raw);
+  if (!parsed.success) return { ok: false, reason: "unparseable" };
+  if (parsed.data.schema_version > SUPPORTED_SCHEMA_VERSION) {
+    return { ok: false, reason: "newer_schema" };
+  }
+  const animationsWire = parsed.data.surfaces.animations;
+  const surfaces = {};
+  if (animationsWire) {
+    surfaces.animations = Object.freeze({
+      enabled: animationsWire.enabled,
+      idle: animationsWire.idle ? Object.freeze({ ...animationsWire.idle }) : COMPILED_DEFAULT_IDLE
+    });
+  }
+  return {
+    ok: true,
+    manifest: Object.freeze({
+      schemaVersion: parsed.data.schema_version,
+      revision: parsed.data.revision,
+      surfaces: Object.freeze(surfaces)
+    })
+  };
+}
+async function resolveManifest(liveRaw, kv, tel) {
+  if (liveRaw !== null && liveRaw !== void 0) {
+    const parsed = parseManifest(liveRaw);
+    if (parsed.ok) {
+      await writeLastKnownGood(kv, liveRaw);
+      tel.track("manifest.fallback", { source: "live" });
+      return Object.freeze({ manifest: parsed.manifest, source: "live" });
+    }
+    if (parsed.reason === "newer_schema") tel.track("manifest.refused_newer", {});
+  }
+  const lkg = await readLastKnownGood(kv);
+  if (lkg) {
+    tel.track("manifest.fallback", { source: "last-known-good" });
+    return Object.freeze({ manifest: lkg, source: "last-known-good" });
+  }
+  tel.track("manifest.fallback", { source: "compiled-default" });
+  return Object.freeze({ manifest: COMPILED_DEFAULT_MANIFEST, source: "compiled-default" });
+}
+function animationsSurfaceOf(manifest) {
+  return manifest.surfaces.animations ?? COMPILED_DEFAULT_MANIFEST.surfaces.animations ?? {
+    enabled: true,
+    idle: COMPILED_DEFAULT_IDLE
+  };
+}
+async function writeLastKnownGood(kv, raw) {
+  try {
+    await kv.setItem(MANIFEST_LKG_STORAGE_KEY, JSON.stringify(raw));
+  } catch {
+  }
+}
+async function readLastKnownGood(kv) {
+  let stored;
+  try {
+    stored = await kv.getItem(MANIFEST_LKG_STORAGE_KEY);
+  } catch {
+    return null;
+  }
+  if (stored === null) return null;
+  let json;
+  try {
+    json = JSON.parse(stored);
+  } catch {
+    return null;
+  }
+  const parsed = parseManifest(json);
+  return parsed.ok ? parsed.manifest : null;
+}
+
+// src/core/animations/petStateStore.ts
+var DEFAULT_STALE_MS = 6e4;
+var MAX_TRANSIENT_RETRIES = 2;
+var MAX_WARM_ENTRIES = 32;
+var EMPTY_SNAPSHOT = Object.freeze({
+  data: null,
+  isPending: false,
+  isError: false,
+  error: null,
+  isDark: false
+});
+function createPetStateStore(deps) {
+  const { repo, cacheEpoch, timers } = deps;
+  const listeners = /* @__PURE__ */ new Set();
+  const warm = /* @__PURE__ */ new Map();
+  let snapshot = EMPTY_SNAPSHOT;
+  let currentPetRef = null;
+  let dataPetRef = null;
+  let isFocused = false;
+  let terminatedPetRef = null;
+  let remintHandle = null;
+  let inFlight = null;
+  let epoch = 0;
+  const emit = () => {
+    for (const listener of listeners) listener();
+  };
+  const patch = (partial) => {
+    snapshot = Object.freeze({ ...snapshot, ...partial });
+    emit();
+  };
+  const clearRemint = () => {
+    if (remintHandle !== null) {
+      timers.clearTimeout(remintHandle);
+      remintHandle = null;
+    }
+  };
+  const staleMs = (data) => data ? Math.max(1, data.ttlSeconds) * 1e3 : DEFAULT_STALE_MS;
+  const touchWarm = (petRef) => {
+    const entry = warm.get(petRef);
+    if (entry === void 0) return;
+    warm.delete(petRef);
+    warm.set(petRef, entry);
+  };
+  const setWarm = (petRef, data) => {
+    warm.delete(petRef);
+    warm.set(petRef, Object.freeze({ data, fetchedAt: timers.now() }));
+    while (warm.size > MAX_WARM_ENTRIES) {
+      const oldest = warm.keys().next().value;
+      if (oldest === void 0 || oldest === petRef) break;
+      warm.delete(oldest);
+    }
+  };
+  const hasGoodTiers = (petRef) => {
+    const entry = warm.get(petRef);
+    if (!entry) return false;
+    return Boolean(entry.data.tiers.animation || entry.data.tiers.image);
+  };
+  const scheduleRemint = (petRef, ttlSeconds) => {
+    clearRemint();
+    if (!isFocused) return;
+    const ms = Math.max(1, ttlSeconds) * 1e3;
+    const scheduledEpoch = epoch;
+    remintHandle = timers.setTimeout(() => {
+      remintHandle = null;
+      if (scheduledEpoch !== epoch || currentPetRef !== petRef || !isFocused) return;
+      void fetchOnce(petRef, 0);
+    }, ms);
+  };
+  const fetchOnce = async (petRef, attempt) => {
+    if (currentPetRef !== petRef || terminatedPetRef === petRef || !isFocused) return;
+    const myEpoch = epoch;
+    inFlight?.abort();
+    const ctrl = new AbortController();
+    inFlight = ctrl;
+    const res = await repo.getState(petRef, { signal: ctrl.signal });
+    if (myEpoch !== epoch || currentPetRef !== petRef) return;
+    if (res.ok) {
+      const resp = res.value;
+      if (resp === null) {
+        onTerminalDark(petRef);
+        return;
+      }
+      void cacheEpoch.sync(resp.cacheEpoch);
+      const respHasTiers = Boolean(resp.tiers.animation || resp.tiers.image);
+      if (resp.degraded && !respHasTiers && hasGoodTiers(petRef)) {
+        patch({ isError: false, error: null, isPending: false, isDark: false });
+        scheduleRemint(petRef, resp.ttlSeconds);
+        return;
+      }
+      setWarm(petRef, resp);
+      dataPetRef = petRef;
+      patch({ data: resp, isPending: false, isError: false, error: null, isDark: false });
+      scheduleRemint(petRef, resp.ttlSeconds);
+      return;
+    }
+    if (isTerminalPetStateError(res.error)) {
+      onTerminalDisabled(petRef, res.error);
+      return;
+    }
+    patch({ isError: true, error: res.error, isPending: snapshot.data === null && dataPetRef !== petRef });
+    if (attempt < MAX_TRANSIENT_RETRIES) {
+      clearRemint();
+      const backoff = 500 * (attempt + 1);
+      const scheduledEpoch = epoch;
+      remintHandle = timers.setTimeout(() => {
+        remintHandle = null;
+        if (scheduledEpoch !== epoch || currentPetRef !== petRef || !isFocused) return;
+        void fetchOnce(petRef, attempt + 1);
+      }, backoff);
+    } else {
+      scheduleRemint(petRef, 5);
+    }
+  };
+  const onTerminalDark = (petRef) => {
+    terminatedPetRef = petRef;
+    warm.delete(petRef);
+    clearRemint();
+    dataPetRef = petRef;
+    patch({ data: null, isPending: false, isError: false, error: null, isDark: true });
+  };
+  const onTerminalDisabled = (petRef, error) => {
+    terminatedPetRef = petRef;
+    warm.delete(petRef);
+    clearRemint();
+    dataPetRef = petRef;
+    patch({ data: null, isPending: false, isError: false, error, isDark: true });
+  };
+  return {
+    observe(petRef, opts) {
+      const focusChanged = opts.isFocused !== isFocused;
+      isFocused = opts.isFocused;
+      if (petRef !== currentPetRef) {
+        epoch += 1;
+        inFlight?.abort();
+        inFlight = null;
+        clearRemint();
+        terminatedPetRef = null;
+        currentPetRef = petRef;
+        if (petRef === null) {
+          dataPetRef = null;
+          snapshot = EMPTY_SNAPSHOT;
+          emit();
+          return;
+        }
+        const warmEntry = warm.get(petRef);
+        const fresh = warmEntry && timers.now() - warmEntry.fetchedAt < staleMs(warmEntry.data) ? warmEntry : null;
+        if (fresh) {
+          touchWarm(petRef);
+          dataPetRef = petRef;
+          patch({ data: fresh.data, isPending: false, isError: false, error: null, isDark: false });
+        } else {
+          patch({ isPending: true, isError: false, error: null, isDark: false });
+        }
+        if (isFocused) void fetchOnce(petRef, 0);
+        return;
+      }
+      if (!focusChanged || petRef === null) return;
+      if (!isFocused) {
+        clearRemint();
+        return;
+      }
+      const entry = warm.get(petRef);
+      if (!entry || timers.now() - entry.fetchedAt >= staleMs(entry.data)) {
+        if (terminatedPetRef !== petRef) void fetchOnce(petRef, 0);
+      } else {
+        scheduleRemint(petRef, entry.data.ttlSeconds);
+      }
+    },
+    getSnapshot() {
+      return snapshot;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getCachedPetStateMedia(petRef) {
+      const entry = warm.get(petRef);
+      if (!entry) return null;
+      if (timers.now() - entry.fetchedAt >= staleMs(entry.data)) return null;
+      touchWarm(petRef);
+      return entry.data;
+    },
+    dispose() {
+      epoch += 1;
+      inFlight?.abort();
+      inFlight = null;
+      clearRemint();
+      listeners.clear();
+      warm.clear();
+    }
+  };
+}
+function isTerminalPetStateError(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const record = error;
+  const status = typeof record.status === "number" ? record.status : record.httpStatus;
+  return status === 403 || status === 404;
+}
+
+// src/core/animations/AnimationController.ts
+function createAnimationController(deps) {
+  const telemetry = deps.telemetry ?? noopTelemetry;
+  const timers = deps.timers ?? defaultTimers(deps.now);
+  const store = createPetStateStore({
+    repo: deps.repo,
+    cacheEpoch: createCacheEpochGuard({ kv: deps.kv, cache: deps.cache }),
+    timers
+  });
+  const listeners = /* @__PURE__ */ new Set();
+  let failed = NO_FAILURES;
+  let fallbackReason = "none";
+  let paused = false;
+  let photoUrl = null;
+  let lastData = null;
+  let lastDark = false;
+  let lastShownKey = "";
+  let view = pendingView(surface());
+  let disposed = false;
+  function surface() {
+    const manifest = deps.manifest ? deps.manifest() : COMPILED_DEFAULT_MANIFEST;
+    return animationsSurfaceOf(manifest);
+  }
+  const emit = () => {
+    for (const listener of listeners) listener();
+  };
+  const unsubscribeStore = store.subscribe(() => {
+    onStoreChange();
+  });
+  function onStoreChange() {
+    const snap = store.getSnapshot();
+    if (snap.data !== lastData || snap.isDark !== lastDark) {
+      lastData = snap.data;
+      lastDark = snap.isDark;
+      failed = NO_FAILURES;
+      fallbackReason = snap.isDark ? "dark_or_missing" : "none";
+    }
+    recompute(snap);
+  }
+  function recompute(snap = store.getSnapshot()) {
+    const surf = surface();
+    const next = buildView(surf, snap, {
+      failed,
+      fallbackReason,
+      paused,
+      photoUrl,
+      reducedMotion: deps.reducedMotion()});
+    view = next;
+    maybeEmitShown(next);
+    emit();
+  }
+  function maybeEmitShown(next) {
+    if (next.kind !== "ready") return;
+    const key = `${next.category}|${next.tier}|${next.fallbackReason}|${next.reducedMotion ? 1 : 0}`;
+    if (key === lastShownKey) return;
+    lastShownKey = key;
+    telemetry.track("pet_state_shown", {
+      category: next.category,
+      // coarse only; privacy-safe (§5.5)
+      tier: next.tier,
+      fallback_reason: next.fallbackReason,
+      reduced_motion: next.reducedMotion
+    });
+    if (next.fallbackReason === "idle_asset_failed") {
+      telemetry.trackExpectedFailure("idle_asset_failed", { category: next.category });
+    }
+  }
+  return {
+    observe(petRef, opts) {
+      if (disposed) return;
+      photoUrl = opts.photoUrl ?? null;
+      failed = NO_FAILURES;
+      store.observe(petRef, { isFocused: opts.isFocused });
+      onStoreChange();
+    },
+    getState() {
+      return view;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    onMediaError() {
+      if (disposed || view.kind !== "ready") return;
+      const retired = retireTier(view.tier, failed);
+      failed = retired.failed;
+      fallbackReason = retired.reason;
+      recompute();
+    },
+    setPaused(next) {
+      if (disposed || paused === next) return;
+      paused = next;
+      recompute();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      unsubscribeStore();
+      store.dispose();
+      listeners.clear();
+    }
+  };
+}
+function buildView(surf, snap, inputs) {
+  const idleSource = surf.idle;
+  if (!surf.enabled) {
+    return Object.freeze({
+      kind: "disabled",
+      reason: userFacingError("accessDenied"),
+      level: "partner_config",
+      source: idleSource,
+      idle: surf.idle
+    });
+  }
+  if (snap.isPending && snap.data === null && !snap.isDark) {
+    return Object.freeze({ kind: "pending", showSkeleton: true, source: idleSource });
+  }
+  const data = snap.data;
+  const category = data?.category ?? "idle";
+  const animation = data?.tiers.animation;
+  const image = data?.tiers.image;
+  const canAnimate = Boolean(animation) && animation?.kind === "webp" && !inputs.reducedMotion && !inputs.failed.animation;
+  const tier = selectTier({
+    hasPhoto: inputs.photoUrl !== null && inputs.photoUrl.length > 0,
+    photoFailed: inputs.failed.photo,
+    canAnimate,
+    animationFailed: inputs.failed.animation,
+    hasImage: Boolean(image),
+    imageFailed: inputs.failed.image
+  });
+  let source = idleSource;
+  let loopDurationMs = null;
+  let cacheHit = false;
+  if (tier === "photo" && inputs.photoUrl) {
+    source = uriSource(inputs.photoUrl, void 0);
+  } else if (tier === "animation" && animation) {
+    source = uriSource(animation.url, animation.cacheKey);
+    loopDurationMs = animation.loopDurationMs ?? null;
+    cacheHit = animation.cacheKey !== void 0;
+  } else if (tier === "image" && image) {
+    source = uriSource(image.url, image.cacheKey);
+    cacheHit = image.cacheKey !== void 0;
+  }
+  const recyclingKey = source.kind === "uri" ? source.cacheKey : `bundled:${source.id}`;
+  return Object.freeze({
+    kind: "ready",
+    tier,
+    source,
+    recyclingKey,
+    category,
+    loopDurationMs,
+    paused: inputs.paused,
+    reducedMotion: inputs.reducedMotion,
+    cacheHit,
+    fallbackReason: inputs.fallbackReason,
+    isDark: snap.isDark,
+    isTransientError: snap.isError
+  });
+}
+function uriSource(uri, serverCacheKey) {
+  return Object.freeze({
+    kind: "uri",
+    uri,
+    cacheKey: serverCacheKey ?? stableMediaKey({ uri })
+  });
+}
+function pendingView(surf) {
+  return Object.freeze({ kind: "pending", showSkeleton: true, source: surf.idle });
+}
+function defaultTimers(now) {
+  return {
+    setTimeout: (handler, ms) => setTimeout(handler, ms),
+    clearTimeout: (handle) => clearTimeout(handle),
+    now
+  };
+}
+
+// src/rn/animations/useAnimations.ts
+var PENDING_FALLBACK = Object.freeze({
+  kind: "pending",
+  showSkeleton: true,
+  source: COMPILED_DEFAULT_IDLE
+});
+var NOOP_UNSUBSCRIBE = () => {
+};
+function useAnimations(params) {
+  const {
+    petRef,
+    repo,
+    cache,
+    kv,
+    isFocused = true,
+    photoUrl = null,
+    telemetry,
+    reducedMotion,
+    manifest,
+    timers,
+    now
+  } = params;
+  const { runtime, userRef } = useEverfurContext();
+  const capability = useCapability("animations");
+  const reducedMotionReader = useSystemReducedMotion(reducedMotion);
+  const hasOverride = repo !== void 0 && cache !== void 0 && kv !== void 0;
+  const seamKey = hasOverride ? "override" : `${userRef ?? ""}|${petRef ?? ""}`;
+  const [controller, setController] = useState(null);
+  useEffect(() => {
+    if (repo !== void 0 && cache !== void 0 && kv !== void 0) {
+      const deps = {
+        repo,
+        cache,
+        kv,
+        reducedMotion: reducedMotionReader,
+        now: now ?? defaultNow,
+        ...telemetry ? { telemetry } : {},
+        ...manifest ? { manifest } : {},
+        ...timers ? { timers } : {}
+      };
+      const built = createAnimationController(deps);
+      setController(built);
+      return () => {
+        setController((current) => current === built ? null : current);
+        built.dispose();
+      };
+    }
+    const { services } = runtime.registry;
+    const acquired = runtime.registry.acquire(
+      "animations",
+      `${userRef ?? ""}|${petRef ?? ""}`,
+      () => createAnimationController({
+        repo: createPetStateRepository(services.authFor(userRef)),
+        cache: services.imageCache,
+        kv: services.kv,
+        reducedMotion: reducedMotionReader,
+        now: now ?? defaultNow,
+        telemetry: services.telemetry,
+        ...manifest ? { manifest } : {},
+        ...timers ? { timers } : {}
+      }),
+      (controller2) => controller2.dispose()
+    );
+    setController(acquired);
+    return () => {
+      setController((current) => current === acquired ? null : current);
+      runtime.registry.release(acquired);
+    };
+  }, [seamKey, repo, cache, kv, runtime]);
+  useEffect(() => {
+    controller?.observe(petRef, { isFocused, photoUrl });
+  }, [controller, petRef, isFocused, photoUrl]);
+  const subscribe = useCallback(
+    (onChange) => controller ? controller.subscribe(onChange) : NOOP_UNSUBSCRIBE,
+    [controller]
+  );
+  const getState = useCallback(
+    () => controller ? controller.getState() : PENDING_FALLBACK,
+    [controller]
+  );
+  const state = useSyncExternalStore(subscribe, getState, getState);
+  const onMediaError = useCallback(() => {
+    controller?.onMediaError();
+  }, [controller]);
+  const setPaused = useCallback(
+    (paused) => {
+      controller?.setPaused(paused);
+    },
+    [controller]
+  );
+  return useMemo(
+    () => ({ capability, state, onMediaError, setPaused }),
+    [capability, state, onMediaError, setPaused]
+  );
+}
+function useSystemReducedMotion(provided) {
+  const enabledRef = useRef(true);
+  useEffect(() => {
+    if (provided) return;
+    let active = true;
+    const probe = AccessibilityInfo.isReduceMotionEnabled?.();
+    if (probe && typeof probe.then === "function") {
+      void probe.then((value) => {
+        if (active) enabledRef.current = value;
+      });
+    }
+    const subscription = AccessibilityInfo.addEventListener?.("reduceMotionChanged", (value) => {
+      enabledRef.current = value;
+    });
+    return () => {
+      active = false;
+      subscription?.remove?.();
+    };
+  }, [provided]);
+  return useMemo(() => provided ?? (() => enabledRef.current), [provided]);
+}
+function defaultNow() {
+  return Date.now();
+}
+var PET_STATE_CROSSFADE_MS = 200;
+var SPINNER_DELAY_MS = 300;
+var MIN_MEDIA_HEIGHT = 120;
+function PetStateView(props) {
+  const { style, accessibilityLabel } = props;
+  const a11y = { accessibilityLabel, decorative: isDecorative(props) };
+  return /* @__PURE__ */ jsx(
+    CapabilityGate,
+    {
+      capability: "animations",
+      style,
+      renderPending: () => /* @__PURE__ */ jsx(IdleRegion, { style, a11y, busy: true }),
+      renderDisabled: (decision) => /* @__PURE__ */ jsx(IdleRegion, { style, a11y, reason: decision.disabled?.reason ?? "" }),
+      children: /* @__PURE__ */ jsx(PetStateBody, { ...props })
+    }
+  );
+}
+function isDecorative(props) {
+  return props.decorative === true || props.accessibilityLabel === void 0;
+}
+function PetStateBody(props) {
+  const styles = useStyles();
+  const a11y = {
+    accessibilityLabel: props.accessibilityLabel,
+    decorative: isDecorative(props)
+  };
+  const state = useAnimations(buildParams(props));
+  return /* @__PURE__ */ jsx(View, { style: [styles.container, props.style], children: renderState(state.state, state.onMediaError, a11y) });
+}
+function renderState(view, onMediaError, a11y) {
+  switch (view.kind) {
+    case "pending":
+      return /* @__PURE__ */ jsx(MediaNode, { source: view.source, recyclingKey: "pending", reducedMotion: true, a11y, busy: true, onMediaError });
+    case "disabled":
+      return /* @__PURE__ */ jsx(IdleRegion, { a11y, reason: view.reason });
+    case "ready":
+      return /* @__PURE__ */ jsx(
+        MediaNode,
+        {
+          source: view.source,
+          recyclingKey: view.recyclingKey,
+          reducedMotion: view.reducedMotion,
+          a11y,
+          onMediaError
+        }
+      );
+    default:
+      return assertNever(view);
+  }
+}
+function MediaNode({
+  source,
+  recyclingKey,
+  reducedMotion,
+  a11y,
+  busy,
+  onMediaError
+}) {
+  const styles = useStyles();
+  if (source.kind === "uri") {
+    return /* @__PURE__ */ jsx(
+      Image,
+      {
+        source: { uri: source.uri },
+        onError: onMediaError,
+        fadeDuration: reducedMotion ? 0 : PET_STATE_CROSSFADE_MS,
+        style: styles.media,
+        ...a11yProps(a11y)
+      },
+      recyclingKey
+    );
+  }
+  return /* @__PURE__ */ jsx(IdleRegion, { a11y, busy });
+}
+function IdleRegion({
+  style,
+  a11y,
+  busy,
+  reason
+}) {
+  const styles = useStyles();
+  return /* @__PURE__ */ jsxs(View, { style: [styles.idlePlaceholder, style], ...a11yProps(a11y), children: [
+    busy ? /* @__PURE__ */ jsx(DelayedSpinner, {}) : null,
+    reason && reason.length > 0 ? /* @__PURE__ */ jsx(Text, { style: styles.reasonText, children: reason }) : null
+  ] });
+}
+function DelayedSpinner() {
+  const theme = useEverfurTheme();
+  const [visible, setVisible] = useState(false);
+  useEffect(() => {
+    const id = setTimeout(() => setVisible(true), SPINNER_DELAY_MS);
+    return () => clearTimeout(id);
+  }, []);
+  return visible ? /* @__PURE__ */ jsx(ActivityIndicator, { color: theme.color.brand }) : null;
+}
+function a11yProps(a11y) {
+  if (a11y.decorative) {
+    return { accessible: false, accessibilityElementsHidden: true, importantForAccessibility: "no-hide-descendants" };
+  }
+  const label = a11y.accessibilityLabel;
+  return label !== void 0 ? { accessible: true, accessibilityRole: "image", accessibilityLabel: label } : { accessible: true, accessibilityRole: "image" };
+}
+function buildParams(props) {
+  const params = { petRef: props.petRef, repo: props.repo, cache: props.cache, kv: props.kv };
+  if (props.isFocused !== void 0) params.isFocused = props.isFocused;
+  if (props.photoUrl !== void 0) params.photoUrl = props.photoUrl;
+  if (props.telemetry !== void 0) params.telemetry = props.telemetry;
+  if (props.reducedMotion !== void 0) params.reducedMotion = props.reducedMotion;
+  if (props.manifest !== void 0) params.manifest = props.manifest;
+  if (props.timers !== void 0) params.timers = props.timers;
+  if (props.now !== void 0) params.now = props.now;
+  return params;
+}
+function useStyles() {
+  const theme = useEverfurTheme();
+  return useMemo(() => makeStyles2(theme), [theme]);
+}
+function makeStyles2(theme) {
+  return StyleSheet.create({
+    // Cream ground + rounded frame so the media crossfade sits on a branded surface with clipped corners.
+    container: {
+      minHeight: MIN_MEDIA_HEIGHT,
+      width: "100%",
+      backgroundColor: theme.color.surfaceCream,
+      borderRadius: theme.radius.lg,
+      overflow: "hidden"
+    },
+    media: { minHeight: MIN_MEDIA_HEIGHT, width: "100%" },
+    // Idle placeholder: an Everfur cream card with a hairline cream ring for subtle depth (never grey-on-blue).
+    idlePlaceholder: {
+      minHeight: MIN_MEDIA_HEIGHT,
+      width: "100%",
+      alignItems: "center",
+      justifyContent: "center",
+      backgroundColor: theme.color.surfaceCream,
+      borderRadius: theme.radius.lg,
+      borderWidth: StyleSheet.hairlineWidth,
+      borderColor: theme.color.borderRingCream,
+      padding: theme.space.lg
+    },
+    // Safe disabled reason: the warm muted ramp, on-brand type scale, legible in both themes.
+    reasonText: {
+      marginTop: theme.space.sm,
+      fontFamily: theme.type.family,
+      fontSize: theme.type.size.bodyTight,
+      lineHeight: Math.round(theme.type.size.bodyTight * theme.type.lineHeight.normal),
+      fontWeight: theme.type.weight.medium,
+      color: theme.color.text.muted,
+      textAlign: "center"
+    }
+  });
+}
+
+export { CACHE_EPOCH_STORAGE_KEY, COMPILED_DEFAULT_IDLE, COMPILED_DEFAULT_MANIFEST, MANIFEST_LKG_STORAGE_KEY, NO_FAILURES, PetStateView, SUPPORTED_SCHEMA_VERSION, animationsSurfaceOf, createAnimationController, createCacheEpochGuard, createPetStateRepository, createPetStateStore, isLoaderSafeCategory, isTerminalPetStateError, mapPetStateResponse, newSessionId, parseManifest, parsePetStateWire, petStateResponseWireSchema, resolveManifest, retireTier, selectTier, stableMediaKey, useAnimations };