@everfur/sdk 0.1.0

package/dist/client/index.js

@@ -0,0 +1,2217 @@
+import { z } from 'zod';
+
+// src/client/contract/contract.generated.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;
+}
+function contractDocUrl(entry) {
+  return entry.envelope === "sse_frame" ? `/errors#sse-${entry.wireCode}` : `/errors#${entry.wireCode}`;
+}
+var DOC_SITE_ORIGIN = null;
+function publishedDocUrl(entry) {
+  return null ;
+}
+
+// src/client/errors/codes.ts
+var EVERFUR_ERROR_CODES = Object.freeze([
+  "authExpired",
+  "authRejected",
+  "sessionRequired",
+  "accessDenied",
+  "paymentRequired",
+  "quotaExceeded",
+  "rateLimited",
+  "validationFailed",
+  "sdkUpdateRequired",
+  "conflict",
+  "idempotencyConflict",
+  "idempotencyInFlight",
+  "conversationNotFound",
+  "petNotFound",
+  "resourceNotFound",
+  "streamTimeout",
+  "mediaUploadFailed",
+  "moderationBlocked",
+  "upstreamLlmTimeout",
+  "internalError",
+  "notImplemented",
+  "serviceUnavailable",
+  "streamIncomplete",
+  "unknown"
+]);
+var EVERFUR_ERROR_CATEGORIES = Object.freeze([
+  "authentication",
+  "authorization",
+  "entitlement",
+  "rateLimit",
+  "invalidRequest",
+  "notFound",
+  "conflict",
+  "connection",
+  "server",
+  "media",
+  "policy",
+  "unknown"
+]);
+var CATEGORY_OF = Object.freeze({
+  // the caller's sign-in state is wrong and a credential change is the remedy
+  authExpired: "authentication",
+  authRejected: "authentication",
+  sessionRequired: "authentication",
+  // signed in, correctly identified, and still not allowed
+  accessDenied: "authorization",
+  // a plan gate, not a permission failure: the remedy is commercial
+  paymentRequired: "entitlement",
+  // slow down / come back later
+  quotaExceeded: "rateLimit",
+  rateLimited: "rateLimit",
+  // the request itself was wrong; retrying it unchanged can never succeed
+  validationFailed: "invalidRequest",
+  sdkUpdateRequired: "invalidRequest",
+  // the target is gone, hidden, or was never visible to this caller
+  conversationNotFound: "notFound",
+  petNotFound: "notFound",
+  resourceNotFound: "notFound",
+  // something else already holds the thing
+  conflict: "conflict",
+  idempotencyConflict: "conflict",
+  idempotencyInFlight: "conflict",
+  // the pipe, not the request: timeouts, drops, a briefly unreachable dependency
+  streamTimeout: "connection",
+  streamIncomplete: "connection",
+  upstreamLlmTimeout: "connection",
+  serviceUnavailable: "connection",
+  // the server admits fault
+  internalError: "server",
+  notImplemented: "server",
+  mediaUploadFailed: "media",
+  moderationBlocked: "policy",
+  unknown: "unknown"
+});
+function categoryFor(code) {
+  return CATEGORY_OF[code];
+}
+function fromWire(wire) {
+  const contractRow = contractErrorFor(wire);
+  if (contractRow) return contractRow.normalized;
+  const upper = (wire ?? "").trim().toUpperCase();
+  const canonical = upper.replace(/[^A-Z0-9]/g, "");
+  if (canonical === "AUTHREJECTED") return "authRejected";
+  if (upper.startsWith("AUTH")) return "authExpired";
+  switch (canonical) {
+    case "DAILYQUOTAEXCEEDED":
+    case "QUOTAEXCEEDED":
+      return "quotaExceeded";
+    case "RATELIMITED":
+    case "TOOMANYREQUESTS":
+      return "rateLimited";
+    case "IDEMPOTENCYKEYCONFLICT":
+    case "IDEMPOTENCYCONFLICT":
+      return "idempotencyConflict";
+    case "ACCESSDENIED":
+    case "FORBIDDEN":
+      return "accessDenied";
+    case "NOTFOUND":
+    case "CONVERSATIONNOTFOUND":
+      return "conversationNotFound";
+    case "PETNOTFOUND":
+      return "petNotFound";
+    case "TIMEOUT":
+    case "STREAMTIMEOUT":
+      return "streamTimeout";
+    // Analysis-domain deterministic 400s (NON-retryable). Additive per SPEC-00 §3.1 / SPEC-11b §2.6:
+    // fold to a NON-retried target so the SDK never retries a permanently-failing bad-input request.
+    // (Comment above the group so the empty fall-through cases stay lint-clean under no-fallthrough.)
+    case "MEDIAUPLOADFAILED":
+    case "UNRECOGNIZEDVIDEOFORMAT":
+    case "FILETOOSMALL":
+      return "mediaUploadFailed";
+    case "MODERATIONBLOCKED":
+      return "moderationBlocked";
+    case "UPSTREAMLLMTIMEOUT":
+      return "upstreamLlmTimeout";
+    case "INTERNALERROR":
+    case "INTERNALSERVERERROR":
+      return "internalError";
+    case "STREAMINCOMPLETE":
+    case "CHATSTREAMINCOMPLETE":
+      return "streamIncomplete";
+    // Deterministic 400s that can only come from an SDK bug -> unknown (NON-retryable). NEVER internalError
+    // (which IS auto-retried): mapping a bad-input 400 to a retryable code retries a request that never succeeds.
+    case "INVALIDANALYSISTYPE":
+    case "INVALIDUPLOADPURPOSE":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+function fromHttpStatus(status) {
+  if (status === 401) return "authExpired";
+  if (status === 403) return "accessDenied";
+  if (status === 404) return "conversationNotFound";
+  if (status === 409) return "idempotencyConflict";
+  if (status === 421) return "unknown";
+  if (status === 429) return "rateLimited";
+  if (status === 400 || status === 422) return "unknown";
+  if (status >= 500) return "internalError";
+  return "unknown";
+}
+var AUTO_RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "streamTimeout",
+  "rateLimited",
+  "internalError",
+  "upstreamLlmTimeout",
+  "streamIncomplete"
+]);
+function isAutoRetryable(code) {
+  return AUTO_RETRYABLE_CODES.has(code);
+}
+var RETRYABLE_CONTRACT_CODES = /* @__PURE__ */ new Set([
+  "serviceUnavailable",
+  "conflict",
+  "idempotencyInFlight"
+]);
+function isRetryableCode(code) {
+  return isAutoRetryable(code) || RETRYABLE_CONTRACT_CODES.has(code);
+}
+function shouldRetry(code, frameRetryable = false) {
+  return frameRetryable || isAutoRetryable(code);
+}
+var BACKOFF_BASE_MS = 500;
+var BACKOFF_CAP_MS = 8e3;
+var MAX_RETRY_ATTEMPTS = 4;
+function backoffDelayMs(attempt, rng = Math.random) {
+  const bounded = Math.max(0, attempt);
+  const ceiling = Math.min(BACKOFF_BASE_MS * 2 ** bounded, BACKOFF_CAP_MS);
+  return Math.floor(rng() * ceiling);
+}
+function canRecreateOnNotFound(code) {
+  return code === "conversationNotFound";
+}
+
+// src/client/errors/EverfurError.ts
+var USER_FACING_COPY = Object.freeze({
+  authExpired: "Please sign in again to continue.",
+  authRejected: "Please sign in again to continue.",
+  sessionRequired: "This app needs to be updated to keep using Everfur.",
+  accessDenied: "This feature isn't available on your account right now.",
+  paymentRequired: "This is part of a paid plan.",
+  quotaExceeded: "You have used today's messages. This resets tomorrow.",
+  rateLimited: "You are sending messages quickly. Try again in a few seconds.",
+  validationFailed: "Something in that request was not right. Check the details and try again.",
+  sdkUpdateRequired: "This app needs to be updated to keep using Everfur.",
+  conflict: "That is already running. Wait for it to finish, then try again.",
+  idempotencyConflict: "That message was already delivered.",
+  idempotencyInFlight: "That is still processing. Give it a moment.",
+  conversationNotFound: "This conversation is no longer available.",
+  petNotFound: "We could not find that pet. Please pick a pet and try again.",
+  resourceNotFound: "We could not find that.",
+  streamTimeout: "The response timed out. Tap retry to try again.",
+  mediaUploadFailed: "We could not upload that photo. Please attach it again.",
+  moderationBlocked: "This request cannot be answered here.",
+  upstreamLlmTimeout: "The response timed out. Tap retry to try again.",
+  internalError: "We hit a snag on our end. Please try again.",
+  notImplemented: "That is not available yet.",
+  serviceUnavailable: "That service is briefly unavailable. Try again shortly.",
+  streamIncomplete: "The connection dropped mid-answer. Tap retry to continue.",
+  unknown: "Something went wrong. Please try again."
+});
+function userFacingError(code) {
+  return USER_FACING_COPY[code];
+}
+function defineHidden(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+}
+function makeEverfurError(code, opts) {
+  contractErrorFor(opts?.wireCode);
+  const error = {
+    code,
+    category: categoryFor(code),
+    retryable: opts?.retryable ?? isRetryableCode(code),
+    displayMessage: userFacingError(code)
+  };
+  if (opts?.httpStatus !== void 0) error.httpStatus = opts.httpStatus;
+  if (opts?.requestId) error.requestId = opts.requestId;
+  if (opts?.wireMessage) defineHidden(error, "wireMessage", opts.wireMessage);
+  if (opts?.raw !== void 0 && opts.raw !== null) defineHidden(error, "raw", opts.raw);
+  return Object.freeze(error);
+}
+
+// src/client/errors/EverfurResult.ts
+function ok(value, warning) {
+  return Object.freeze(
+    warning === void 0 ? { ok: true, value } : { ok: true, value, warning }
+  );
+}
+function err(error) {
+  return Object.freeze({ ok: false, error });
+}
+function isOk(r) {
+  return r.ok;
+}
+function isErr(r) {
+  return !r.ok;
+}
+var EverfurThrownError = class _EverfurThrownError extends Error {
+  constructor(error) {
+    super(`${error.code}: ${error.displayMessage}`);
+    this.name = "EverfurThrownError";
+    this.error = error;
+    this.code = error.code;
+    this.category = error.category;
+    Object.setPrototypeOf(this, _EverfurThrownError.prototype);
+  }
+};
+function unwrap(r) {
+  if (r.ok) return r.value;
+  throw new EverfurThrownError(r.error);
+}
+var EverfurConfigError = class _EverfurConfigError extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.name = "EverfurConfigError";
+    this.kind = kind;
+    Object.setPrototypeOf(this, _EverfurConfigError.prototype);
+  }
+};
+
+// src/client/config.ts
+var SDK_VERSION = "0.1.0";
+var SDK_PLATFORM = "react-native";
+var DEFAULT_CONTRACT_VERSION = "2026-08-01";
+var ENV_API_BASE_URL = "EVERFUR_API_BASE_URL";
+function configFailure(reason, message) {
+  return Object.freeze({ ok: false, failure: Object.freeze({ reason, message }) });
+}
+function checkPublishableKey(raw) {
+  const publishableKey = typeof raw === "string" ? raw.trim() : "";
+  if (publishableKey.length === 0) {
+    return { reason: "missing-publishable-key", message: "publishableKey is required" };
+  }
+  if (/^sk[_-]/i.test(publishableKey)) {
+    return {
+      reason: "secret-key-as-publishable-key",
+      message: "publishableKey looks like a SECRET key (sk_...). A device must never hold a partner secret key: use the pk_ publishable key here, and keep the secret key on your server."
+    };
+  }
+  return null;
+}
+function tryResolveClientConfig(config) {
+  const keyFailure = checkPublishableKey(config?.publishableKey);
+  if (keyFailure !== null) {
+    return Object.freeze({ ok: false, failure: keyFailure });
+  }
+  const publishableKey = config.publishableKey.trim();
+  const baseUrl = tryResolveApiBaseUrl(config.apiBaseUrl);
+  if (!baseUrl.ok) {
+    return baseUrl;
+  }
+  const contractVersion = config.contractVersion?.trim() || DEFAULT_CONTRACT_VERSION;
+  return Object.freeze({
+    ok: true,
+    config: Object.freeze({
+      publishableKey,
+      apiBaseUrl: baseUrl.value,
+      contractVersion,
+      sdkVersion: SDK_VERSION,
+      platform: SDK_PLATFORM,
+      debug: config.debug === true
+    })
+  });
+}
+function resolveClientConfig(config) {
+  const outcome = tryResolveClientConfig(config);
+  if (!outcome.ok) {
+    throw new EverfurConfigError("invalid-argument", outcome.failure.message);
+  }
+  return outcome.config;
+}
+function tryResolveApiBaseUrl(apiBaseUrl) {
+  const explicit = apiBaseUrl?.trim();
+  const candidate = explicit && explicit.length > 0 ? explicit : readEnv(ENV_API_BASE_URL);
+  if (!candidate) {
+    return configFailure(
+      "missing-api-base-url",
+      `apiBaseUrl is required: pass config.apiBaseUrl or set ${ENV_API_BASE_URL}. The SDK never ships a hardcoded host.`
+    );
+  }
+  return normalizeBaseUrl(candidate);
+}
+function resolveApiBaseUrl(apiBaseUrl) {
+  const outcome = tryResolveApiBaseUrl(apiBaseUrl);
+  if (!outcome.ok) {
+    throw new EverfurConfigError("invalid-argument", outcome.failure.message);
+  }
+  return outcome.value;
+}
+function buildBaseHeaders(cfg) {
+  return {
+    "X-Everfur-SDK-Version": cfg.sdkVersion,
+    "X-Everfur-SDK-Platform": cfg.platform,
+    "X-Everfur-Contract": cfg.contractVersion
+  };
+}
+var ABSOLUTE_URL = /^([A-Za-z][A-Za-z0-9+.-]*):\/\/([^/?#]*)/;
+function hostOf(authority) {
+  const afterUserinfo = authority.slice(authority.lastIndexOf("@") + 1);
+  return afterUserinfo.replace(/:\d+$/, "").toLowerCase();
+}
+function isPrintableHost(host) {
+  if (host.length === 0) return false;
+  if (host.includes("@")) return false;
+  if (host.startsWith("[") && host.endsWith("]")) return true;
+  return !host.includes(":");
+}
+function canEchoOrigin(rawTrimmed, host) {
+  const schemeEnd = rawTrimmed.indexOf("://");
+  if (schemeEnd < 0) return false;
+  if (rawTrimmed.slice(schemeEnd + 3).includes("@")) return false;
+  return isPrintableHost(host);
+}
+function safeOrigin(scheme, host) {
+  return `${scheme}://${host}`;
+}
+function normalizeBaseUrl(raw) {
+  const trimmed = raw.trim();
+  const match = ABSOLUTE_URL.exec(trimmed);
+  if (match === null || match[2] === void 0 || match[2].length === 0) {
+    return configFailure("malformed-api-base-url", "apiBaseUrl is not a valid absolute URL");
+  }
+  const scheme = (match[1] ?? "").toLowerCase();
+  const host = hostOf(match[2]);
+  if (host.length === 0) {
+    return configFailure("malformed-api-base-url", "apiBaseUrl is not a valid absolute URL");
+  }
+  const shown = canEchoOrigin(trimmed, host) ? `: ${safeOrigin(scheme, host)}` : "";
+  if (scheme === "https") ; else if (scheme === "http" && isLoopbackHost(host)) ; else if (scheme === "http") {
+    return configFailure(
+      "insecure-api-base-url",
+      `apiBaseUrl must use https (cleartext http is only allowed for localhost)${shown}`
+    );
+  } else {
+    return configFailure("unsupported-api-base-url-scheme", `apiBaseUrl must be http(s)${shown}`);
+  }
+  const value = trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+  return Object.freeze({ ok: true, value });
+}
+function isLoopbackHost(hostname) {
+  const host = hostname.toLowerCase();
+  return host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host === "::1";
+}
+function readEnv(name) {
+  const g = globalThis;
+  const value = g.process?.env?.[name];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+
+// src/client/text.ts
+function hasLoneSurrogate(value) {
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      const low = value.charCodeAt(i + 1);
+      if (!(low >= 56320 && low <= 57343)) return true;
+      i += 1;
+    } else if (code >= 56320 && code <= 57343) {
+      return true;
+    }
+  }
+  return false;
+}
+function serverLength(value) {
+  return [...value].length;
+}
+
+// src/client/ids.ts
+var MAX_USER_REF_LEN = 128;
+var MAX_PET_REF_LEN = 128;
+var CONTROL_CHAR = /[\u0000-\u001F\u007F]/;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function petRef(raw) {
+  const v = raw;
+  const length = serverLength(v);
+  if (length === 0 || length > MAX_PET_REF_LEN) {
+    throw new EverfurConfigError(
+      "invalid-argument",
+      `petRef must be 1..${MAX_PET_REF_LEN} characters`
+    );
+  }
+  if (CONTROL_CHAR.test(v)) {
+    throw new EverfurConfigError("invalid-argument", "petRef must be printable (no control characters)");
+  }
+  return v;
+}
+function userRef(raw) {
+  const v = raw;
+  const length = serverLength(v);
+  if (length === 0 || length > MAX_USER_REF_LEN) {
+    throw new EverfurConfigError(
+      "invalid-argument",
+      `userRef must be 1..${MAX_USER_REF_LEN} characters`
+    );
+  }
+  if (v.includes("@")) {
+    throw new EverfurConfigError("invalid-argument", "userRef must not contain '@'");
+  }
+  if (CONTROL_CHAR.test(v)) {
+    throw new EverfurConfigError("invalid-argument", "userRef must be printable (no control characters)");
+  }
+  return v;
+}
+function conversationId(raw) {
+  if (!UUID_RE.test(raw)) {
+    throw new EverfurConfigError("invalid-argument", "conversationId must be a UUID");
+  }
+  return raw;
+}
+function unsafePetRef(raw) {
+  return raw;
+}
+function unsafeUserRef(raw) {
+  return raw;
+}
+function unsafeConversationId(raw) {
+  return raw;
+}
+function unsafeResponseId(raw) {
+  return raw;
+}
+function unsafeClientId(raw) {
+  return raw;
+}
+function unsafeDocumentId(raw) {
+  return raw;
+}
+function unsafeJobId(raw) {
+  return raw;
+}
+function unsafeRecordsRequestId(raw) {
+  return raw;
+}
+
+// src/client/identity.ts
+function createIdentityProvider(userRef2, getToken) {
+  let cached = null;
+  let inFlight = null;
+  let revoked = false;
+  const load = () => {
+    if (inFlight) return inFlight;
+    inFlight = (async () => {
+      try {
+        const token = await getToken();
+        if (typeof token !== "string" || token.length === 0) {
+          throw new EverfurConfigError("invalid-argument", "TokenProvider returned an empty token");
+        }
+        cached = token;
+        return token;
+      } finally {
+        inFlight = null;
+      }
+    })();
+    return inFlight;
+  };
+  return {
+    userRef: userRef2,
+    async currentToken(opts) {
+      if (revoked) {
+        throw new EverfurConfigError("not-initialized", "This identity was cleared (sign-out); mint a new one.");
+      }
+      if (opts?.forceRefresh) cached = null;
+      if (cached !== null) return cached;
+      return load();
+    },
+    hasToken() {
+      return !revoked && cached !== null;
+    },
+    clear() {
+      revoked = true;
+      cached = null;
+    }
+  };
+}
+function newSessionId() {
+  const bytes = new Uint8Array(16);
+  const cryptoObj = globalThis.crypto;
+  if (typeof cryptoObj?.getRandomValues === "function") {
+    cryptoObj.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [];
+  for (let i = 0; i < bytes.length; i += 1) hex.push(bytes[i].toString(16).padStart(2, "0"));
+  return hex.slice(0, 4).join("") + "-" + hex.slice(4, 6).join("") + "-" + hex.slice(6, 8).join("") + "-" + hex.slice(8, 10).join("") + "-" + hex.slice(10, 16).join("");
+}
+function authHeaders(auth) {
+  const headers = {};
+  if (auth.mode === "personalized") {
+    headers.authorization = `Bearer ${auth.token}`;
+  } else {
+    headers["x-everfur-partner-key"] = auth.publishableKey;
+  }
+  if (auth.userRef) headers["x-everfur-user-ref"] = auth.userRef;
+  if (auth.sessionId) headers["x-everfur-session-id"] = auth.sessionId;
+  return headers;
+}
+function withAuthHeaders(req, auth) {
+  return { ...req, headers: { ...stripAuthHeaders(req.headers), ...authHeaders(auth) } };
+}
+function stripAuthHeaders(headers) {
+  if (!headers) return {};
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const lower = key.toLowerCase();
+    if (lower === "authorization" || lower === "x-everfur-partner-key") continue;
+    out[key] = value;
+  }
+  return out;
+}
+async function authedSend(req, ctx) {
+  if (ctx.mode === "anonymous") {
+    return ctx.transport.request(
+      withAuthHeaders(req, {
+        mode: "anonymous",
+        publishableKey: ctx.publishableKey,
+        userRef: ctx.userRef,
+        ...ctx.sessionId ? { sessionId: ctx.sessionId } : {}
+      })
+    );
+  }
+  let token;
+  try {
+    token = await ctx.identity.currentToken();
+  } catch {
+    return err(authRejectedError());
+  }
+  const first = await ctx.transport.request(
+    withAuthHeaders(req, {
+      mode: "personalized",
+      token,
+      userRef: ctx.userRef,
+      ...ctx.sessionId ? { sessionId: ctx.sessionId } : {}
+    })
+  );
+  if (first.ok || first.error.httpStatus !== 401) return first;
+  let refreshed;
+  try {
+    refreshed = await ctx.identity.currentToken({ forceRefresh: true });
+  } catch {
+    return err(authRejectedError());
+  }
+  const retry = await ctx.transport.request(
+    withAuthHeaders(req, {
+      mode: "personalized",
+      token: refreshed,
+      userRef: ctx.userRef,
+      ...ctx.sessionId ? { sessionId: ctx.sessionId } : {}
+    })
+  );
+  if (!retry.ok && retry.error.httpStatus === 401) {
+    return err(authRejectedError(retry.error.httpStatus));
+  }
+  return retry;
+}
+function authRejectedError(httpStatus) {
+  return makeEverfurError("authRejected", {
+    retryable: false,
+    ...httpStatus !== void 0 ? { httpStatus } : {}
+  });
+}
+
+// src/client/protocol/frames.ts
+function assertNever(x) {
+  throw new Error(
+    `assertNever: unhandled discriminated-union member ${JSON.stringify(x)}`
+  );
+}
+var EMPTY_STRINGS = Object.freeze([]);
+var EMPTY_MAPS = Object.freeze([]);
+function acceptedFrame(streamId, lastEventId, serverRequestId = null) {
+  return Object.freeze({ kind: "accepted", streamId, lastEventId, serverRequestId, terminal: false });
+}
+function heartbeatFrame(lastEventId, serverRequestId = null) {
+  return Object.freeze({ kind: "heartbeat", lastEventId, serverRequestId, terminal: false });
+}
+function deltaFrame(delta, lastEventId, serverRequestId = null) {
+  return Object.freeze({ kind: "delta", delta, lastEventId, serverRequestId, terminal: false });
+}
+function doneFrame(fields, serverRequestId = null) {
+  return Object.freeze({
+    kind: "done",
+    terminal: true,
+    conversationId: fields.conversationId,
+    messageId: fields.messageId,
+    title: fields.title,
+    followUpQuestions: Object.freeze([...fields.followUpQuestions]),
+    citations: Object.freeze([...fields.citations]),
+    citationStatus: fields.citationStatus,
+    urgencyLevel: fields.urgencyLevel,
+    urgencyReason: fields.urgencyReason,
+    resultId: fields.resultId,
+    lastEventId: fields.lastEventId,
+    serverRequestId
+  });
+}
+function errorFrame(fields) {
+  return Object.freeze({
+    kind: "error",
+    terminal: true,
+    code: fields.code,
+    retryable: fields.retryable,
+    wireMessage: fields.wireMessage,
+    synthesized: fields.synthesized,
+    lastEventId: fields.lastEventId,
+    serverRequestId: fields.serverRequestId ?? null
+  });
+}
+function analysisStartedFrame(requestId, lastEventId, serverRequestId = null) {
+  return Object.freeze({
+    kind: "analysisStarted",
+    requestId,
+    lastEventId,
+    serverRequestId,
+    terminal: false
+  });
+}
+function analysisCompleteFrame(fields, serverRequestId = null) {
+  return Object.freeze({
+    kind: "analysisComplete",
+    terminal: false,
+    resultId: fields.resultId,
+    analysisType: fields.analysisType,
+    modelVersion: fields.modelVersion,
+    confidence: fields.confidence,
+    detections: Object.freeze([...fields.detections]),
+    interpretation: fields.interpretation,
+    lastEventId: fields.lastEventId,
+    serverRequestId
+  });
+}
+function unknownFrame(raw, lastEventId, serverRequestId = null) {
+  return Object.freeze({
+    kind: "unknown",
+    raw: { ...raw },
+    lastEventId,
+    serverRequestId,
+    terminal: false
+  });
+}
+var EMPTY_FRAME_ARRAYS = Object.freeze({
+  strings: EMPTY_STRINGS,
+  maps: EMPTY_MAPS
+});
+var BLOCK_SEPARATOR = "\n\n";
+var MAX_PENDING_BLOCK_CHARS = 1048576;
+var wireObjectSchema = z.record(z.string(), z.unknown());
+var URGENCY_LEVELS = ["emergency", "schedule_soon", "home_care"];
+async function* parseSse(bytes, serverRequestId = null) {
+  let resolvedRequestId = null;
+  const requestIdNow = () => {
+    if (resolvedRequestId !== null) return resolvedRequestId;
+    resolvedRequestId = typeof serverRequestId === "function" ? serverRequestId() : serverRequestId;
+    return resolvedRequestId;
+  };
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let scanFrom = 0;
+  let sawDelta = false;
+  for await (const chunk of bytes) {
+    buffer += decoder.decode(chunk, { stream: true });
+    for (; ; ) {
+      const sep = buffer.indexOf(BLOCK_SEPARATOR, scanFrom);
+      if (sep === -1) break;
+      const block = buffer.slice(0, sep);
+      buffer = buffer.slice(sep + BLOCK_SEPARATOR.length);
+      scanFrom = 0;
+      const frame = parseBlock(block, requestIdNow());
+      if (frame === null) continue;
+      if (frame.kind === "delta") sawDelta = true;
+      yield frame;
+      if (frame.terminal) return;
+    }
+    scanFrom = buffer.length > 0 ? buffer.length - 1 : 0;
+    if (buffer.length > MAX_PENDING_BLOCK_CHARS) {
+      yield errorFrame({
+        code: sawDelta ? "CHAT_STREAM_INCOMPLETE" : "internal_error",
+        retryable: true,
+        wireMessage: null,
+        synthesized: true,
+        lastEventId: null,
+        serverRequestId: requestIdNow()
+      });
+      return;
+    }
+  }
+  buffer += decoder.decode();
+  if (buffer.trim().length > 0) {
+    const frame = parseBlock(buffer, requestIdNow());
+    if (frame !== null) {
+      if (frame.kind === "delta") sawDelta = true;
+      yield frame;
+      if (frame.terminal) return;
+    }
+  }
+  yield errorFrame({
+    code: sawDelta ? "CHAT_STREAM_INCOMPLETE" : "internal_error",
+    retryable: true,
+    wireMessage: null,
+    synthesized: true,
+    lastEventId: null,
+    serverRequestId: requestIdNow()
+  });
+}
+function parseBlock(block, serverRequestId) {
+  let id = null;
+  const dataLines = [];
+  for (const rawLine of block.split("\n")) {
+    const line = rawLine.replace(/\s+$/, "");
+    if (line.length === 0 || line.startsWith(":")) continue;
+    if (line.startsWith("id:")) {
+      id = line.slice(3).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).replace(/^ /, ""));
+    }
+  }
+  if (dataLines.length === 0) return null;
+  let decoded;
+  try {
+    decoded = JSON.parse(dataLines.join("\n"));
+  } catch {
+    return null;
+  }
+  if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) return null;
+  const parsed = wireObjectSchema.safeParse(decoded);
+  if (!parsed.success) return null;
+  return frameFromWire(parsed.data, id, serverRequestId);
+}
+function frameFromWire(json, lastEventId, serverRequestId) {
+  const type = json["type"];
+  const event = json["event"];
+  if (type === "error" || "error" in json) {
+    return errorFrame({
+      code: asString(json["code"]) ?? "unknown",
+      retryable: json["retryable"] === true,
+      wireMessage: asString(json["error"]),
+      synthesized: false,
+      lastEventId,
+      serverRequestId
+    });
+  }
+  if (type === "done" || json["done"] === true) {
+    return doneFrame({
+      conversationId: asString(json["conversation_id"]) ?? "",
+      messageId: asString(json["message_id"]),
+      title: asString(json["title"]),
+      followUpQuestions: asStringList(json["follow_up_questions"]),
+      citations: asMapList(json["citations"]),
+      citationStatus: asString(json["citation_status"]),
+      urgencyLevel: asUrgency(json["urgency_level"]),
+      urgencyReason: asString(json["urgency_reason"]),
+      resultId: asString(json["result_id"]),
+      lastEventId
+    }, serverRequestId);
+  }
+  if (type === "accepted" || json["status"] === "reasoning") {
+    return acceptedFrame(asString(json["stream_id"]), lastEventId, serverRequestId);
+  }
+  if (type === "heartbeat" || json["heartbeat"] === true) {
+    return heartbeatFrame(lastEventId, serverRequestId);
+  }
+  if (type === "text.delta" || "delta" in json || "token" in json) {
+    const delta = asString(json["delta"]) ?? asString(json["token"]) ?? "";
+    return deltaFrame(delta, lastEventId, serverRequestId);
+  }
+  if (event === "analysis_started") {
+    return analysisStartedFrame(asString(json["request_id"]), lastEventId, serverRequestId);
+  }
+  if (event === "analysis_complete") {
+    return analysisCompleteFrame({
+      resultId: asString(json["result_id"]),
+      analysisType: asString(json["analysis_type"]),
+      modelVersion: asString(json["model_version"]),
+      confidence: asNumber(json["confidence"]),
+      detections: asMapList(json["detections"]),
+      interpretation: asString(json["interpretation"]),
+      lastEventId
+    }, serverRequestId);
+  }
+  return unknownFrame(json, lastEventId, serverRequestId);
+}
+function asString(v) {
+  return typeof v === "string" ? v : null;
+}
+function asNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function asUrgency(v) {
+  return typeof v === "string" && URGENCY_LEVELS.includes(v) ? v : null;
+}
+function asStringList(v) {
+  if (!Array.isArray(v)) return [];
+  return v.map((e) => typeof e === "string" ? e : String(e));
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function asMapList(v) {
+  if (!Array.isArray(v)) return [];
+  return v.filter(isPlainObject);
+}
+
+// src/client/transport.ts
+var UNARY_TIMEOUT_MS = 3e4;
+var REQUEST_ID_HEADER = "x-request-id";
+async function* fetchByteSource(body) {
+  if (!body) return;
+  const reader = body.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value && value.length > 0) yield value;
+    }
+  } finally {
+    await reader.cancel?.();
+  }
+}
+async function* bufferedTextByteSource(text, splitAt = []) {
+  const bytes = new TextEncoder().encode(text);
+  const points = [...new Set(splitAt)].filter((n) => n > 0 && n < bytes.length).sort((a, b) => a - b);
+  let start = 0;
+  for (const point of points) {
+    yield bytes.subarray(start, point);
+    start = point;
+  }
+  yield bytes.subarray(start);
+}
+function eventSourceByteSource(es) {
+  const enc = new TextEncoder();
+  const queue = createByteQueue();
+  let cleaned = false;
+  const onMessage = (ev) => {
+    let block = "";
+    if (ev.lastEventId) block += `id: ${ev.lastEventId}
+`;
+    const data = ev.data ?? "";
+    for (const line of data.split("\n")) block += `data: ${line}
+`;
+    block += "\n";
+    queue.push(enc.encode(block));
+  };
+  const onDone = () => {
+    cleanup();
+    queue.end();
+  };
+  const onError = (ev) => {
+    const status = typeof ev.xhrStatus === "number" ? ev.xhrStatus : 0;
+    if (status >= 400) {
+      const wireCode = statusToWireCode(status);
+      const retryable = isAutoRetryable(fromWire(wireCode));
+      queue.push(enc.encode(`data: ${JSON.stringify({ type: "error", code: wireCode, retryable })}
+
+`));
+    }
+    cleanup();
+    queue.end();
+  };
+  es.addEventListener("message", onMessage);
+  es.addEventListener("done", onDone);
+  es.addEventListener("error", onError);
+  function cleanup() {
+    if (cleaned) return;
+    cleaned = true;
+    es.removeEventListener("message", onMessage);
+    es.removeEventListener("done", onDone);
+    es.removeEventListener("error", onError);
+    try {
+      es.close();
+    } catch {
+    }
+  }
+  return sourceWithCleanup(queue.source, cleanup);
+}
+async function* sourceWithCleanup(source, cleanup) {
+  try {
+    yield* source;
+  } finally {
+    cleanup();
+  }
+}
+function createByteQueue() {
+  const buffer = [];
+  let done = false;
+  let wake = null;
+  const signal = () => {
+    if (wake) {
+      const fn = wake;
+      wake = null;
+      fn();
+    }
+  };
+  async function* gen() {
+    for (; ; ) {
+      const next = buffer.shift();
+      if (next !== void 0) {
+        yield next;
+        continue;
+      }
+      if (done) return;
+      await new Promise((resolve) => {
+        wake = resolve;
+      });
+    }
+  }
+  return {
+    source: gen(),
+    push: (u) => {
+      buffer.push(u);
+      signal();
+    },
+    end: () => {
+      done = true;
+      signal();
+    }
+  };
+}
+async function requestJson(req, deps) {
+  const fetchImpl = deps.fetchImpl ?? getGlobalFetch();
+  const url = buildUrl(deps.config.apiBaseUrl, req.path, req.query);
+  const headers = mergeHeaders(deps.config, req.headers, "application/json", req.body !== void 0 && req.multipart === void 0);
+  const deadline = timeoutSignal(UNARY_TIMEOUT_MS);
+  const signal = mergeAbortSignals(deadline.signal, req.signal);
+  let res;
+  try {
+    res = await fetchImpl(url, buildInit({ ...req, signal }, headers));
+  } catch (cause) {
+    return err(networkError(cause));
+  } finally {
+    deadline.cancel();
+  }
+  const bodyJson = await safeJson(res);
+  if (!res.ok) return err(errorFromResponse(res.status, bodyJson, requestIdOf(res)));
+  return ok(bodyJson);
+}
+async function requestRaw(req, deps, byteSourceFor) {
+  const fetchImpl = deps.fetchImpl ?? getGlobalFetch();
+  const url = buildUrl(deps.config.apiBaseUrl, req.path, req.query);
+  const headers = mergeHeaders(deps.config, req.headers, "text/event-stream", req.body !== void 0 && req.multipart === void 0);
+  let res;
+  try {
+    res = await fetchImpl(url, buildInit(req, headers));
+  } catch (cause) {
+    return err(networkError(cause));
+  }
+  if (!res.ok) return err(errorFromResponse(res.status, await safeJson(res), requestIdOf(res)));
+  const bytes = byteSourceFor ? byteSourceFor(res) : fetchByteSource(res.body);
+  return ok({ ok: res.ok, status: res.status, headers: collectHeaders(res), bytes });
+}
+function createHttpTransport(deps) {
+  return {
+    request: (req) => requestJson(req, deps),
+    stream: (req, signal) => streamFrames(withSignal(req, signal), deps)
+  };
+}
+async function* streamFrames(req, deps) {
+  const url = buildUrl(deps.config.apiBaseUrl, req.path, req.query);
+  const headers = mergeHeaders(deps.config, req.headers, "text/event-stream", req.body !== void 0 && req.multipart === void 0);
+  if (deps.eventSourceFactory) {
+    const es = deps.eventSourceFactory(url, buildEventSourceInit(req, headers));
+    yield* parseSse(eventSourceByteSource(es), () => eventSourceRequestId(es));
+    return;
+  }
+  const fetchImpl = deps.fetchImpl ?? getGlobalFetch();
+  let res;
+  try {
+    res = await fetchImpl(url, buildInit(req, headers));
+  } catch (cause) {
+    yield syntheticErrorFrame("", true, describeCause(cause));
+    return;
+  }
+  const requestId = requestIdOf(res);
+  if (!res.ok) {
+    const body = await safeJson(res);
+    const wireCode = extractWireCode(body) ?? statusToWireCode(res.status);
+    const retryable = extractRetryable(body) || isAutoRetryable(fromWire(wireCode));
+    yield syntheticErrorFrame(wireCode, retryable, extractWireMessage(body), requestId);
+    return;
+  }
+  if (res.body) {
+    yield* parseSse(fetchByteSource(res.body), requestId);
+    return;
+  }
+  yield* parseSse(fetchByteSource(null), requestId);
+}
+function buildEventSourceInit(req, headers) {
+  return {
+    method: req.method,
+    headers,
+    pollingInterval: 0,
+    ...req.body !== void 0 ? { body: JSON.stringify(req.body) } : {}
+  };
+}
+function errorFromResponse(status, body, requestId) {
+  const wireCode = extractWireCode(body);
+  const code = wireCode ? fromWire(wireCode) : fromHttpStatus(status);
+  const wireMessage = extractWireMessage(body);
+  return makeEverfurError(code, {
+    httpStatus: status,
+    ...extractRetryable(body) ? { retryable: true } : {},
+    ...requestId ? { requestId } : {},
+    ...wireCode ? { wireCode } : {},
+    ...wireMessage ? { wireMessage } : {},
+    ...body !== null && body !== void 0 ? { raw: body } : {}
+  });
+}
+function networkError(cause) {
+  return makeEverfurError("internalError", { retryable: true, wireMessage: describeCause(cause) });
+}
+function requestIdOf(res) {
+  const value = res.headers.get(REQUEST_ID_HEADER);
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function eventSourceRequestId(es) {
+  if (typeof es.getResponseHeader !== "function") return null;
+  let value;
+  try {
+    value = es.getResponseHeader(REQUEST_ID_HEADER);
+  } catch {
+    return null;
+  }
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function statusToWireCode(status) {
+  if (status === 401) return "AUTH_EXPIRED";
+  if (status === 403) return "ACCESS_DENIED";
+  if (status === 404) return "NOT_FOUND";
+  if (status === 409) return "IDEMPOTENCY_CONFLICT";
+  if (status === 421) return "MISDIRECTED_REQUEST";
+  if (status === 429) return "RATE_LIMITED";
+  if (status === 400 || status === 422) return "INVALID_REQUEST";
+  if (status === 503) return "INTERNAL_ERROR";
+  if (status >= 500) return "INTERNAL_ERROR";
+  return "";
+}
+function syntheticErrorFrame(code, retryable, wireMessage, serverRequestId = null) {
+  return errorFrame({ code, retryable, wireMessage, synthesized: true, lastEventId: null, serverRequestId });
+}
+function getGlobalFetch() {
+  const candidate = globalThis.fetch;
+  if (typeof candidate !== "function") {
+    throw new EverfurConfigError(
+      "missing-peer-dependency",
+      "global fetch is unavailable; provide config.transport or an injected fetch implementation"
+    );
+  }
+  return candidate;
+}
+function buildUrl(base, path, query) {
+  const rel = path.startsWith("/") ? path : `/${path}`;
+  let url = `${base}${rel}`;
+  if (query) {
+    const qs = Object.entries(query).filter((entry) => entry[1] !== void 0).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+    if (qs) url += `?${qs}`;
+  }
+  return url;
+}
+function mergeHeaders(config, reqHeaders, accept, hasJsonBody) {
+  const headers = { ...buildBaseHeaders(config), accept };
+  if (hasJsonBody) headers["content-type"] = "application/json";
+  if (reqHeaders) Object.assign(headers, reqHeaders);
+  return headers;
+}
+function buildInit(req, headers) {
+  const init = { method: req.method, headers };
+  if (req.multipart !== void 0) init.body = req.multipart;
+  else if (req.body !== void 0) init.body = JSON.stringify(req.body);
+  if (req.signal) init.signal = req.signal;
+  return init;
+}
+function withSignal(req, signal) {
+  return req.signal ? req : { ...req, signal };
+}
+function timeoutSignal(ms) {
+  const ctrl = new AbortController();
+  const handle = setTimeout(() => ctrl.abort(), ms);
+  return {
+    signal: ctrl.signal,
+    cancel: () => clearTimeout(handle)
+  };
+}
+function mergeAbortSignals(deadline, caller) {
+  if (!caller) return deadline;
+  const ctrl = new AbortController();
+  if (deadline.aborted || caller.aborted) {
+    ctrl.abort();
+    return ctrl.signal;
+  }
+  const onAbort = () => ctrl.abort();
+  deadline.addEventListener("abort", onAbort, { once: true });
+  caller.addEventListener("abort", onAbort, { once: true });
+  return ctrl.signal;
+}
+async function safeJson(res) {
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+function collectHeaders(res) {
+  const out = {};
+  res.headers.forEach?.((value, key) => {
+    out[key.toLowerCase()] = value;
+  });
+  return out;
+}
+function extractWireCode(body) {
+  const b = body;
+  const code = b?.error?.code ?? b?.code;
+  return typeof code === "string" && code.length > 0 ? code : null;
+}
+function extractWireMessage(body) {
+  const b = body;
+  const message = b?.error?.message ?? b?.message;
+  return typeof message === "string" && message.length > 0 ? message : null;
+}
+function extractRetryable(body) {
+  const b = body;
+  return b?.error?.retryable === true || b?.retryable === true;
+}
+function describeCause(cause) {
+  if (cause instanceof Error) return cause.message;
+  return typeof cause === "string" ? cause : "network request failed";
+}
+
+// src/client/entitlements/resolve.ts
+function resolveEntitlements(levels) {
+  if (levels.length === 0) {
+    return freezeResolved({ granted: [], asGrant: { allow: [], deny: [] } });
+  }
+  let allowed = null;
+  const denied = /* @__PURE__ */ new Set();
+  for (const level of levels) {
+    const allow = new Set(level.allow);
+    allowed = allowed === null ? allow : intersect(allowed, allow);
+    for (const key of level.deny) denied.add(key);
+  }
+  const granted = [...allowed ?? /* @__PURE__ */ new Set()].filter((key) => !denied.has(key)).sort();
+  return freezeResolved({ granted, asGrant: { allow: granted, deny: [] } });
+}
+function intersect(a, b) {
+  const out = /* @__PURE__ */ new Set();
+  for (const key of a) if (b.has(key)) out.add(key);
+  return out;
+}
+function freezeResolved(r) {
+  return Object.freeze({
+    granted: Object.freeze([...r.granted]),
+    asGrant: Object.freeze({
+      allow: Object.freeze([...r.asGrant.allow]),
+      deny: Object.freeze([...r.asGrant.deny])
+    })
+  });
+}
+var REQUIRES = Object.freeze({
+  chat: Object.freeze(["chat.message.create"]),
+  records: Object.freeze(["records.upload.create", "records.record.read"]),
+  video: Object.freeze(["video.gait.execute"]),
+  photo: Object.freeze(["photo.checkup.execute"]),
+  animations: Object.freeze(["animations.state.read"])
+});
+function requires(name) {
+  return REQUIRES[name];
+}
+function deniedDecisionsFor(level, reason) {
+  const disabled = Object.freeze({ reason, level, recoverable: false });
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of Object.keys(REQUIRES)) {
+    for (const resource of REQUIRES[name]) {
+      if (seen.has(resource)) continue;
+      seen.add(resource);
+      rows.push(Object.freeze({ resource, granted: false, disabled }));
+    }
+  }
+  return Object.freeze(rows);
+}
+function decideCapability(name, decisions, opts) {
+  if (opts?.isPending === true) {
+    return freezeDecision({ name, enabled: false, isPending: true, limits: {} });
+  }
+  const keys = requires(name);
+  const byResource = /* @__PURE__ */ new Map();
+  for (const decision of decisions) byResource.set(decision.resource, decision);
+  const limits = mergeLimits(keys, byResource);
+  const missing = keys.filter((key) => byResource.get(key)?.granted !== true);
+  if (missing.length === 0) {
+    return freezeDecision({ name, enabled: true, isPending: false, limits });
+  }
+  return freezeDecision({
+    name,
+    enabled: false,
+    isPending: false,
+    limits,
+    disabled: disabledFor(keys, byResource)
+  });
+}
+function mergeLimits(keys, byResource) {
+  const out = {};
+  for (const key of keys) {
+    const decisionLimits = byResource.get(key)?.limits;
+    if (!decisionLimits) continue;
+    for (const [limitKey, limitValue] of Object.entries(decisionLimits)) {
+      const existing = out[limitKey];
+      out[limitKey] = existing === void 0 ? limitValue : Math.min(existing, limitValue);
+    }
+  }
+  return out;
+}
+function disabledFor(keys, byResource) {
+  for (const key of keys) {
+    const explicit = byResource.get(key)?.disabled;
+    if (explicit) {
+      return Object.freeze({
+        reason: explicit.reason,
+        level: explicit.level,
+        recoverable: explicit.recoverable
+      });
+    }
+  }
+  return Object.freeze({
+    reason: userFacingError("accessDenied"),
+    level: "user_entitlement",
+    recoverable: false
+  });
+}
+function freezeDecision(d) {
+  const base = {
+    name: d.name,
+    enabled: d.enabled,
+    isPending: d.isPending,
+    limits: Object.freeze({ ...d.limits })
+  };
+  if (d.disabled !== void 0) base.disabled = d.disabled;
+  return Object.freeze(base);
+}
+
+// src/client/funnel/requestFunnel.ts
+var FUNNEL_UNARY_TIMEOUT_MS = 3e4;
+var RETRY_OVERRIDE_MAX_MS = BACKOFF_CAP_MS * 2;
+var IDEMPOTENCY_HEADER = "idempotency-key";
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var NOOP_OBSERVER = Object.freeze({
+  onEvent() {
+  }
+});
+var defaultFunnelTimers = Object.freeze({
+  setTimeout: (handler, ms) => setTimeout(handler, ms),
+  clearTimeout: (handle) => clearTimeout(handle),
+  now: () => Date.now()
+});
+function createRequestFunnel(deps) {
+  const observer = deps.observer ?? NOOP_OBSERVER;
+  const timers = deps.timers ?? defaultFunnelTimers;
+  const rng = deps.rng ?? Math.random;
+  const sleep = deps.sleep ?? ((ms, signal) => delayAbortable(ms, timers, signal));
+  const ceiling = deps.maxAttempts ?? MAX_RETRY_ATTEMPTS;
+  const timeoutMs = deps.unaryTimeoutMs ?? FUNNEL_UNARY_TIMEOUT_MS;
+  const mintKey = deps.newIdempotencyKey ?? defaultIdempotencyKeyFactory();
+  const emit = (event) => {
+    try {
+      observer.onEvent(event);
+    } catch {
+    }
+  };
+  async function send(call, req, opts) {
+    const perCallMaxAttempts = opts?.maxAttempts;
+    const maxAttempts = Math.max(1, perCallMaxAttempts ?? ceiling);
+    const idempotent = opts?.idempotent ?? MUTATING_METHODS.has(req.method);
+    const idempotencyKey = idempotent ? mintKey() : null;
+    const base = assembleHeaders(req, idempotencyKey);
+    let attempt = 0;
+    for (; ; ) {
+      const stamp = (extra) => Object.freeze({
+        call,
+        method: req.method,
+        path: req.path,
+        attempt,
+        ...idempotencyKey ? { idempotencyKey } : {},
+        ...extra
+      });
+      emit(stamp({ phase: "attempt" }));
+      const deadline = boundedSignal(timeoutMs, timers);
+      const merged = mergeSignals(deadline.signal, req.signal);
+      let settled;
+      try {
+        settled = await authedSend({ ...base, signal: merged.signal }, deps.auth);
+      } catch (cause) {
+        settled = err(networkError(cause));
+      } finally {
+        merged.dispose();
+        deadline.cancel();
+      }
+      if (settled.ok) {
+        emit(stamp({ phase: "settled", ok: true, reason: "ok" }));
+        return settled;
+      }
+      const error = settled.error;
+      const decision = decideRetry(error, attempt, {
+        maxAttempts,
+        rng,
+        now: timers.now(),
+        aborted: req.signal?.aborted === true,
+        ...perCallMaxAttempts !== void 0 ? { perCallMaxAttempts } : {},
+        ...deps.errorPolicy !== void 0 ? { policy: deps.errorPolicy } : {}
+      });
+      const settledEvent = {
+        ok: false,
+        code: error.code,
+        reason: decision.reason,
+        ...error.httpStatus !== void 0 ? { httpStatus: error.httpStatus } : {},
+        ...error.requestId !== void 0 ? { requestId: error.requestId } : {}
+      };
+      if (!decision.retry) {
+        emit(stamp({ phase: "settled", ...settledEvent }));
+        return err(error);
+      }
+      emit(stamp({ phase: "retry", ...settledEvent, delayMs: decision.delayMs }));
+      await sleep(decision.delayMs, req.signal);
+      if (req.signal?.aborted === true) {
+        emit(stamp({ phase: "settled", ...settledEvent, reason: "aborted" }));
+        return err(error);
+      }
+      attempt += 1;
+    }
+  }
+  async function authorize(req) {
+    return withAuthHeaders(req, await resolveDeviceAuth(deps.auth));
+  }
+  async function* stream(call, req, signal) {
+    emit(
+      Object.freeze({
+        call,
+        phase: "stream.open",
+        method: req.method,
+        path: req.path,
+        attempt: 0
+      })
+    );
+    try {
+      yield* deps.auth.transport.stream(req, signal);
+    } catch {
+      yield errorFrame({
+        // The same wire spelling sse.ts synthesizes, so `fromWire` folds it to the retryable `internalError`
+        // like any other transport failure. wireMessage stays null: it is the SERVER's text, and a thrown
+        // host exception's `.message` is not that.
+        code: "internal_error",
+        retryable: true,
+        wireMessage: null,
+        synthesized: true,
+        lastEventId: null,
+        serverRequestId: null
+      });
+    }
+  }
+  return Object.freeze({ send, authorize, stream });
+}
+function assembleHeaders(req, idempotencyKey) {
+  const headers = {};
+  for (const [key, value] of Object.entries(req.headers ?? {})) {
+    if (key.toLowerCase() === IDEMPOTENCY_HEADER) continue;
+    headers[key] = value;
+  }
+  if (idempotencyKey !== null) headers["Idempotency-Key"] = idempotencyKey;
+  return { ...req, headers };
+}
+function defaultIdempotencyKeyFactory() {
+  let counter = 0;
+  return () => `efk_${Date.now().toString(36)}_${(counter++).toString(36)}_${Math.random().toString(36).slice(2, 12)}`;
+}
+var POLICY_MAX_ATTEMPTS_CAP = 10;
+function decideRetry(error, attempt, ctx) {
+  if (ctx.aborted) return { retry: false, reason: "aborted" };
+  const throttle = throttleKind(error);
+  if (throttle === "quota") {
+    return { retry: false, reason: "daily-quota-exhausted" };
+  }
+  if (throttle !== "burst" && !isAutoRetryable(error.code)) {
+    return { retry: false, reason: "terminal-code" };
+  }
+  const reason = throttle === "burst" ? "burst-throttle" : "retryable-code";
+  const policyVetoedRetry = () => {
+    if (ctx.policy === void 0) return false;
+    try {
+      return !ctx.policy.shouldRetry(error.code, attempt);
+    } catch {
+      return false;
+    }
+  };
+  if (policyVetoedRetry()) return { retry: false, reason: "terminal-code" };
+  const policyCeiling = () => {
+    if (ctx.policy === void 0) return null;
+    let raw;
+    try {
+      raw = ctx.policy.maxAttempts(error.code);
+    } catch {
+      return null;
+    }
+    if (typeof raw !== "number" || !Number.isFinite(raw)) return null;
+    return Math.max(1, Math.min(POLICY_MAX_ATTEMPTS_CAP, Math.floor(raw)));
+  };
+  const ceiling = ctx.perCallMaxAttempts ?? policyCeiling() ?? ctx.maxAttempts;
+  if (attempt + 1 >= ceiling) return { retry: false, reason: "attempts-exhausted" };
+  const override = retryOverrideMs(error, ctx.now);
+  if (override !== null) {
+    if (override > RETRY_OVERRIDE_MAX_MS) {
+      return { retry: false, reason: "server-reset-beyond-budget" };
+    }
+    return { retry: true, reason, delayMs: override };
+  }
+  return { retry: true, reason, delayMs: backoffDelayMs(attempt, ctx.rng) };
+}
+function throttleKind(error) {
+  const code = error.code === "unknown" ? fromWire(rawWireCode(error.raw)) : error.code;
+  if (code === "quotaExceeded") return "quota";
+  if (code === "rateLimited") return "burst";
+  if (error.httpStatus === 429) {
+    return "burst";
+  }
+  return null;
+}
+function retryOverrideMs(error, now) {
+  const at = findResetsAt(error.raw);
+  if (at === null) return null;
+  const delta = at - now;
+  return delta > 0 ? delta : 0;
+}
+function findResetsAt(raw) {
+  for (const scope of candidateScopes(raw)) {
+    const value = scope["resets_at"];
+    const parsed = parseInstantMs(value);
+    if (parsed !== null) return parsed;
+  }
+  return null;
+}
+function candidateScopes(raw) {
+  if (!isRecord(raw)) return [];
+  const out = [raw];
+  for (const nested of ["error", "detail"]) {
+    const value = raw[nested];
+    if (isRecord(value)) out.push(value);
+  }
+  return out;
+}
+function parseInstantMs(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value < 1e11 ? Math.round(value * 1e3) : Math.round(value);
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function rawWireCode(raw) {
+  for (const scope of candidateScopes(raw)) {
+    const code = scope["code"];
+    if (typeof code === "string" && code.length > 0) return code;
+  }
+  return null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+async function resolveDeviceAuth(auth) {
+  if (auth.mode === "anonymous") {
+    return {
+      mode: "anonymous",
+      publishableKey: auth.publishableKey,
+      userRef: auth.userRef,
+      ...auth.sessionId ? { sessionId: auth.sessionId } : {}
+    };
+  }
+  return {
+    mode: "personalized",
+    token: await auth.identity.currentToken(),
+    userRef: auth.userRef,
+    ...auth.sessionId ? { sessionId: auth.sessionId } : {}
+  };
+}
+function boundedSignal(ms, timers) {
+  const ctrl = new AbortController();
+  const handle = timers.setTimeout(() => ctrl.abort(), ms);
+  return { signal: ctrl.signal, cancel: () => timers.clearTimeout(handle) };
+}
+function mergeSignals(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/theme/tokens.ts
+function deepFreeze(value) {
+  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const key of Object.keys(value)) {
+      deepFreeze(value[key]);
+    }
+  }
+  return value;
+}
+var SPACE = { xs: 4, sm: 8, md: 12, lg: 16, xl: 24, xxl: 32 };
+var RADIUS = { tile: 5, xs: 6, sm: 10, md: 14, lg: 20, xl: 28, pill: 500 };
+var TYPE_SIZE = {
+  nano: 8,
+  small: 9,
+  micro: 10,
+  tiny: 11,
+  caption: 12,
+  bodyTight: 13,
+  body: 14,
+  subtitle: 16,
+  heading: 18,
+  verdict: 24
+};
+var LINE_HEIGHT = { tight: 1.15, snug: 1.3, normal: 1.4, relaxed: 1.55 };
+var WEIGHT = { regular: "400", medium: "500", bold: "700" };
+var LETTER_SPACING = {
+  eyebrow: 1,
+  monoWide: 0.9,
+  headerBrand: -0.42,
+  tight: -0.35
+};
+function baseType() {
+  return {
+    family: "System",
+    mono: "monospace",
+    fontUrl: null,
+    size: TYPE_SIZE,
+    lineHeight: LINE_HEIGHT,
+    weight: WEIGHT,
+    letterSpacing: LETTER_SPACING
+  };
+}
+var MOTION = {
+  duration: { instant: 80, fast: 140, normal: 220, slow: 320 },
+  spring: { gentle: { damping: 18, stiffness: 200 } },
+  easing: { standard: "cubic-bezier(0.4, 0, 0.2, 1)" },
+  reducedMotion: false
+};
+var LIGHT_COLOR = {
+  brand: "#10462E",
+  brandSoft: "rgba(16,70,46,0.10)",
+  brandSofter: "rgba(16,70,46,0.15)",
+  brandBorder: "rgba(16,70,46,0.18)",
+  borderHairlineGreen: "rgba(16,70,46,0.25)",
+  surface: "#FFFFFF",
+  surfaceCream: "#FDFBF8",
+  surfaceSubtle: "#EFE9E3",
+  background: "#FFFFFF",
+  borderRingCream: "#D8D2C8",
+  text: {
+    primary: "#111111",
+    secondary: "#0E462E",
+    muted: "#6E6660",
+    placeholder: "rgba(0,0,0,0.30)",
+    onBrand: "#FFFFFF",
+    metaCool: "#3D3D3D"
+  },
+  primary: "#10462E",
+  onPrimary: "#FFFFFF",
+  accent: "#10462E",
+  onAccent: "#FFFFFF",
+  accentEdge: "#07C168",
+  success: "#07C168",
+  danger: "#B91C1C",
+  errorRed: "#FF1B00",
+  warningStrong: "#A45610",
+  cautionAccent: "#D9821D",
+  riskConcern: "#EFA700",
+  badgeBgPositive: "rgba(7,193,104,0.12)",
+  badgeBgCaution: "rgba(217,130,29,0.14)",
+  badgeBgCritical: "rgba(185,28,28,0.12)",
+  badgeBgNeutral: "rgba(110,102,96,0.12)",
+  bubbleUser: "#10462E",
+  bubbleAssistant: "#FFFFFF",
+  skeleton: "#EFE9E3",
+  scanButtonPink: "#FFC3BC",
+  checkupCardLowRiskBg: "rgba(7,193,104,0.10)",
+  checkupCardConcernBg: "rgba(239,167,0,0.10)"
+};
+var EVERFUR_LIGHT = deepFreeze({
+  brightness: "light",
+  meta: { displayName: "Everfur", logoUrl: null, placeholder: null, hidePoweredBy: false },
+  color: LIGHT_COLOR,
+  space: SPACE,
+  radius: RADIUS,
+  type: baseType(),
+  motion: MOTION
+});
+var DARK_COLOR = {
+  brand: "#6BD39A",
+  brandSoft: "rgba(107,211,154,0.12)",
+  brandSofter: "rgba(107,211,154,0.18)",
+  brandBorder: "rgba(107,211,154,0.22)",
+  borderHairlineGreen: "rgba(107,211,154,0.28)",
+  surface: "#1C1F23",
+  surfaceCream: "#23272C",
+  surfaceSubtle: "#23272C",
+  background: "#15171A",
+  borderRingCream: "#3A3F45",
+  text: {
+    primary: "#F5F3F0",
+    secondary: "#A9E4C4",
+    muted: "#9A938C",
+    placeholder: "rgba(255,255,255,0.35)",
+    onBrand: "#0E1F17",
+    metaCool: "#C9C9C9"
+  },
+  primary: "#6BD39A",
+  onPrimary: "#0E1F17",
+  accent: "#6BD39A",
+  onAccent: "#0E1F17",
+  accentEdge: "#34D888",
+  success: "#07C168",
+  danger: "#B91C1C",
+  errorRed: "#FF1B00",
+  warningStrong: "#A45610",
+  cautionAccent: "#D9821D",
+  riskConcern: "#EFA700",
+  badgeBgPositive: "rgba(7,193,104,0.18)",
+  badgeBgCaution: "rgba(217,130,29,0.20)",
+  badgeBgCritical: "rgba(185,28,28,0.22)",
+  badgeBgNeutral: "rgba(255,255,255,0.10)",
+  bubbleUser: "#6BD39A",
+  bubbleAssistant: "#1C1F23",
+  skeleton: "#23272C",
+  scanButtonPink: "#FFC3BC",
+  checkupCardLowRiskBg: "rgba(7,193,104,0.16)",
+  checkupCardConcernBg: "rgba(239,167,0,0.16)"
+};
+var EVERFUR_DARK = deepFreeze({
+  brightness: "dark",
+  meta: { displayName: "Everfur", logoUrl: null, placeholder: null, hidePoweredBy: false },
+  color: DARK_COLOR,
+  space: SPACE,
+  radius: RADIUS,
+  type: baseType(),
+  motion: MOTION
+});
+
+// src/client/theme/resolve.ts
+function isEmptyBranding(b) {
+  return b.displayName === null && b.logoUrl === null && b.primaryColor === null && b.accentColor === null && b.brightness === null && b.fontFamily === null && b.fontUrl === null && b.placeholder === null && b.hidePoweredBy === null;
+}
+function parseClientBranding(json) {
+  if (json === null || typeof json !== "object") return null;
+  const raw = json;
+  const branding = {
+    displayName: parseNonEmptyString(pick(raw, "display_name", "displayName")),
+    logoUrl: parseNonEmptyString(pick(raw, "logo_url", "logoUrl")),
+    primaryColor: parseColor(pick(raw, "primary_color", "primaryColor")),
+    accentColor: parseColor(pick(raw, "accent_color", "accentColor")),
+    brightness: parseBrightness(pick(raw, "brightness")),
+    fontFamily: parseNonEmptyString(pick(raw, "font_family", "fontFamily")),
+    fontUrl: parseNonEmptyString(pick(raw, "font_url", "fontUrl")),
+    placeholder: parseNonEmptyString(pick(raw, "chat_placeholder", "placeholder", "chatPlaceholder")),
+    hidePoweredBy: parseBool(pick(raw, "hide_powered_by", "hidePoweredBy"))
+  };
+  return isEmptyBranding(branding) ? null : Object.freeze(branding);
+}
+function parseBool(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const lower = value.trim().toLowerCase();
+    if (lower === "true") return true;
+    if (lower === "false") return false;
+  }
+  return null;
+}
+function pick(raw, ...keys) {
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(raw, key)) {
+      const value = raw[key];
+      if (value !== void 0) return value;
+    }
+  }
+  return void 0;
+}
+function parseNonEmptyString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length === 0 ? null : trimmed;
+}
+function parseBrightness(value) {
+  if (typeof value !== "string") return null;
+  const lower = value.trim().toLowerCase();
+  return lower === "light" || lower === "dark" ? lower : null;
+}
+function parseColor(value) {
+  const rgba = toRgba(value);
+  return rgba === null ? null : normalizeRgba(rgba);
+}
+function toRgba(value) {
+  if (typeof value === "number") return argbIntToRgba(value);
+  if (typeof value !== "string") return null;
+  const s = value.trim();
+  if (s.length === 0) return null;
+  if (s.startsWith("#")) return fromHex(s.slice(1));
+  if (s.toLowerCase().startsWith("0x")) return fromArgbHex(s.slice(2));
+  if (s.toLowerCase().startsWith("rgb")) return fromRgbFunc(s);
+  if (/^[0-9a-fA-F]+$/.test(s)) {
+    const hex = fromHex(s);
+    if (hex !== null) return hex;
+  }
+  if (/^\d+$/.test(s)) return argbIntToRgba(Number.parseInt(s, 10));
+  return null;
+}
+function fromHex(hex) {
+  const h = hex.trim();
+  if (!/^[0-9a-fA-F]+$/.test(h)) return null;
+  if (h.length === 3) {
+    const r = dup(h[0]);
+    const g = dup(h[1]);
+    const b = dup(h[2]);
+    return { r, g, b, a: 1 };
+  }
+  if (h.length === 6) {
+    return { r: byte(h, 0), g: byte(h, 2), b: byte(h, 4), a: 1 };
+  }
+  if (h.length === 8) {
+    const a = byte(h, 0);
+    return { r: byte(h, 2), g: byte(h, 4), b: byte(h, 6), a: a / 255 };
+  }
+  return null;
+}
+function fromArgbHex(hex) {
+  return fromHex(hex);
+}
+function fromRgbFunc(input) {
+  const open = input.indexOf("(");
+  const close = input.indexOf(")");
+  if (open < 0 || close < 0 || close < open) return null;
+  const parts = input.slice(open + 1, close).split(",").map((p) => p.trim());
+  if (parts.length < 3) return null;
+  const r = clampByte(Number(parts[0]));
+  const g = clampByte(Number(parts[1]));
+  const b = clampByte(Number(parts[2]));
+  if (r === null || g === null || b === null) return null;
+  let a = 1;
+  if (parts.length >= 4) {
+    const alpha = Number(parts[3]);
+    if (!Number.isFinite(alpha)) return null;
+    a = Math.min(1, Math.max(0, alpha));
+  }
+  return { r, g, b, a };
+}
+function argbIntToRgba(n) {
+  if (!Number.isFinite(n)) return null;
+  const int = Math.trunc(n) >>> 0;
+  const a = int >>> 24 & 255;
+  return {
+    r: int >>> 16 & 255,
+    g: int >>> 8 & 255,
+    b: int & 255,
+    // A 0x00RRGGBB with no alpha byte reads as fully transparent; treat a zero alpha byte as opaque so a
+    // bare 0xRRGGBB (or small decimal) is not silently invisible.
+    a: a === 0 ? 1 : a / 255
+  };
+}
+function byte(hex, at) {
+  return Number.parseInt(hex.slice(at, at + 2), 16);
+}
+function dup(nibble) {
+  return Number.parseInt(`${nibble ?? "0"}${nibble ?? "0"}`, 16);
+}
+function clampByte(n) {
+  if (!Number.isFinite(n)) return null;
+  return Math.min(255, Math.max(0, Math.round(n)));
+}
+function normalizeRgba(rgba) {
+  if (rgba.a >= 1) {
+    return `#${hex2(rgba.r)}${hex2(rgba.g)}${hex2(rgba.b)}`.toUpperCase();
+  }
+  const a = Math.round(rgba.a * 1e3) / 1e3;
+  return `rgba(${rgba.r},${rgba.g},${rgba.b},${a})`;
+}
+function hex2(n) {
+  return n.toString(16).padStart(2, "0");
+}
+var NEAR_BLACK = "#111111";
+var WHITE = "#FFFFFF";
+function readableOn(background) {
+  const rgba = toRgba(background);
+  if (rgba === null) return WHITE;
+  const bg = relativeLuminance(rgba);
+  const black = relativeLuminance({ r: 17, g: 17, b: 17});
+  const white = relativeLuminance({ r: 255, g: 255, b: 255});
+  const contrastBlack = contrastRatio(bg, black);
+  const contrastWhite = contrastRatio(bg, white);
+  return contrastWhite >= contrastBlack ? WHITE : NEAR_BLACK;
+}
+function relativeLuminance(rgba) {
+  const r = linearize(rgba.r / 255);
+  const g = linearize(rgba.g / 255);
+  const b = linearize(rgba.b / 255);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function linearize(channel) {
+  return channel <= 0.03928 ? channel / 12.92 : Math.pow((channel + 0.055) / 1.055, 2.4);
+}
+function contrastRatio(l1, l2) {
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function hardenHttpsUrl(url) {
+  if (url === null) return null;
+  const trimmed = url.trim();
+  if (trimmed.length === 0) return null;
+  return /^https:\/\/\S+$/i.test(trimmed) ? trimmed : null;
+}
+function withServerBranding(base, b) {
+  if (b === null || isEmptyBranding(b)) return base;
+  const palette = b.brightness !== null && b.brightness !== base.brightness ? b.brightness === "dark" ? EVERFUR_DARK : EVERFUR_LIGHT : base;
+  const primary = b.primaryColor ?? palette.color.primary;
+  const accent = b.accentColor ?? palette.color.accent;
+  const pr = b.primaryColor !== null ? toRgba(primary) : null;
+  const lift = (c) => Math.round(c + (255 - c) * 0.4);
+  const brandFamily = pr !== null ? {
+    brand: primary,
+    bubbleUser: primary,
+    text: { ...palette.color.text, secondary: primary },
+    brandSoft: `rgba(${pr.r}, ${pr.g}, ${pr.b}, 0.10)`,
+    brandSofter: `rgba(${pr.r}, ${pr.g}, ${pr.b}, 0.15)`,
+    brandBorder: `rgba(${pr.r}, ${pr.g}, ${pr.b}, 0.20)`,
+    borderHairlineGreen: `rgba(${pr.r}, ${pr.g}, ${pr.b}, 0.28)`,
+    accentEdge: `rgb(${lift(pr.r)}, ${lift(pr.g)}, ${lift(pr.b)})`
+  } : {};
+  const next = {
+    brightness: palette.brightness,
+    meta: {
+      displayName: b.displayName ?? palette.meta.displayName,
+      logoUrl: b.logoUrl ?? palette.meta.logoUrl,
+      placeholder: b.placeholder ?? palette.meta.placeholder,
+      hidePoweredBy: b.hidePoweredBy ?? palette.meta.hidePoweredBy
+    },
+    color: {
+      ...palette.color,
+      ...brandFamily,
+      primary,
+      accent,
+      // onPrimary/onAccent are recomputed by resolveTheme; carry the palette defaults for a standalone call.
+      onPrimary: palette.color.onPrimary,
+      onAccent: palette.color.onAccent
+    },
+    space: palette.space,
+    radius: palette.radius,
+    type: {
+      ...palette.type,
+      family: b.fontFamily ?? palette.type.family,
+      fontUrl: b.fontUrl ?? palette.type.fontUrl
+    },
+    motion: palette.motion
+  };
+  return deepFreeze(next);
+}
+var DEFAULT_DISPLAY_NAME = "Everfur";
+function resolveTheme(input) {
+  const scheme = input?.colorScheme === "dark" ? "dark" : "light";
+  const systemBase = scheme === "dark" ? EVERFUR_DARK : EVERFUR_LIGHT;
+  const withClient = withServerBranding(systemBase, input?.clientOverride ?? null);
+  const merged = withServerBranding(withClient, input?.branding ?? null);
+  return finalize(merged, input?.reducedMotion === true);
+}
+function finalize(theme, reducedMotion) {
+  const primary = theme.color.primary;
+  const accent = theme.color.accent;
+  const displayName = theme.meta.displayName.trim().length === 0 ? DEFAULT_DISPLAY_NAME : theme.meta.displayName;
+  const logoUrl = hardenHttpsUrl(theme.meta.logoUrl);
+  const fontUrl = hardenHttpsUrl(theme.type.fontUrl);
+  const motion = reducedMotion ? {
+    duration: { instant: 0, fast: 0, normal: 0, slow: 0 },
+    // Stiffen the spring so it settles immediately with no perceptible bounce.
+    spring: { gentle: { damping: 100, stiffness: 1e3 } },
+    easing: theme.motion.easing,
+    reducedMotion: true
+  } : theme.motion;
+  const finalized = {
+    brightness: theme.brightness,
+    meta: { displayName, logoUrl, placeholder: theme.meta.placeholder, hidePoweredBy: theme.meta.hidePoweredBy },
+    color: {
+      ...theme.color,
+      primary,
+      accent,
+      onPrimary: readableOn(primary),
+      onAccent: readableOn(accent)
+    },
+    space: theme.space,
+    radius: theme.radius,
+    type: { ...theme.type, fontUrl },
+    motion
+  };
+  return deepFreeze(finalized);
+}
+
+// src/client/entitlements/entitlementRepository.ts
+var ENTITLEMENTS_PATH = "/widget/v1/entitlements";
+var HTTP_NOT_MODIFIED = 304;
+var NOT_MODIFIED = Object.freeze({ kind: "notModified" });
+async function fetchEntitlements(auth, args = {}, funnel = createRequestFunnel({ auth })) {
+  const result = await funnel.send(
+    "entitlements.fetch",
+    buildRequest(args)
+  );
+  if (!result.ok) {
+    if (result.error.httpStatus === HTTP_NOT_MODIFIED) return NOT_MODIFIED;
+    return { kind: "failed", error: result.error };
+  }
+  return parseUpdated(result.value);
+}
+var REGION_MAX = 64;
+function buildRequest(args) {
+  const headers = {};
+  if (isFiniteNumber(args.cachedRevision)) {
+    headers["if-none-match"] = `"${args.cachedRevision}"`;
+  }
+  if (args.region && args.region.length <= REGION_MAX) {
+    return { method: "GET", path: ENTITLEMENTS_PATH, headers, query: { region: args.region } };
+  }
+  return { method: "GET", path: ENTITLEMENTS_PATH, headers };
+}
+function parseUpdated(body) {
+  if (body === null || typeof body !== "object") return malformed();
+  if (!isFiniteNumber(body.revision)) return malformed();
+  const region = typeof body.region === "string" ? body.region : "";
+  const ttlSeconds = isFiniteNumber(body.ttl_seconds) ? body.ttl_seconds : 0;
+  return Object.freeze({
+    kind: "updated",
+    revision: body.revision,
+    region,
+    ttlSeconds,
+    decisions: mapCapabilities(body.capabilities),
+    // Branding is ADDITIVE and orthogonal to capabilities: a parse fault here NEVER affects the decisions and
+    // fails closed to null (the compiled default theme). It cannot make a granted capability un-render.
+    branding: parseBranding(body)
+  });
+}
+function parseBranding(body) {
+  const direct = parseClientBranding(body.branding);
+  if (direct !== null) return direct;
+  const hints = body.render_hints;
+  if (hints !== null && typeof hints === "object") {
+    const nested = parseClientBranding(hints.branding);
+    if (nested !== null) return nested;
+    return parseClientBranding(hints);
+  }
+  return null;
+}
+function mapCapabilities(capabilities) {
+  if (capabilities === null || typeof capabilities !== "object") return Object.freeze([]);
+  const out = [];
+  for (const [resource, value] of Object.entries(capabilities)) {
+    if (isEnabled(value)) out.push(Object.freeze({ resource, granted: true }));
+  }
+  return Object.freeze(out);
+}
+function isEnabled(value) {
+  return typeof value === "object" && value !== null && value.enabled === true;
+}
+function malformed() {
+  return {
+    kind: "failed",
+    error: makeEverfurError("internalError", {
+      retryable: true,
+      wireMessage: "malformed entitlements response"
+    })
+  };
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+// src/client/pets/petsRepository.ts
+var PET_NAME_MAX = 100;
+var PET_SPECIES_MAX = 50;
+var PET_BREED_MAX = 100;
+var PET_AGE_YEARS_MAX = 50;
+var PET_WEIGHT_KG_MAX = 500;
+var PET_REF_MAX = 128;
+function invalid(wireMessage) {
+  return makeEverfurError("validationFailed", { retryable: false, wireMessage });
+}
+function checkString(field, value, max) {
+  if (typeof value !== "string") return invalid(`${field} must be a string`);
+  const length = serverLength(value);
+  if (length <= max) return null;
+  return invalid(`${field} is ${length} characters; the server accepts at most ${max}`);
+}
+function outOfRange(field, value, max) {
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= max) return null;
+  return invalid(`${field} must be a finite number between 0 and ${max}`);
+}
+function validate(petRef2, profile) {
+  if (typeof petRef2 !== "string") return invalid("pet_ref must be a string");
+  if (petRef2.trim().length === 0) return invalid("pet_ref must not be blank");
+  if (hasLoneSurrogate(petRef2)) return invalid("pet_ref contains an unpaired surrogate and cannot be encoded");
+  if (profile !== void 0 && profile !== null && typeof profile !== "object") {
+    return invalid("profile must be an object");
+  }
+  const checks = [checkString("pet_ref", petRef2, PET_REF_MAX)];
+  if (profile?.name !== void 0) checks.push(checkString("name", profile.name, PET_NAME_MAX));
+  if (profile?.species !== void 0) checks.push(checkString("species", profile.species, PET_SPECIES_MAX));
+  if (profile?.breed !== void 0) checks.push(checkString("breed", profile.breed, PET_BREED_MAX));
+  if (profile?.ageYears !== void 0) checks.push(outOfRange("age_years", profile.ageYears, PET_AGE_YEARS_MAX));
+  if (profile?.weightKg !== void 0) checks.push(outOfRange("weight_kg", profile.weightKg, PET_WEIGHT_KG_MAX));
+  return checks.find((c) => c !== null) ?? null;
+}
+function toWire(profile) {
+  if (profile === void 0 || profile === null) return {};
+  return {
+    ...profile.name !== void 0 ? { name: profile.name } : {},
+    ...profile.species !== void 0 ? { species: profile.species } : {},
+    ...profile.breed !== void 0 ? { breed: profile.breed } : {},
+    ...profile.ageYears !== void 0 ? { age_years: profile.ageYears } : {},
+    ...profile.weightKg !== void 0 ? { weight_kg: profile.weightKg } : {}
+  };
+}
+function fromWire2(raw, petRef2) {
+  const o = typeof raw === "object" && raw !== null ? raw : {};
+  const str = (v) => typeof v === "string" ? v : null;
+  const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+  return Object.freeze({
+    petRef: str(o["pet_ref"]) ?? petRef2,
+    name: str(o["name"]),
+    species: str(o["species"]),
+    breed: str(o["breed"]),
+    ageYears: num(o["age_years"]),
+    weightKg: num(o["weight_kg"])
+  });
+}
+function createPetsRepository(auth) {
+  return createPetsRepositoryOver(createRequestFunnel({ auth }));
+}
+function createPetsRepositoryOver(funnel) {
+  return {
+    async registerPet(petRef2, profile, opts) {
+      const invalid2 = validate(petRef2, profile);
+      if (invalid2 !== null) return err(invalid2);
+      const path = `/widget/v1/pets/${encodeURIComponent(petRef2)}`;
+      const base = { method: "POST", path, body: toWire(profile) };
+      const res = await funnel.send(
+        "pets.registerPet",
+        opts?.signal ? { ...base, signal: opts.signal } : base
+      );
+      if (!res.ok) return err(res.error);
+      return ok(fromWire2(res.value, petRef2));
+    }
+  };
+}
+
+export { AUTO_RETRYABLE_CODES, BACKOFF_BASE_MS, BACKOFF_CAP_MS, CONTRACT_ERROR_ROWS, DEFAULT_CONTRACT_VERSION, DOC_SITE_ORIGIN, EMPTY_FRAME_ARRAYS, ENTITLEMENTS_PATH, ENV_API_BASE_URL, EVERFUR_DARK, EVERFUR_ERROR_CATEGORIES, EVERFUR_ERROR_CODES, EVERFUR_LIGHT, EverfurConfigError, EverfurThrownError, MAX_RETRY_ATTEMPTS, PET_AGE_YEARS_MAX, PET_BREED_MAX, PET_NAME_MAX, PET_SPECIES_MAX, PET_WEIGHT_KG_MAX, RETRYABLE_CONTRACT_CODES, SDK_PLATFORM, SDK_VERSION, acceptedFrame, analysisCompleteFrame, analysisStartedFrame, assertNever, authHeaders, authedSend, backoffDelayMs, bufferedTextByteSource, buildBaseHeaders, canRecreateOnNotFound, categoryFor, checkPublishableKey, contractDocUrl, contractErrorFor, conversationId, createHttpTransport, createIdentityProvider, createPetsRepository, decideCapability, deepFreeze, deltaFrame, deniedDecisionsFor, doneFrame, err, errorFrame, errorFromResponse, eventSourceByteSource, eventSourceRequestId, fetchByteSource, fetchEntitlements, fromHttpStatus, fromWire, getGlobalFetch, hardenHttpsUrl, heartbeatFrame, isAutoRetryable, isEmptyBranding, isErr, isOk, isRetryableCode, makeEverfurError, networkError, newSessionId, ok, parseClientBranding, parseColor, parseSse, petRef, publishedDocUrl, readableOn, requestIdOf, requestJson, requestRaw, requires, resolveApiBaseUrl, resolveClientConfig, resolveEntitlements, resolveTheme, shouldRetry, tryResolveApiBaseUrl, tryResolveClientConfig, unknownFrame, unsafeClientId, unsafeConversationId, unsafeDocumentId, unsafeJobId, unsafePetRef, unsafeRecordsRequestId, unsafeResponseId, unsafeUserRef, unwrap, userFacingError, userRef, withAuthHeaders, withServerBranding };