@everfur/sdk 0.1.0

package/dist/records/index.js

@@ -0,0 +1,2834 @@
+import { createContext, useState, useRef, useEffect, useCallback, useMemo, useReducer, useContext, useSyncExternalStore } from 'react';
+import { z } from 'zod';
+import 'react-native-safe-area-context';
+import { View, ActivityIndicator, Pressable, Text, AccessibilityInfo, ScrollView, StyleSheet } from 'react-native';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+// src/rn/records/useRecords.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);
+  }
+};
+function brandPetRef(raw) {
+  return raw;
+}
+function brandRequestId(raw) {
+  return raw;
+}
+function brandDocumentId(raw) {
+  return raw;
+}
+var KNOWN_STATUSES = /* @__PURE__ */ new Set([
+  "awaiting_upload",
+  "received",
+  "parsing",
+  "in_review",
+  "published",
+  "failed",
+  "revoked"
+]);
+var STATUS_ALIASES = Object.freeze({
+  records_received: "received",
+  // the server's spelling; `received` is never sent verbatim
+  parsing_failed: "failed",
+  // TERMINAL. Folding to `parsing` polled forever on a dead request.
+  clinic_declined: "failed"
+  // TERMINAL. The clinic refused; nothing further will arrive.
+});
+function normalizeStatus(raw) {
+  const aliased = Object.prototype.hasOwnProperty.call(STATUS_ALIASES, raw) ? STATUS_ALIASES[raw] : void 0;
+  if (aliased !== void 0) return aliased;
+  const value = raw;
+  return KNOWN_STATUSES.has(value) ? value : "parsing";
+}
+function normalizeOrigin(raw) {
+  return raw === "owner_reported" || raw === "clinic_document" ? raw : null;
+}
+var requestSchema = z.object({
+  request_id: z.string().min(1),
+  pet_ref: z.string().min(1),
+  status: z.string(),
+  status_label: z.string().optional(),
+  document_count: z.number().optional(),
+  held_item_count: z.number().optional(),
+  received_at: z.string().nullish(),
+  parsing_started_at: z.string().nullish(),
+  review_started_at: z.string().nullish(),
+  created_at: z.string().optional(),
+  updated_at: z.string().optional()
+}).passthrough();
+function mapRequestView(wire) {
+  const parsed = requestSchema.safeParse(wire);
+  if (!parsed.success) return null;
+  const w = parsed.data;
+  return Object.freeze({
+    id: brandRequestId(w.request_id),
+    petRef: brandPetRef(w.pet_ref),
+    status: normalizeStatus(w.status),
+    statusLabel: w.status_label ?? "",
+    documentCount: numberOr(w.document_count, 0),
+    heldItemCount: numberOr(w.held_item_count, 0),
+    receivedAt: w.received_at ?? null,
+    parsingStartedAt: w.parsing_started_at ?? null,
+    reviewStartedAt: w.review_started_at ?? null,
+    createdAt: w.created_at ?? "",
+    updatedAt: w.updated_at ?? ""
+  });
+}
+function mapRequestList(wire) {
+  const list = Array.isArray(wire) ? wire : [];
+  const out = [];
+  for (const entry of list) {
+    const view = mapRequestView(entry);
+    if (view !== null) out.push(view);
+  }
+  return Object.freeze(out);
+}
+var acceptedSchema = z.object({
+  source_doc_id: z.string().min(1),
+  request_id: z.string().min(1)
+});
+function mapUploadedDocument(wire) {
+  const parsed = acceptedSchema.safeParse(wire);
+  if (!parsed.success) return null;
+  return Object.freeze({
+    documentId: brandDocumentId(parsed.data.source_doc_id),
+    requestId: brandRequestId(parsed.data.request_id),
+    status: "received"
+  });
+}
+var identitySchema = z.object({ label: z.string(), value: z.string() });
+var entitySchema = z.object({
+  key: z.string(),
+  category: z.string().optional(),
+  label: z.string().optional(),
+  value: z.string().nullish(),
+  unit: z.string().nullish(),
+  observed_at: z.string().nullish(),
+  status: z.string().nullish(),
+  origin: z.string().nullish()
+});
+var seriesPointSchema = z.object({
+  at: z.string(),
+  value: z.number().nullish(),
+  display: z.string().nullish(),
+  origin: z.string().nullish()
+});
+var seriesSchema = z.object({
+  key: z.string(),
+  label: z.string().optional(),
+  points: z.array(seriesPointSchema).optional()
+});
+var forwardSchema = z.object({
+  title: z.string(),
+  detail: z.string().nullish(),
+  due_at: z.string().nullish()
+});
+var documentSchema = z.object({
+  doc_id: z.string(),
+  title: z.string().nullish(),
+  page_count: z.number().nullish(),
+  received_at: z.string().nullish()
+});
+var contentSchema = z.object({
+  identity: z.array(identitySchema).optional(),
+  entities: z.array(entitySchema).optional(),
+  entity_series: z.array(seriesSchema).optional(),
+  forward_looking: z.array(forwardSchema).optional(),
+  documents: z.array(documentSchema).optional()
+});
+function mapRecordView(petRef, wire) {
+  const w = isObject(wire) ? wire : {};
+  const schemaVersion = strOr(w["schema_version"], "epdf/1.0");
+  const disclaimer = strOr(w["disclaimer"], "");
+  const pet = brandPetRef(typeof w["pet_ref"] === "string" && w["pet_ref"].length > 0 ? w["pet_ref"] : petRef);
+  if (w["withheld"] === true) {
+    return withheldView(pet, schemaVersion, disclaimer);
+  }
+  const content = contentSchema.safeParse(w);
+  if (!content.success) {
+    return withheldView(pet, schemaVersion, disclaimer);
+  }
+  const c = content.data;
+  const identity = (c.identity ?? []).map(
+    (i) => Object.freeze({ label: i.label, value: i.value })
+  );
+  const entities = (c.entities ?? []).map(
+    (e) => Object.freeze({
+      key: e.key,
+      category: e.category ?? "",
+      label: e.label ?? e.key,
+      value: e.value ?? null,
+      unit: e.unit ?? null,
+      observedAt: e.observed_at ?? null,
+      status: e.status ?? null,
+      origin: normalizeOrigin(e.origin)
+    })
+  );
+  const entitySeries = (c.entity_series ?? []).map(
+    (s) => Object.freeze({
+      key: s.key,
+      label: s.label ?? s.key,
+      points: Object.freeze(
+        (s.points ?? []).map(
+          (p) => Object.freeze({
+            at: p.at,
+            value: p.value ?? null,
+            display: p.display ?? null,
+            origin: normalizeOrigin(p.origin)
+          })
+        )
+      )
+    })
+  );
+  const forwardLooking = (c.forward_looking ?? []).map(
+    (f) => Object.freeze({ title: f.title, detail: f.detail ?? null, dueAt: f.due_at ?? null })
+  );
+  const documents = {};
+  for (const d of c.documents ?? []) {
+    documents[d.doc_id] = Object.freeze({
+      docId: d.doc_id,
+      title: d.title ?? null,
+      pageCount: d.page_count ?? null,
+      receivedAt: d.received_at ?? null
+    });
+  }
+  const isEmpty = w["is_empty"] === true || identity.length === 0 && entities.length === 0 && entitySeries.length === 0 && forwardLooking.length === 0 && Object.keys(documents).length === 0;
+  return Object.freeze({
+    petRef: pet,
+    schemaVersion,
+    isEmpty,
+    withheld: false,
+    generatedAt: strOrNull(w["generated_at"]),
+    identity: Object.freeze(identity),
+    entities: Object.freeze(entities),
+    entitySeries: Object.freeze(entitySeries),
+    forwardLooking: Object.freeze(forwardLooking),
+    documents: Object.freeze(documents),
+    disclaimer
+  });
+}
+function withheldView(petRef, schemaVersion, disclaimer) {
+  return Object.freeze({
+    petRef,
+    schemaVersion,
+    isEmpty: false,
+    withheld: true,
+    generatedAt: null,
+    identity: Object.freeze([]),
+    entities: Object.freeze([]),
+    entitySeries: Object.freeze([]),
+    forwardLooking: Object.freeze([]),
+    documents: Object.freeze({}),
+    disclaimer
+  });
+}
+var consentSchema = z.object({
+  pet_ref: z.string().optional(),
+  granted: z.boolean().optional(),
+  version: z.string().nullish(),
+  granted_at: z.string().nullish()
+});
+function mapConsent(petRef, wire) {
+  const parsed = consentSchema.safeParse(wire);
+  const data = parsed.success ? parsed.data : {};
+  return Object.freeze({
+    petRef: brandPetRef(typeof data.pet_ref === "string" && data.pet_ref.length > 0 ? data.pet_ref : petRef),
+    granted: data.granted === true,
+    version: data.version ?? null,
+    grantedAt: data.granted_at ?? null
+  });
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function numberOr(v, fallback) {
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function strOr(v, fallback) {
+  return typeof v === "string" && v.length > 0 ? v : fallback;
+}
+function strOrNull(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+
+// src/core/records/models.ts
+var RECORDS_TERMINAL = Object.freeze([
+  "published",
+  "failed",
+  "revoked"
+]);
+function isTerminalStatus(status) {
+  return RECORDS_TERMINAL.includes(status);
+}
+function recordsDenialReasonOf(error) {
+  if (error === null) return null;
+  const reason = error.recordsReason;
+  return reason === "consent_required" || reason === "session_required" || reason === "entitlement" ? reason : null;
+}
+
+// src/core/records/ports.ts
+var noopRecordsTelemetry = Object.freeze({
+  record() {
+  }
+});
+var MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
+var CONSENT_VERSION_MAX = 64;
+var IDEMPOTENCY_KEY_MAX = 128;
+var PET_REF_MAX = 128;
+var RECORDS_UPLOAD_CONTENT_TYPE = "application/pdf";
+var UPLOAD_DEADLINE_MS = 9e4;
+
+// src/core/records/RecordsController.ts
+function createRecordsController(deps) {
+  return new RecordsControllerImpl(deps);
+}
+var RecordsControllerImpl = class {
+  constructor(deps) {
+    /** In-memory record cache (per pet). NEVER persisted to disk. Cleared on revoke. */
+    this.recordCache = /* @__PURE__ */ new Map();
+    /** Parse-gap dedup: a request's gap metric fires at most once per id. */
+    this.reportedGaps = /* @__PURE__ */ new Set();
+    this.repository = deps.repository;
+    this.uploads = deps.uploads;
+    this.telemetry = deps.telemetry ?? noopRecordsTelemetry;
+    this.newIdempotencyKey = deps.newIdempotencyKey ?? defaultIdempotencyFactory();
+    this.timers = deps.timers ?? defaultTimers;
+    this.uploadDeadlineMs = deps.uploadDeadlineMs ?? UPLOAD_DEADLINE_MS;
+  }
+  // ---- request lifecycle ------------------------------------------------
+  async createUploadRequest(input) {
+    const res = await this.repository.createRequest({
+      pet_ref: input.petRef,
+      idempotency_key: input.idempotencyKey
+    });
+    if (!res.ok) return this.onRequestError(res.error);
+    const view = mapRequestView(res.value);
+    if (view === null) return err(internal());
+    this.observeRequest(view);
+    return ok(view);
+  }
+  async getRequest(id) {
+    const res = await this.repository.getRequest(id);
+    if (!res.ok) return this.onRequestError(res.error);
+    const view = mapRequestView(res.value);
+    if (view === null) return err(internal());
+    this.observeRequest(view);
+    return ok(view);
+  }
+  async listRequests() {
+    const res = await this.repository.listRequests();
+    if (!res.ok) return this.onRequestError(res.error);
+    const views = mapRequestList(res.value);
+    for (const view of views) this.observeRequest(view);
+    return ok(views);
+  }
+  // ---- two-phase upload (§3.2) ------------------------------------------
+  async uploadDocument(input) {
+    const { requestId, file } = input;
+    const rejection = validateFile(file);
+    if (rejection !== null) {
+      this.telemetry.record("records.upload.rejected", { reason: rejection });
+      return err(uploadFailed(`upload rejected: ${rejection}`));
+    }
+    const initiated = await this.repository.initiateUpload(requestId, {
+      content_type: RECORDS_UPLOAD_CONTENT_TYPE,
+      file_size: file.sizeBytes
+    });
+    if (!initiated.ok) {
+      return this.onRequestError(initiated.error);
+    }
+    const s3 = await this.postToS3(initiated.value, file, input);
+    if (!s3.ok) {
+      this.telemetry.record("records.upload.failed", { reason: s3.reason });
+      return err(uploadFailed(s3.reason));
+    }
+    const completed = await this.repository.completeUpload(requestId, {
+      upload_id: initiated.value.upload_id
+    });
+    if (!completed.ok) {
+      if (completed.error.code === "mediaUploadFailed") {
+        this.telemetry.record("records.upload.rejected", {
+          reason: reasonFromWire(completed.error) ?? "corrupt"
+        });
+      }
+      return this.onRequestError(completed.error);
+    }
+    const doc = mapUploadedDocument(completed.value);
+    if (doc === null) return err(internal());
+    return ok(doc);
+  }
+  async postToS3(policy, file, input) {
+    const deadline = new AbortController();
+    const signal = mergeSignals(deadline.signal, input.signal);
+    const handle = this.timers.setTimeout(() => deadline.abort(), this.uploadDeadlineMs);
+    try {
+      const opts = { signal };
+      if (input.onProgress) opts.onProgress = input.onProgress;
+      await this.uploads.postMultipart(policy, file, opts);
+      return { ok: true };
+    } catch {
+      const reason = deadline.signal.aborted && input.signal?.aborted !== true ? "timeout" : "upload_error";
+      return { ok: false, reason };
+    } finally {
+      this.timers.clearTimeout(handle);
+    }
+  }
+  // ---- record read (consent-gated, redaction-fail-closed) ---------------
+  async getRecord(pet) {
+    const res = await this.repository.getRecord(pet);
+    if (!res.ok) {
+      const reason = recordsDenialReasonOf(res.error);
+      if (reason === "consent_required") {
+        this.telemetry.record("records.consent.denied", { pet_ref: pet });
+      } else if (reason === "entitlement") {
+        this.telemetry.record("records.capability.denied", { pet_ref: pet });
+      }
+      return err(res.error);
+    }
+    const view = mapRecordView(pet, res.value);
+    if (view.withheld) {
+      this.telemetry.record("records.redaction.withheld", { pet_ref: pet });
+      this.recordCache.delete(pet);
+      return ok(view);
+    }
+    this.recordCache.set(pet, view);
+    return ok(view);
+  }
+  peekCachedRecord(pet) {
+    return this.recordCache.get(pet) ?? null;
+  }
+  // ---- consent ----------------------------------------------------------
+  async getConsent(pet) {
+    const res = await this.repository.getConsent(pet);
+    if (!res.ok) {
+      return err(res.error);
+    }
+    return ok(mapConsent(pet, res.value));
+  }
+  async grantConsent(input) {
+    const res = await this.repository.putConsent(
+      input.petRef,
+      { consent_version: input.consentVersion, idempotency_key: input.idempotencyKey }
+    );
+    if (!res.ok) {
+      const reason = recordsDenialReasonOf(res.error);
+      if (reason === "entitlement") this.telemetry.record("records.capability.denied", { pet_ref: input.petRef });
+      return err(res.error);
+    }
+    return ok(mapConsent(input.petRef, res.value));
+  }
+  async revokeConsent(pet) {
+    const res = await this.repository.deleteConsent(pet);
+    if (!res.ok) return err(res.error);
+    this.recordCache.delete(pet);
+    return ok(mapConsent(pet, res.value));
+  }
+  // ---- telemetry ---------------------------------------------------------
+  reportCapabilityDenied(pet) {
+    this.telemetry.record("records.capability.denied", pet ? { pet_ref: pet } : {});
+  }
+  // ---- internals ---------------------------------------------------------
+  /** Emit `records.parse.gap` at most once when a request first shows a manual-review gap (R6). */
+  observeRequest(view) {
+    if (view.reviewStartedAt !== null && !this.reportedGaps.has(view.id)) {
+      this.reportedGaps.add(view.id);
+      this.telemetry.record("records.parse.gap", { request_id: view.id });
+    }
+  }
+  /** Shared error path for the request lane: emit capability-denied on an entitlement 403, then surface. */
+  onRequestError(error) {
+    const reason = recordsDenialReasonOf(error);
+    if (reason === "entitlement") this.telemetry.record("records.capability.denied", {});
+    return err(error);
+  }
+};
+function validateFile(file) {
+  if (file.mimeType !== RECORDS_UPLOAD_CONTENT_TYPE) return "unsupported_format";
+  const size = file.sizeBytes;
+  if (typeof size !== "number" || !Number.isFinite(size) || size <= 0 || size > MAX_UPLOAD_BYTES) {
+    return "oversize";
+  }
+  return null;
+}
+function reasonFromWire(error) {
+  const raw = error.wireMessage;
+  if (raw === "unsupported_format" || raw === "oversize" || raw === "corrupt") return raw;
+  return null;
+}
+function uploadFailed(wireMessage) {
+  return makeEverfurError("mediaUploadFailed", { retryable: false, wireMessage });
+}
+function internal() {
+  return makeEverfurError("internalError", { retryable: true });
+}
+var defaultTimers = {
+  setTimeout: (handler, ms) => setTimeout(handler, ms),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+function mergeSignals(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;
+}
+function defaultIdempotencyFactory() {
+  let counter = 0;
+  return () => `records-${Date.now().toString(36)}-${(counter++).toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// 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 = mergeSignals2(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 mergeSignals2(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/core/records/repository.ts
+var BASE = "/widget/v1/records";
+function createHttpRecordsRepository(deps) {
+  const { auth } = deps;
+  const mode = auth.mode;
+  const funnel = deps.funnel ?? createRequestFunnel({ auth, ...deps.errorPolicy ? { errorPolicy: deps.errorPolicy } : {} });
+  const send = async (call, req, kind) => {
+    const res = await funnel.send(call, req);
+    if (res.ok) return res;
+    return err(tagReason(res.error, mode, kind));
+  };
+  const segmentError = (field, value) => {
+    if (typeof value !== "string" || value.length === 0) {
+      return makeEverfurError("validationFailed", {
+        retryable: false,
+        wireMessage: `${field} is required and must be a non-empty string`
+      });
+    }
+    if (hasLoneSurrogate(value)) {
+      return makeEverfurError("validationFailed", {
+        retryable: false,
+        wireMessage: `${field} contains an unpaired surrogate and cannot be encoded`
+      });
+    }
+    return null;
+  };
+  const boundsError = (field, value, max) => {
+    const unusable = segmentError(field, value);
+    if (unusable !== null) return unusable;
+    const value_ = value;
+    const length = [...value_].length;
+    if (length > max) {
+      return makeEverfurError("validationFailed", {
+        retryable: false,
+        wireMessage: `${field} is ${length} characters; the server accepts at most ${max}`
+      });
+    }
+    return null;
+  };
+  const firstError = (...checks) => checks.find((c) => c !== null) ?? null;
+  return {
+    createRequest: (body) => {
+      const invalid = firstError(
+        boundsError("idempotency_key", body.idempotency_key, IDEMPOTENCY_KEY_MAX),
+        boundsError("pet_ref", body.pet_ref, PET_REF_MAX)
+      );
+      if (invalid) return Promise.resolve(err(invalid));
+      return send("records.createRequest", post(`${BASE}/requests`, body), "request");
+    },
+    initiateUpload: (requestId, body) => {
+      const invalid = segmentError("request_id", requestId);
+      if (invalid) return Promise.resolve(err(invalid));
+      return send(
+        "records.initiateUpload",
+        post(`${BASE}/requests/${encodeURIComponent(requestId)}/uploads/initiate`, body),
+        "request"
+      );
+    },
+    completeUpload: (requestId, body) => {
+      const invalid = segmentError("request_id", requestId);
+      if (invalid) return Promise.resolve(err(invalid));
+      return send(
+        "records.completeUpload",
+        post(`${BASE}/requests/${encodeURIComponent(requestId)}/uploads/complete`, body),
+        "request"
+      );
+    },
+    getRequest: (requestId) => {
+      const invalid = segmentError("request_id", requestId);
+      if (invalid) return Promise.resolve(err(invalid));
+      return send(
+        "records.getRequest",
+        get(`${BASE}/requests/${encodeURIComponent(requestId)}`),
+        "request"
+      );
+    },
+    listRequests: async () => {
+      const res = await send(
+        "records.listRequests",
+        get(`${BASE}/requests`),
+        "request"
+      );
+      if (!res.ok) return res;
+      const value = res.value;
+      const items = Array.isArray(value) ? value : value.items ?? [];
+      return { ok: true, value: items };
+    },
+    getRecord: (petRef) => {
+      const invalid = boundsError("pet_ref", petRef, PET_REF_MAX);
+      if (invalid) return Promise.resolve(err(invalid));
+      return send(
+        "records.getRecord",
+        get(`${BASE}/pets/${encodeURIComponent(petRef)}/record`),
+        "content"
+      );
+    },
+    getConsent: (petRef) => {
+      const invalid = boundsError("pet_ref", petRef, PET_REF_MAX);
+      if (invalid) return Promise.resolve(err(invalid));
+      return send(
+        "records.getConsent",
+        get(`${BASE}/pets/${encodeURIComponent(petRef)}/consent`),
+        "consent"
+      );
+    },
+    putConsent: (petRef, body) => {
+      const invalid = firstError(
+        boundsError("consent_version", body.consent_version, CONSENT_VERSION_MAX),
+        boundsError("idempotency_key", body.idempotency_key, IDEMPOTENCY_KEY_MAX),
+        boundsError("pet_ref", petRef, PET_REF_MAX)
+      );
+      if (invalid) return Promise.resolve(err(invalid));
+      return send(
+        "records.putConsent",
+        put(`${BASE}/pets/${encodeURIComponent(petRef)}/consent`, body),
+        "consent"
+      );
+    },
+    deleteConsent: (petRef) => {
+      const invalid = boundsError("pet_ref", petRef, PET_REF_MAX);
+      if (invalid) return Promise.resolve(err(invalid));
+      return send(
+        "records.deleteConsent",
+        del(`${BASE}/pets/${encodeURIComponent(petRef)}/consent`),
+        "consent"
+      );
+    }
+  };
+}
+function withReason(error, reason) {
+  const tagged = { ...error, recordsReason: reason };
+  for (const key of ["wireMessage", "raw"]) {
+    const descriptor = Object.getOwnPropertyDescriptor(error, key);
+    if (descriptor !== void 0) Object.defineProperty(tagged, key, descriptor);
+  }
+  return Object.freeze(tagged);
+}
+function tagReason(error, mode, kind) {
+  if (error.httpStatus === 404) return withReason(error, "entitlement");
+  if (error.code !== "accessDenied") return error;
+  const reason = mode === "anonymous" ? "session_required" : kind === "content" ? "consent_required" : "entitlement";
+  return withReason(error, reason);
+}
+function get(path) {
+  return { method: "GET", path };
+}
+function post(path, body) {
+  return { method: "POST", path, body };
+}
+function put(path, body) {
+  return { method: "PUT", path, body };
+}
+function del(path) {
+  return { method: "DELETE", path };
+}
+
+// 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/records/useRecords.ts
+var INITIAL = {
+  record: null,
+  requests: [],
+  consent: null,
+  error: null,
+  denialReason: null,
+  withheld: false,
+  loading: true,
+  isUploading: false,
+  uploadProgress: null
+};
+var POLL_INTERVAL_MS = 4e3;
+var MAX_POLLS = 30;
+function useEverfurRecords(opts) {
+  const { petRef } = opts;
+  const { runtime, userRef } = useEverfurContext();
+  const [controller, setController] = useState(opts.controller ?? null);
+  const [snap, setSnap] = useState(INITIAL);
+  const generation = useRef(0);
+  useEffect(() => {
+    if (opts.controller) {
+      setController(opts.controller);
+      return;
+    }
+    const { services } = runtime.registry;
+    const telemetry = {
+      record: (event, props) => services.telemetry.track(event, props)
+    };
+    const acquired = runtime.registry.acquire(
+      "records",
+      `${userRef ?? ""}|${petRef}`,
+      () => createRecordsController({
+        repository: createHttpRecordsRepository({
+          auth: services.authFor(userRef),
+          ...services.errorPolicy ? { errorPolicy: services.errorPolicy } : {}
+        }),
+        uploads: services.uploadTransport,
+        telemetry
+      }),
+      // The records controller holds only an in-memory cache and has no dispose; dropping the ref clears it.
+      () => {
+      }
+    );
+    setController(acquired);
+    return () => {
+      runtime.registry.release(acquired);
+      setController((current) => current === acquired ? null : current);
+    };
+  }, [runtime, userRef, petRef, opts.controller]);
+  const patch = useCallback((partial) => {
+    setSnap((current) => ({ ...current, ...partial }));
+  }, []);
+  const load = useCallback(async () => {
+    if (!controller) return;
+    const gen = generation.current += 1;
+    pollsRef.current = 0;
+    rearmPolls();
+    patch({ loading: true, error: null, denialReason: null, withheld: false });
+    const [consentRes, listRes] = await Promise.all([
+      controller.getConsent(petRef),
+      controller.listRequests()
+    ]);
+    if (gen !== generation.current) return;
+    const consent = consentRes.ok ? consentRes.value : null;
+    const requests = listRes.ok ? listRes.value : [];
+    const listError = listRes.ok ? null : listRes.error;
+    if (consent && consent.granted) {
+      const recordRes = await controller.getRecord(petRef);
+      if (gen !== generation.current) return;
+      if (recordRes.ok) {
+        patch({
+          consent,
+          requests,
+          record: recordRes.value,
+          withheld: recordRes.value.withheld,
+          error: recordRes.value.withheld ? withheldSentinel() : listError,
+          denialReason: null,
+          loading: false
+        });
+        return;
+      }
+      patch({
+        consent,
+        requests,
+        record: null,
+        error: recordRes.error,
+        denialReason: recordsDenialReasonOf(recordRes.error),
+        withheld: false,
+        loading: false
+      });
+      return;
+    }
+    patch({
+      consent,
+      requests,
+      record: null,
+      // When the CONSENT read itself failed, its error is the one that explains the state; `listError` is
+      // incidental. This branch is now reachable with a real error because a 404 no longer folds into a
+      // fake `granted:false`.
+      error: consentRes.ok ? listError : consentRes.error,
+      denialReason: consent ? "consent_required" : consentDenial(consentRes),
+      withheld: false,
+      loading: false
+    });
+  }, [controller, petRef, patch]);
+  useEffect(() => {
+    void load();
+  }, [load]);
+  const activeRequest = useMemo(() => newestRequest(snap.requests), [snap.requests]);
+  const activeId = activeRequest?.id ?? null;
+  const activeStatus = activeRequest?.status ?? null;
+  const pollsRef = useRef(0);
+  const polledIdRef = useRef(null);
+  const [pollEpoch, rearmPolls] = useReducer((n) => n + 1, 0);
+  useEffect(() => {
+    if (!controller || activeId === null || activeStatus === null) return;
+    if (isTerminalStatus(activeStatus) || activeStatus === "in_review") return;
+    if (polledIdRef.current !== String(activeId)) {
+      polledIdRef.current = String(activeId);
+      pollsRef.current = 0;
+    }
+    let cancelled = false;
+    const tick = async () => {
+      if (cancelled || pollsRef.current >= MAX_POLLS) return;
+      pollsRef.current += 1;
+      const res = await controller.getRequest(activeId);
+      if (cancelled) return;
+      if (res.ok) {
+        setSnap((current) => ({ ...current, requests: replaceRequest(current.requests, res.value) }));
+        if (isTerminalStatus(res.value.status)) {
+          if (res.value.status === "published") void load();
+          return;
+        }
+        if (res.value.status === "in_review") return;
+      }
+      handle = setTimeout(() => void tick(), POLL_INTERVAL_MS);
+    };
+    let handle = setTimeout(() => void tick(), POLL_INTERVAL_MS);
+    return () => {
+      cancelled = true;
+      clearTimeout(handle);
+    };
+  }, [controller, activeId, activeStatus, load, pollEpoch]);
+  const createRequest = useCallback(
+    async (idempotencyKey) => {
+      if (!controller) return notReady();
+      const res = await controller.createUploadRequest({ petRef, idempotencyKey });
+      if (res.ok) setSnap((c) => ({ ...c, requests: replaceRequest(c.requests, res.value) }));
+      return res;
+    },
+    [controller, petRef]
+  );
+  const uploadDocument = useCallback(
+    async (requestId, file) => {
+      if (!controller) return notReady();
+      patch({ isUploading: true, uploadProgress: 0 });
+      const res = await controller.uploadDocument({
+        requestId,
+        file,
+        onProgress: (fraction) => patch({ uploadProgress: fraction })
+      });
+      patch({ isUploading: false, uploadProgress: null });
+      if (res.ok) {
+        const refreshed = await controller.getRequest(requestId);
+        if (refreshed.ok) setSnap((c) => ({ ...c, requests: replaceRequest(c.requests, refreshed.value) }));
+      }
+      return res;
+    },
+    [controller, patch]
+  );
+  const grantConsent = useCallback(
+    async (consentVersion, idempotencyKey) => {
+      if (!controller) return notReady();
+      const res = await controller.grantConsent({ petRef, consentVersion, idempotencyKey });
+      if (res.ok) void load();
+      return res;
+    },
+    [controller, petRef, load]
+  );
+  const revokeConsent = useCallback(async () => {
+    if (!controller) return notReady();
+    const res = await controller.revokeConsent(petRef);
+    if (res.ok) {
+      patch({ record: null, withheld: false, denialReason: "consent_required", consent: res.value });
+    }
+    return res;
+  }, [controller, petRef, patch]);
+  const refresh = useCallback(() => {
+    void load();
+  }, [load]);
+  const status = selectStatus(snap, controller !== null);
+  return useMemo(
+    () => ({
+      status,
+      record: snap.record,
+      requests: snap.requests,
+      activeRequest,
+      consent: snap.consent,
+      error: snap.error,
+      denialReason: snap.denialReason,
+      withheld: snap.withheld,
+      isUploading: snap.isUploading,
+      uploadProgress: snap.uploadProgress,
+      createRequest,
+      uploadDocument,
+      grantConsent,
+      revokeConsent,
+      refresh
+    }),
+    [status, snap, activeRequest, createRequest, uploadDocument, grantConsent, revokeConsent, refresh]
+  );
+}
+function selectStatus(snap, hasController) {
+  if (snap.loading || !hasController) return "loading";
+  if (snap.withheld || snap.denialReason !== null || snap.error !== null) return "error";
+  if (snap.record !== null && !snap.record.isEmpty) return "populated";
+  if (snap.requests.length > 0) return "populated";
+  return "empty";
+}
+function newestRequest(requests) {
+  if (requests.length === 0) return null;
+  let newest = requests[0];
+  for (const r of requests) if (r.updatedAt > newest.updatedAt) newest = r;
+  return newest;
+}
+function replaceRequest(requests, next) {
+  const filtered = requests.filter((r) => r.id !== next.id);
+  return [next, ...filtered];
+}
+function consentDenial(res) {
+  return res.ok ? "consent_required" : recordsDenialReasonOf(res.error) ?? "consent_required";
+}
+function withheldSentinel() {
+  return makeEverfurError("internalError", { retryable: false });
+}
+function notReady() {
+  return { ok: false, error: 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
+    }
+  });
+}
+
+// src/rn/records/format.ts
+function formatEntityValue(value, unit) {
+  if (value === null) return "";
+  return unit ? `${value} ${unit}` : value;
+}
+function formatShortDate(at) {
+  if (at === null || at.length === 0) return "";
+  const iso = /^(\d{4})-(\d{2})-(\d{2})/.exec(at);
+  if (iso !== null) {
+    const year = iso[1] ?? "";
+    const month = iso[2] ?? "";
+    const day = iso[3] ?? "";
+    return `${Number(month)}/${Number(day)}/${year.slice(2)}`;
+  }
+  const ms = Date.parse(at);
+  if (Number.isNaN(ms)) return at;
+  const date = new Date(ms);
+  return `${date.getUTCMonth() + 1}/${date.getUTCDate()}/${String(date.getUTCFullYear()).slice(2)}`;
+}
+var TINT_KEYS = ["brandSoft", "badgeBgPositive", "badgeBgCaution", "badgeBgNeutral"];
+function buildRows(entities, forwardLooking, documents) {
+  const rows = [];
+  const order = [];
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const entity of entities) {
+    const category = entity.category.trim();
+    if (category.length === 0) continue;
+    const bucket = byCategory.get(category);
+    if (bucket === void 0) {
+      order.push(category);
+      byCategory.set(category, [entity]);
+    } else {
+      bucket.push(entity);
+    }
+  }
+  for (const category of order) {
+    const group = byCategory.get(category) ?? [];
+    rows.push({
+      id: `cat:${category}`,
+      title: category,
+      count: group.length,
+      dateLabel: null,
+      entities: group,
+      detail: null
+    });
+  }
+  forwardLooking.forEach((item, index) => {
+    const title = item.title.trim();
+    if (title.length === 0) return;
+    const detail = item.detail !== null && item.detail.length > 0 ? item.detail : null;
+    rows.push({
+      id: `fwd:${index}`,
+      title,
+      count: null,
+      dateLabel: formatShortDate(item.dueAt),
+      entities: null,
+      detail
+    });
+  });
+  for (const doc of Object.values(documents)) {
+    const title = doc.title !== null ? doc.title.trim() : "";
+    if (title.length === 0) continue;
+    rows.push({
+      id: `doc:${doc.docId}`,
+      title,
+      count: null,
+      dateLabel: formatShortDate(doc.receivedAt),
+      entities: null,
+      detail: null
+    });
+  }
+  return rows;
+}
+function RecordNavCards({
+  entities,
+  forwardLooking,
+  documents,
+  testID
+}) {
+  const styles = useStyles();
+  const rows = useMemo(
+    () => buildRows(entities, forwardLooking, documents),
+    [entities, forwardLooking, documents]
+  );
+  const [expanded, setExpanded] = useState(() => /* @__PURE__ */ new Set());
+  if (rows.length === 0) return null;
+  const toggle = (id) => {
+    setExpanded((current) => {
+      const next = new Set(current);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  };
+  return /* @__PURE__ */ jsx(View, { style: styles.stack, testID, children: rows.map((row, index) => {
+    const tintKey = TINT_KEYS[index % TINT_KEYS.length] ?? "brandSoft";
+    const tint = styles.tints[tintKey];
+    const body = row.entities ?? (row.detail !== null ? row.detail : null);
+    const expandable = row.entities !== null || row.detail !== null;
+    const isOpen = expanded.has(row.id);
+    const trailing = row.count !== null ? `${row.count}` : row.dateLabel !== null ? row.dateLabel : null;
+    const a11y = [row.title, trailing].filter((s) => s !== null && s.length > 0).join(", ");
+    return /* @__PURE__ */ jsxs(View, { testID: testID ? `${testID}-row-${index}` : void 0, children: [
+      /* @__PURE__ */ jsx(
+        NavCard,
+        {
+          styles,
+          tint,
+          title: row.title,
+          trailing,
+          expandable,
+          isOpen,
+          a11y,
+          onPress: expandable ? () => toggle(row.id) : void 0
+        }
+      ),
+      expandable && isOpen ? /* @__PURE__ */ jsx(NavCardBody, { styles, body }) : null
+    ] }, row.id);
+  }) });
+}
+function NavCard({
+  styles,
+  tint,
+  title,
+  trailing,
+  expandable,
+  isOpen,
+  a11y,
+  onPress
+}) {
+  return /* @__PURE__ */ jsxs(
+    Pressable,
+    {
+      onPress,
+      disabled: onPress === void 0,
+      accessibilityRole: "button",
+      accessibilityLabel: a11y,
+      accessibilityState: { expanded: expandable ? isOpen : void 0, disabled: onPress === void 0 },
+      style: [styles.card, tint],
+      children: [
+        /* @__PURE__ */ jsx(View, { style: styles.iconChip }),
+        /* @__PURE__ */ jsx(Text, { style: styles.title, numberOfLines: 2, children: title }),
+        /* @__PURE__ */ jsxs(View, { style: styles.trailing, children: [
+          trailing !== null ? /* @__PURE__ */ jsx(View, { style: styles.pill, children: /* @__PURE__ */ jsx(Text, { style: styles.pillLabel, numberOfLines: 1, children: trailing }) }) : null,
+          expandable ? /* @__PURE__ */ jsx(View, { style: isOpen ? styles.chevronOpen : styles.chevron }) : null
+        ] })
+      ]
+    }
+  );
+}
+function NavCardBody({
+  styles,
+  body
+}) {
+  if (body === null) return null;
+  if (typeof body === "string") {
+    return /* @__PURE__ */ jsx(View, { style: styles.body, children: /* @__PURE__ */ jsx(Text, { style: styles.detailText, children: body }) });
+  }
+  return /* @__PURE__ */ jsx(View, { style: styles.body, children: body.map((entity) => /* @__PURE__ */ jsxs(View, { style: styles.factRow, children: [
+    /* @__PURE__ */ jsx(Text, { style: styles.factLabel, numberOfLines: 2, children: entity.label }),
+    /* @__PURE__ */ jsx(Text, { style: styles.factValue, numberOfLines: 2, children: formatEntityValue(entity.value, entity.unit) })
+  ] }, entity.key)) });
+}
+function useStyles() {
+  const theme = useEverfurTheme();
+  return useMemo(() => makeStyles3(theme), [theme]);
+}
+function makeStyles3(theme) {
+  const { color, space, radius, type } = theme;
+  const { size, lineHeight, weight, letterSpacing, family } = type;
+  const lh = (fontSize, multiplier) => Math.round(fontSize * multiplier);
+  const hairline = StyleSheet.hairlineWidth;
+  const boldWeight = weight.bold;
+  const mediumWeight = weight.medium;
+  const rowMinHeight = space.xxl + space.xl;
+  const chipSize = space.xl;
+  const chevronSize = space.sm;
+  const chevronStroke = space.xs / 2;
+  const softShadow = {
+    shadowColor: color.brand,
+    shadowOffset: { width: 0, height: space.xs },
+    shadowRadius: space.sm,
+    shadowOpacity: 0.06,
+    elevation: space.xs
+  };
+  const chevronBase = {
+    width: chevronSize,
+    height: chevronSize,
+    borderTopWidth: chevronStroke,
+    borderRightWidth: chevronStroke,
+    borderColor: color.brand
+  };
+  return {
+    tints: {
+      brandSoft: { backgroundColor: color.brandSoft },
+      badgeBgPositive: { backgroundColor: color.badgeBgPositive },
+      badgeBgCaution: { backgroundColor: color.badgeBgCaution },
+      badgeBgNeutral: { backgroundColor: color.badgeBgNeutral }
+    },
+    ...StyleSheet.create({
+      stack: { gap: space.sm },
+      card: {
+        flexDirection: "row",
+        alignItems: "center",
+        gap: space.md,
+        minHeight: rowMinHeight,
+        paddingHorizontal: space.lg,
+        paddingVertical: space.md,
+        borderRadius: radius.md,
+        borderWidth: hairline,
+        borderColor: color.brandBorder,
+        ...softShadow
+      },
+      iconChip: {
+        width: chipSize,
+        height: chipSize,
+        borderRadius: radius.sm,
+        backgroundColor: color.brand
+      },
+      title: {
+        flex: 1,
+        fontFamily: family,
+        fontSize: size.subtitle,
+        lineHeight: lh(size.subtitle, lineHeight.snug),
+        color: color.text.secondary,
+        fontWeight: boldWeight,
+        letterSpacing: letterSpacing.tight
+      },
+      trailing: {
+        flexDirection: "row",
+        alignItems: "center",
+        gap: space.sm
+      },
+      pill: {
+        minWidth: space.xl,
+        alignItems: "center",
+        justifyContent: "center",
+        paddingHorizontal: space.sm,
+        paddingVertical: space.xs,
+        borderRadius: radius.pill,
+        backgroundColor: color.surfaceCream,
+        borderWidth: hairline,
+        borderColor: color.brandBorder
+      },
+      pillLabel: {
+        fontFamily: family,
+        fontSize: size.caption,
+        lineHeight: lh(size.caption, lineHeight.tight),
+        color: color.text.secondary,
+        fontWeight: boldWeight
+      },
+      chevron: { ...chevronBase, transform: [{ rotate: "45deg" }] },
+      chevronOpen: { ...chevronBase, transform: [{ rotate: "135deg" }] },
+      body: {
+        gap: space.xs,
+        marginTop: space.xs,
+        paddingHorizontal: space.lg,
+        paddingVertical: space.md,
+        borderRadius: radius.sm,
+        backgroundColor: color.surfaceCream,
+        borderWidth: hairline,
+        borderColor: color.brandBorder
+      },
+      factRow: {
+        flexDirection: "row",
+        justifyContent: "space-between",
+        gap: space.md,
+        paddingVertical: space.xs,
+        borderBottomWidth: hairline,
+        borderBottomColor: color.borderHairlineGreen
+      },
+      factLabel: {
+        fontFamily: family,
+        fontSize: size.body,
+        lineHeight: lh(size.body, lineHeight.normal),
+        color: color.text.muted,
+        flexShrink: 1
+      },
+      factValue: {
+        fontFamily: family,
+        fontSize: size.body,
+        lineHeight: lh(size.body, lineHeight.normal),
+        color: color.text.primary,
+        fontWeight: mediumWeight,
+        textAlign: "right",
+        flexShrink: 1
+      },
+      detailText: {
+        fontFamily: family,
+        fontSize: size.body,
+        lineHeight: lh(size.body, lineHeight.normal),
+        color: color.text.secondary
+      }
+    })
+  };
+}
+function pct(value) {
+  return `${value}%`;
+}
+function isFinitePoint(point) {
+  return point.value !== null && Number.isFinite(point.value);
+}
+function pointDisplay(point) {
+  if (point.display !== null && point.display.length > 0) return point.display;
+  return point.value !== null ? String(point.value) : "";
+}
+function buildTrendModel(series) {
+  const primary = series.find((s) => s.points.some(isFinitePoint));
+  if (primary === void 0) return null;
+  const numeric = primary.points.filter(isFinitePoint);
+  const first = numeric[0];
+  if (first === void 0) return null;
+  const values = numeric.map((p) => p.value);
+  let lo = Math.min(...values);
+  let hi = Math.max(...values);
+  if (lo === hi) {
+    lo -= 1;
+    hi += 1;
+  }
+  const pad = (hi - lo) * 0.18;
+  const yMin = lo - pad;
+  const yMax = hi + pad;
+  const span = yMax - yMin;
+  const xInset = 6;
+  const count = numeric.length;
+  const points = numeric.map((p, index) => ({
+    xPct: count <= 1 ? 50 : xInset + index / (count - 1) * (100 - 2 * xInset),
+    // y in percent DOWN from the top: the max of the domain sits at 0%, the min at 100%.
+    yPct: (yMax - p.value) / span * 100
+  }));
+  const bandTopPct = (yMax - hi) / span * 100;
+  const bandBottomPct = (yMax - lo) / span * 100;
+  const minPoint = numeric.reduce((acc, p) => p.value < acc.value ? p : acc, first);
+  const maxPoint = numeric.reduce((acc, p) => p.value > acc.value ? p : acc, first);
+  const lastNumeric = numeric[numeric.length - 1] ?? first;
+  const latest = primary.points[primary.points.length - 1] ?? lastNumeric;
+  const latestDisplay = pointDisplay(latest);
+  const heroDisplay = latestDisplay.length > 0 ? latestDisplay : pointDisplay(lastNumeric);
+  return {
+    label: primary.label,
+    heroDisplay,
+    minDisplay: pointDisplay(minPoint),
+    maxDisplay: pointDisplay(maxPoint),
+    firstDate: formatShortDate(primary.points[0]?.at ?? null),
+    lastDate: formatShortDate(latest.at),
+    points,
+    bandTopPct,
+    bandBottomPct
+  };
+}
+function TrendRangeCard({ series, testID }) {
+  const styles = useStyles2();
+  const model = useMemo(() => buildTrendModel(series), [series]);
+  if (model === null) return null;
+  const summary = model.heroDisplay.length > 0 ? `${model.label}, ${model.heroDisplay}` : model.label;
+  const bandHeightPct = Math.max(0, model.bandBottomPct - model.bandTopPct);
+  return /* @__PURE__ */ jsxs(View, { style: styles.card, testID, children: [
+    /* @__PURE__ */ jsxs(View, { accessible: true, accessibilityRole: "text", accessibilityLabel: summary, children: [
+      /* @__PURE__ */ jsx(Text, { style: styles.eyebrow, numberOfLines: 1, children: model.label }),
+      model.heroDisplay.length > 0 ? /* @__PURE__ */ jsx(Text, { style: styles.hero, numberOfLines: 1, children: model.heroDisplay }) : null
+    ] }),
+    /* @__PURE__ */ jsxs(
+      View,
+      {
+        style: styles.plot,
+        accessibilityElementsHidden: true,
+        importantForAccessibility: "no-hide-descendants",
+        children: [
+          model.points.map((p, index) => /* @__PURE__ */ jsx(View, { style: [styles.guide, { left: pct(p.xPct) }] }, `g-${index}`)),
+          /* @__PURE__ */ jsx(View, { style: [styles.band, { top: pct(model.bandTopPct), height: pct(bandHeightPct) }] }),
+          model.points.map((p, index) => {
+            const latest = index === model.points.length - 1;
+            return /* @__PURE__ */ jsx(
+              View,
+              {
+                style: [styles.point, latest ? styles.pointLatest : null, { left: pct(p.xPct), top: pct(p.yPct) }]
+              },
+              `pt-${index}`
+            );
+          }),
+          model.maxDisplay.length > 0 ? /* @__PURE__ */ jsx(Text, { style: [styles.edgeLabel, { top: pct(model.bandTopPct) }], numberOfLines: 1, children: model.maxDisplay }) : null,
+          model.minDisplay.length > 0 ? /* @__PURE__ */ jsx(Text, { style: [styles.edgeLabel, { top: pct(model.bandBottomPct) }], numberOfLines: 1, children: model.minDisplay }) : null
+        ]
+      }
+    ),
+    model.firstDate.length > 0 || model.lastDate.length > 0 ? /* @__PURE__ */ jsxs(View, { style: styles.dates, children: [
+      /* @__PURE__ */ jsx(Text, { style: styles.dateLabel, children: model.firstDate }),
+      /* @__PURE__ */ jsx(Text, { style: styles.dateLabel, children: model.lastDate })
+    ] }) : null
+  ] });
+}
+function useStyles2() {
+  const theme = useEverfurTheme();
+  return useMemo(() => makeStyles4(theme), [theme]);
+}
+function makeStyles4(theme) {
+  const { color, space, radius, type } = theme;
+  const { size, lineHeight, weight, letterSpacing, family } = type;
+  const lh = (fontSize, multiplier) => Math.round(fontSize * multiplier);
+  const hairline = StyleSheet.hairlineWidth;
+  const boldWeight = weight.bold;
+  const mediumWeight = weight.medium;
+  const plotHeight = space.xxl * 3;
+  const dotSize = space.sm;
+  const dotOffset = -(dotSize / 2);
+  const bandInset = space.xs;
+  const softShadow = {
+    shadowColor: color.brand,
+    shadowOffset: { width: 0, height: space.xs },
+    shadowRadius: space.sm,
+    shadowOpacity: 0.08,
+    elevation: space.xs
+  };
+  return StyleSheet.create({
+    card: {
+      gap: space.sm,
+      padding: space.lg,
+      borderRadius: radius.md,
+      backgroundColor: color.surfaceCream,
+      borderWidth: hairline,
+      borderColor: color.brandBorder,
+      ...softShadow
+    },
+    eyebrow: {
+      fontFamily: family,
+      fontSize: size.caption,
+      lineHeight: lh(size.caption, lineHeight.normal),
+      color: color.text.muted,
+      letterSpacing: letterSpacing.eyebrow,
+      textTransform: "uppercase"
+    },
+    hero: {
+      fontFamily: family,
+      fontSize: size.verdict,
+      lineHeight: lh(size.verdict, lineHeight.tight),
+      color: color.text.primary,
+      fontWeight: boldWeight,
+      letterSpacing: letterSpacing.tight
+    },
+    plot: {
+      position: "relative",
+      height: plotHeight,
+      marginTop: space.xs
+    },
+    guide: {
+      position: "absolute",
+      top: 0,
+      bottom: 0,
+      width: hairline,
+      backgroundColor: color.borderHairlineGreen
+    },
+    band: {
+      position: "absolute",
+      left: bandInset,
+      right: space.xs,
+      borderRadius: radius.sm,
+      backgroundColor: color.brandSoft
+    },
+    point: {
+      position: "absolute",
+      width: dotSize,
+      height: dotSize,
+      marginLeft: dotOffset,
+      marginTop: dotOffset,
+      borderRadius: radius.pill,
+      backgroundColor: color.brand,
+      borderWidth: hairline,
+      borderColor: color.surfaceCream
+    },
+    pointLatest: {
+      backgroundColor: color.accent,
+      borderColor: color.onAccent
+    },
+    edgeLabel: {
+      position: "absolute",
+      right: 0,
+      marginTop: -space.sm,
+      fontFamily: family,
+      fontSize: size.tiny,
+      lineHeight: lh(size.tiny, lineHeight.tight),
+      color: color.text.muted,
+      fontWeight: mediumWeight
+    },
+    dates: {
+      flexDirection: "row",
+      justifyContent: "space-between"
+    },
+    dateLabel: {
+      fontFamily: family,
+      fontSize: size.tiny,
+      lineHeight: lh(size.tiny, lineHeight.normal),
+      color: color.text.muted
+    }
+  });
+}
+var SPINNER_DELAY_MS = 300;
+function EverfurRecords(props) {
+  const { petRef, controller, onPickDocument, consentVersion, style } = props;
+  return /* @__PURE__ */ jsx(CapabilityGate, { capability: "records", style, children: /* @__PURE__ */ jsx(
+    RecordsBody,
+    {
+      petRef,
+      controller,
+      onPickDocument,
+      consentVersion,
+      style
+    }
+  ) });
+}
+function RecordsBody({
+  petRef,
+  controller,
+  onPickDocument,
+  consentVersion,
+  style
+}) {
+  const styles = useStyles3();
+  const recordsOpts = useMemo(
+    () => controller ? { petRef, controller } : { petRef },
+    [petRef, controller]
+  );
+  const records = useEverfurRecords(recordsOpts);
+  const view = records.status;
+  const canUpload = onPickDocument !== void 0;
+  const onUpload = useMemo(
+    () => makeUploadHandler(records, onPickDocument),
+    [records, onPickDocument]
+  );
+  const onGrant = useMemo(
+    () => makeGrantHandler(records, consentVersion),
+    [records, consentVersion]
+  );
+  const canGrant = useMemo(
+    () => (consentVersion ?? records.consent?.version ?? "").length > 0,
+    [consentVersion, records.consent]
+  );
+  return /* @__PURE__ */ jsxs(View, { style: [styles.container, style], children: [
+    /* @__PURE__ */ jsx(View, { style: styles.body, children: renderView(view, records, onUpload, onGrant, canUpload, canGrant) }),
+    /* @__PURE__ */ jsx(ClinicalDisclaimer, {})
+  ] });
+}
+function renderView(view, records, onUpload, onGrant, canUpload, canGrant) {
+  switch (view) {
+    case "loading":
+      return /* @__PURE__ */ jsx(LoadingState, {});
+    case "empty":
+      return /* @__PURE__ */ jsx(EmptyState, { onUpload, canUpload });
+    case "error":
+      return renderErrorFamily(records, onGrant, canGrant);
+    case "populated":
+      return /* @__PURE__ */ jsx(PopulatedState, { record: records.record, activeRequest: records.activeRequest });
+    default:
+      return assertNever(view);
+  }
+}
+function renderErrorFamily(records, onGrant, canGrant) {
+  if (records.denialReason === "consent_required") {
+    return canGrant ? /* @__PURE__ */ jsx(ConsentRequiredState, { onGrant }) : /* @__PURE__ */ jsx(ConsentUnavailableState, {});
+  }
+  if (records.denialReason === "entitlement") {
+    return /* @__PURE__ */ jsx(ErrorState, { error: makeEverfurError("accessDenied"), onRetry: records.refresh });
+  }
+  if (records.denialReason === "session_required") {
+    return /* @__PURE__ */ jsx(SessionRequiredState, {});
+  }
+  if (records.withheld) {
+    return /* @__PURE__ */ jsx(WithheldState, {});
+  }
+  const error = records.error;
+  if (error === null) return /* @__PURE__ */ jsx(WithheldState, {});
+  return /* @__PURE__ */ jsx(ErrorState, { error, onRetry: records.refresh });
+}
+function makeUploadHandler(records, onPickDocument) {
+  return () => {
+    if (!onPickDocument) return;
+    void (async () => {
+      const file = await onPickDocument();
+      if (!file) return;
+      const key = `records-upload-${Date.now().toString(36)}`;
+      const created = await records.createRequest(key);
+      if (!created.ok) return;
+      await records.uploadDocument(created.value.id, file);
+    })();
+  };
+}
+function makeGrantHandler(records, consentVersion) {
+  return () => {
+    const version = consentVersion ?? records.consent?.version ?? "";
+    if (version.length === 0) return;
+    const key = `records-consent-${Date.now().toString(36)}`;
+    void records.grantConsent(version, key);
+  };
+}
+function LoadingState() {
+  const styles = useStyles3();
+  const [visible, setVisible] = useState(false);
+  useEffect(() => {
+    const id = setTimeout(() => setVisible(true), SPINNER_DELAY_MS);
+    return () => clearTimeout(id);
+  }, []);
+  return /* @__PURE__ */ jsx(View, { style: styles.centered, accessible: true, accessibilityState: { busy: true }, accessibilityLabel: "Loading", children: visible ? /* @__PURE__ */ jsx(ActivityIndicator, {}) : null });
+}
+function EmptyState({ onUpload, canUpload }) {
+  const styles = useStyles3();
+  return /* @__PURE__ */ jsxs(View, { style: styles.centered, accessible: true, accessibilityRole: "summary", accessibilityLabel: "No records yet", children: [
+    /* @__PURE__ */ jsx(View, { style: styles.emptyGlyph }),
+    /* @__PURE__ */ jsx(
+      Pressable,
+      {
+        onPress: canUpload ? onUpload : void 0,
+        disabled: !canUpload,
+        accessibilityRole: "button",
+        accessibilityLabel: "Upload records",
+        accessibilityState: { disabled: !canUpload },
+        style: canUpload ? styles.primaryButton : styles.disabledButton,
+        children: /* @__PURE__ */ jsx(Text, { style: canUpload ? styles.primaryLabel : styles.disabledLabel, children: "Upload records" })
+      }
+    )
+  ] });
+}
+function ConsentRequiredState({ onGrant }) {
+  const styles = useStyles3();
+  return /* @__PURE__ */ jsx(View, { style: styles.centered, accessible: true, accessibilityRole: "alert", accessibilityLabel: "Consent required", children: /* @__PURE__ */ jsx(
+    Pressable,
+    {
+      onPress: onGrant,
+      accessibilityRole: "button",
+      accessibilityLabel: "Allow",
+      style: styles.primaryButton,
+      children: /* @__PURE__ */ jsx(Text, { style: styles.primaryLabel, children: "Allow" })
+    }
+  ) });
+}
+function AlertState({ label, glyph }) {
+  const styles = useStyles3();
+  useEffect(() => {
+    AccessibilityInfo.announceForAccessibility?.(label);
+  }, [label]);
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      style: styles.centered,
+      accessible: true,
+      accessibilityRole: "alert",
+      accessibilityLiveRegion: "assertive",
+      accessibilityLabel: label,
+      children: [
+        /* @__PURE__ */ jsx(View, { style: glyph === "withheld" ? styles.withheldGlyph : styles.emptyGlyph }),
+        /* @__PURE__ */ jsx(Text, { style: styles.errorText, children: label })
+      ]
+    }
+  );
+}
+function ConsentUnavailableState() {
+  return /* @__PURE__ */ jsx(AlertState, { label: "Consent required", glyph: "empty" });
+}
+function SessionRequiredState() {
+  return /* @__PURE__ */ jsx(AlertState, { label: "Sign in required", glyph: "empty" });
+}
+function WithheldState() {
+  return /* @__PURE__ */ jsx(AlertState, { label: "Record unavailable", glyph: "withheld" });
+}
+function ErrorState({ error, onRetry }) {
+  const styles = useStyles3();
+  useEffect(() => {
+    AccessibilityInfo.announceForAccessibility?.(error.displayMessage);
+  }, [error.displayMessage]);
+  return /* @__PURE__ */ jsxs(View, { style: styles.centered, accessible: true, accessibilityRole: "alert", accessibilityLiveRegion: "assertive", 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 PopulatedState({
+  record,
+  activeRequest
+}) {
+  const styles = useStyles3();
+  const hasTimeline = activeRequest !== null && (activeRequest.statusLabel.length > 0 || activeRequest.heldItemCount > 0);
+  const hasRecord = record !== null && !record.isEmpty;
+  if (!hasTimeline && !hasRecord) return /* @__PURE__ */ jsx(LoadingState, {});
+  return /* @__PURE__ */ jsxs(ScrollView, { style: styles.list, contentContainerStyle: styles.listContent, accessibilityLabel: "Records", children: [
+    hasTimeline && activeRequest ? /* @__PURE__ */ jsx(RequestTimeline, { request: activeRequest }) : null,
+    record && !record.isEmpty ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(TrendRangeCard, { series: record.entitySeries, testID: "records-trend-card" }),
+      /* @__PURE__ */ jsx(
+        RecordNavCards,
+        {
+          entities: record.entities,
+          forwardLooking: record.forwardLooking,
+          documents: record.documents,
+          testID: "records-nav-cards"
+        }
+      ),
+      /* @__PURE__ */ jsx(RecordDetails, { record })
+    ] }) : null
+  ] });
+}
+function RequestTimeline({ request }) {
+  const styles = useStyles3();
+  const hasLabel = request.statusLabel.length > 0;
+  const hasHeld = request.heldItemCount > 0;
+  if (!hasLabel && !hasHeld) return null;
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      style: styles.timeline,
+      accessible: true,
+      accessibilityRole: "text",
+      ...hasLabel ? { accessibilityLabel: request.statusLabel } : {},
+      children: [
+        hasLabel ? /* @__PURE__ */ jsx(Text, { style: styles.timelineLabel, children: request.statusLabel }) : null,
+        hasHeld ? /* @__PURE__ */ jsx(Text, { style: styles.timelineMeta, children: `${request.heldItemCount} being reviewed` }) : null
+      ]
+    }
+  );
+}
+function RecordDetails({ record }) {
+  const styles = useStyles3();
+  const uncategorized = record.entities.filter((entity) => entity.category.trim().length === 0);
+  const hasDetails = record.identity.length > 0 || uncategorized.length > 0;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    hasDetails ? /* @__PURE__ */ jsxs(View, { style: styles.recordBlock, children: [
+      record.identity.map((field) => /* @__PURE__ */ jsxs(View, { style: styles.row, children: [
+        /* @__PURE__ */ jsx(Text, { style: styles.rowLabel, children: field.label }),
+        /* @__PURE__ */ jsx(Text, { style: styles.rowValue, children: field.value })
+      ] }, field.label)),
+      uncategorized.map((entity) => /* @__PURE__ */ jsxs(View, { style: styles.row, children: [
+        /* @__PURE__ */ jsx(Text, { style: styles.rowLabel, children: entity.label }),
+        /* @__PURE__ */ jsx(Text, { style: styles.rowValue, children: formatEntityValue(entity.value, entity.unit) })
+      ] }, entity.key))
+    ] }) : null,
+    record.disclaimer.length > 0 ? /* @__PURE__ */ jsx(Text, { style: styles.disclaimer, children: record.disclaimer }) : null
+  ] });
+}
+function useStyles3() {
+  const theme = useEverfurTheme();
+  return useMemo(() => makeStyles5(theme), [theme]);
+}
+function makeStyles5(theme) {
+  const { color, space, radius, type } = theme;
+  const { size, lineHeight, weight, letterSpacing, family } = type;
+  const lh = (fontSize, multiplier) => Math.round(fontSize * multiplier);
+  const hairline = StyleSheet.hairlineWidth;
+  const boldWeight = weight.bold;
+  const mediumWeight = weight.medium;
+  const minSurface = space.xxl * 3 + space.xl;
+  const touchTarget = space.xxl + space.md;
+  const glyphSize = space.xxl + space.sm;
+  const errorColor = theme.brightness === "dark" ? color.errorRed : color.danger;
+  const softShadow = {
+    shadowColor: color.brand,
+    shadowOffset: { width: 0, height: space.xs },
+    shadowRadius: space.sm,
+    shadowOpacity: 0.08,
+    elevation: space.xs
+  };
+  return StyleSheet.create({
+    container: { flex: 1, minHeight: minSurface, backgroundColor: color.background },
+    body: { flex: 1 },
+    centered: {
+      minHeight: minSurface,
+      flexGrow: 1,
+      alignItems: "center",
+      justifyContent: "center",
+      padding: space.xl,
+      gap: space.lg
+    },
+    // Branded empty placeholder: a soft-brand disc ringed in the hairline brand border.
+    emptyGlyph: {
+      width: glyphSize,
+      height: glyphSize,
+      borderRadius: radius.lg,
+      backgroundColor: color.brandSoft,
+      borderWidth: hairline,
+      borderColor: color.brandBorder
+    },
+    // Withheld / fail-closed glyph: a caution wash ringed in the caution accent.
+    withheldGlyph: {
+      width: glyphSize,
+      height: glyphSize,
+      borderRadius: radius.sm,
+      backgroundColor: color.badgeBgCaution,
+      borderWidth: hairline,
+      borderColor: color.cautionAccent
+    },
+    errorText: {
+      fontFamily: family,
+      fontSize: size.subtitle,
+      lineHeight: lh(size.subtitle, lineHeight.snug),
+      color: errorColor,
+      textAlign: "center",
+      marginBottom: space.md
+    },
+    // Primary CTA: brand fill, WCAG onPrimary foreground, pill radius, soft brand shadow.
+    primaryButton: {
+      minHeight: touchTarget,
+      minWidth: touchTarget,
+      alignItems: "center",
+      justifyContent: "center",
+      paddingHorizontal: space.xl,
+      paddingVertical: space.md,
+      borderRadius: radius.pill,
+      backgroundColor: color.primary,
+      ...softShadow
+    },
+    primaryLabel: {
+      fontFamily: family,
+      color: color.onPrimary,
+      fontSize: size.body,
+      fontWeight: boldWeight,
+      letterSpacing: letterSpacing.tight
+    },
+    disabledButton: {
+      minHeight: touchTarget,
+      minWidth: touchTarget,
+      alignItems: "center",
+      justifyContent: "center",
+      paddingHorizontal: space.xl,
+      paddingVertical: space.md,
+      borderRadius: radius.pill,
+      backgroundColor: color.surfaceSubtle,
+      borderWidth: hairline,
+      borderColor: color.brandBorder
+    },
+    disabledLabel: {
+      fontFamily: family,
+      color: color.text.muted,
+      fontSize: size.body,
+      fontWeight: boldWeight,
+      letterSpacing: letterSpacing.tight
+    },
+    list: { flex: 1 },
+    listContent: { padding: space.lg, gap: space.md },
+    // Request timeline: a cream card with the brand hairline border + soft depth.
+    timeline: {
+      paddingVertical: space.md,
+      paddingHorizontal: space.lg,
+      borderRadius: radius.md,
+      backgroundColor: color.surfaceCream,
+      borderWidth: hairline,
+      borderColor: color.brandBorder,
+      gap: space.xs,
+      ...softShadow
+    },
+    timelineLabel: {
+      fontFamily: family,
+      fontSize: size.subtitle,
+      lineHeight: lh(size.subtitle, lineHeight.snug),
+      color: color.text.secondary,
+      fontWeight: boldWeight,
+      letterSpacing: letterSpacing.tight
+    },
+    timelineMeta: {
+      fontFamily: family,
+      fontSize: size.bodyTight,
+      lineHeight: lh(size.bodyTight, lineHeight.normal),
+      color: color.text.muted
+    },
+    // Parsed record: a cream card of hairline-divided label/value rows.
+    recordBlock: {
+      gap: space.sm,
+      padding: space.md,
+      borderRadius: radius.md,
+      backgroundColor: color.surfaceCream,
+      borderWidth: hairline,
+      borderColor: color.brandBorder,
+      ...softShadow
+    },
+    row: {
+      flexDirection: "row",
+      justifyContent: "space-between",
+      gap: space.md,
+      paddingVertical: space.xs,
+      borderBottomWidth: hairline,
+      borderBottomColor: color.borderHairlineGreen
+    },
+    rowLabel: {
+      fontFamily: family,
+      fontSize: size.body,
+      lineHeight: lh(size.body, lineHeight.normal),
+      color: color.text.muted,
+      flexShrink: 1
+    },
+    rowValue: {
+      fontFamily: family,
+      fontSize: size.body,
+      lineHeight: lh(size.body, lineHeight.normal),
+      color: color.text.primary,
+      fontWeight: mediumWeight,
+      textAlign: "right",
+      flexShrink: 1
+    },
+    disclaimer: {
+      fontFamily: family,
+      fontSize: size.caption,
+      lineHeight: lh(size.caption, lineHeight.normal),
+      color: color.text.muted,
+      marginTop: space.md
+    }
+  });
+}
+
+export { EverfurRecords, RECORDS_TERMINAL, isTerminalStatus, recordsDenialReasonOf, useEverfurRecords };