@everfur/sdk 0.1.0

package/dist/core/index.cjs

@@ -0,0 +1,3175 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/client/errors/EverfurResult.ts
+function ok(value, warning) {
+  return Object.freeze(
+    { ok: true, value } 
+  );
+}
+function err(error) {
+  return Object.freeze({ ok: false, error });
+}
+var EverfurConfigError = class _EverfurConfigError extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.name = "EverfurConfigError";
+    this.kind = kind;
+    Object.setPrototypeOf(this, _EverfurConfigError.prototype);
+  }
+};
+
+// src/core/ports/SecureStorePort.ts
+var NULL_SECURE_STORE = Object.freeze({
+  isAvailable: false,
+  async getSecret() {
+    return null;
+  },
+  async setSecret() {
+    throw new EverfurConfigError(
+      "not-initialized",
+      "EF_NO_SECURE_STORE: token persistence requires an explicit SecureStorePort"
+    );
+  },
+  async deleteSecret() {
+  }
+});
+
+// src/core/ports/TelemetryPort.ts
+var noopTelemetry = Object.freeze({
+  track() {
+  },
+  trackExpectedFailure() {
+  }
+});
+var CONTRACT_RETRYABILITY = Object.freeze([
+  Object.freeze({ wireCode: "AccessDeniedException", envelope: "http_envelope", httpStatus: 403, retryable: false }),
+  Object.freeze({ wireCode: "AuthorizationException", envelope: "http_envelope", httpStatus: 401, retryable: false }),
+  Object.freeze({ wireCode: "ConflictException", envelope: "http_envelope", httpStatus: 409, retryable: true }),
+  Object.freeze({ wireCode: "DAILY_QUOTA_EXCEEDED", envelope: "http_envelope", httpStatus: 429, retryable: true }),
+  Object.freeze({ wireCode: "IDEMPOTENCY_KEY_IN_FLIGHT", envelope: "http_envelope", httpStatus: 409, retryable: true }),
+  Object.freeze({ wireCode: "IDEMPOTENCY_KEY_REUSED_DIFFERENT_REQUEST", envelope: "http_envelope", httpStatus: 409, retryable: false }),
+  Object.freeze({ wireCode: "InternalFailureException", envelope: "http_envelope", httpStatus: 500, retryable: true }),
+  Object.freeze({ wireCode: "NotImplementedException", envelope: "http_envelope", httpStatus: 501, retryable: false }),
+  Object.freeze({ wireCode: "PaymentRequiredException", envelope: "http_envelope", httpStatus: 402, retryable: false }),
+  Object.freeze({ wireCode: "ResourceNotFoundException", envelope: "http_envelope", httpStatus: 404, retryable: false }),
+  Object.freeze({ wireCode: "ServiceUnavailableException", envelope: "http_envelope", httpStatus: 503, retryable: true }),
+  Object.freeze({ wireCode: "TIER_UPGRADE_REQUIRED", envelope: "http_envelope", httpStatus: 402, retryable: false }),
+  Object.freeze({ wireCode: "ThrottlingException", envelope: "http_envelope", httpStatus: 429, retryable: true }),
+  Object.freeze({ wireCode: "ValidationException", envelope: "http_envelope", httpStatus: 400, retryable: false }),
+  Object.freeze({ wireCode: "accessDenied", envelope: "http_envelope", httpStatus: 403, retryable: false }),
+  Object.freeze({ wireCode: "authExpired", envelope: "http_envelope", httpStatus: 401, retryable: true }),
+  Object.freeze({ wireCode: "internal_error", envelope: "sse_frame", httpStatus: 200, retryable: false }),
+  Object.freeze({ wireCode: "invalidRequest", envelope: "http_envelope", httpStatus: 400, retryable: false }),
+  Object.freeze({ wireCode: "not_found", envelope: "sse_frame", httpStatus: 200, retryable: false }),
+  Object.freeze({ wireCode: "session_required", envelope: "http_envelope", httpStatus: 403, retryable: false }),
+  Object.freeze({ wireCode: "timeout", envelope: "sse_frame", httpStatus: 200, retryable: true }),
+  Object.freeze({ wireCode: "unavailable", envelope: "http_envelope", httpStatus: 503, retryable: true })
+]);
+Object.freeze(
+  CONTRACT_RETRYABILITY.map((row) => row.wireCode)
+);
+
+// src/client/errors/contract.ts
+var NORMALIZED_FOLD = Object.freeze({
+  // the default status-mapped envelope
+  ValidationException: "validationFailed",
+  AuthorizationException: "authRejected",
+  PaymentRequiredException: "paymentRequired",
+  AccessDeniedException: "accessDenied",
+  ResourceNotFoundException: "resourceNotFound",
+  ConflictException: "conflict",
+  ThrottlingException: "rateLimited",
+  InternalFailureException: "internalError",
+  NotImplementedException: "notImplemented",
+  ServiceUnavailableException: "serviceUnavailable",
+  // dict-detail codes on the widget surface
+  authExpired: "authExpired",
+  unavailable: "serviceUnavailable",
+  session_required: "sessionRequired",
+  accessDenied: "accessDenied",
+  invalidRequest: "sdkUpdateRequired",
+  // typed codes
+  IDEMPOTENCY_KEY_IN_FLIGHT: "idempotencyInFlight",
+  IDEMPOTENCY_KEY_REUSED_DIFFERENT_REQUEST: "idempotencyConflict",
+  DAILY_QUOTA_EXCEEDED: "quotaExceeded",
+  TIER_UPGRADE_REQUIRED: "paymentRequired",
+  // SSE error frames
+  not_found: "conversationNotFound",
+  timeout: "streamTimeout",
+  internal_error: "internalError"
+});
+var CONTRACT_ERROR_ROWS = Object.freeze(
+  CONTRACT_RETRYABILITY.map(
+    (generated) => Object.freeze({
+      wireCode: generated.wireCode,
+      envelope: generated.envelope,
+      retryable: generated.retryable,
+      normalized: NORMALIZED_FOLD[generated.wireCode]
+    })
+  )
+);
+var BY_UPPER = new Map(
+  CONTRACT_ERROR_ROWS.map((r) => [r.wireCode.toUpperCase(), r])
+);
+function contractErrorFor(wireCode) {
+  if (typeof wireCode !== "string") return void 0;
+  const key = wireCode.trim().toUpperCase();
+  return key.length > 0 ? BY_UPPER.get(key) : void 0;
+}
+var CATEGORY_OF = Object.freeze({
+  // the caller's sign-in state is wrong and a credential change is the remedy
+  authExpired: "authentication",
+  authRejected: "authentication",
+  sessionRequired: "authentication",
+  // signed in, correctly identified, and still not allowed
+  accessDenied: "authorization",
+  // a plan gate, not a permission failure: the remedy is commercial
+  paymentRequired: "entitlement",
+  // slow down / come back later
+  quotaExceeded: "rateLimit",
+  rateLimited: "rateLimit",
+  // the request itself was wrong; retrying it unchanged can never succeed
+  validationFailed: "invalidRequest",
+  sdkUpdateRequired: "invalidRequest",
+  // the target is gone, hidden, or was never visible to this caller
+  conversationNotFound: "notFound",
+  petNotFound: "notFound",
+  resourceNotFound: "notFound",
+  // something else already holds the thing
+  conflict: "conflict",
+  idempotencyConflict: "conflict",
+  idempotencyInFlight: "conflict",
+  // the pipe, not the request: timeouts, drops, a briefly unreachable dependency
+  streamTimeout: "connection",
+  streamIncomplete: "connection",
+  upstreamLlmTimeout: "connection",
+  serviceUnavailable: "connection",
+  // the server admits fault
+  internalError: "server",
+  notImplemented: "server",
+  mediaUploadFailed: "media",
+  moderationBlocked: "policy",
+  unknown: "unknown"
+});
+function categoryFor(code) {
+  return CATEGORY_OF[code];
+}
+function fromWire(wire) {
+  const contractRow = contractErrorFor(wire);
+  if (contractRow) return contractRow.normalized;
+  const upper = (wire ?? "").trim().toUpperCase();
+  const canonical = upper.replace(/[^A-Z0-9]/g, "");
+  if (canonical === "AUTHREJECTED") return "authRejected";
+  if (upper.startsWith("AUTH")) return "authExpired";
+  switch (canonical) {
+    case "DAILYQUOTAEXCEEDED":
+    case "QUOTAEXCEEDED":
+      return "quotaExceeded";
+    case "RATELIMITED":
+    case "TOOMANYREQUESTS":
+      return "rateLimited";
+    case "IDEMPOTENCYKEYCONFLICT":
+    case "IDEMPOTENCYCONFLICT":
+      return "idempotencyConflict";
+    case "ACCESSDENIED":
+    case "FORBIDDEN":
+      return "accessDenied";
+    case "NOTFOUND":
+    case "CONVERSATIONNOTFOUND":
+      return "conversationNotFound";
+    case "PETNOTFOUND":
+      return "petNotFound";
+    case "TIMEOUT":
+    case "STREAMTIMEOUT":
+      return "streamTimeout";
+    // Analysis-domain deterministic 400s (NON-retryable). Additive per SPEC-00 §3.1 / SPEC-11b §2.6:
+    // fold to a NON-retried target so the SDK never retries a permanently-failing bad-input request.
+    // (Comment above the group so the empty fall-through cases stay lint-clean under no-fallthrough.)
+    case "MEDIAUPLOADFAILED":
+    case "UNRECOGNIZEDVIDEOFORMAT":
+    case "FILETOOSMALL":
+      return "mediaUploadFailed";
+    case "MODERATIONBLOCKED":
+      return "moderationBlocked";
+    case "UPSTREAMLLMTIMEOUT":
+      return "upstreamLlmTimeout";
+    case "INTERNALERROR":
+    case "INTERNALSERVERERROR":
+      return "internalError";
+    case "STREAMINCOMPLETE":
+    case "CHATSTREAMINCOMPLETE":
+      return "streamIncomplete";
+    // Deterministic 400s that can only come from an SDK bug -> unknown (NON-retryable). NEVER internalError
+    // (which IS auto-retried): mapping a bad-input 400 to a retryable code retries a request that never succeeds.
+    case "INVALIDANALYSISTYPE":
+    case "INVALIDUPLOADPURPOSE":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+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/core/ports/ErrorPolicyPort.ts
+var defaultErrorPolicy = Object.freeze({
+  shouldRetry(code, attempt) {
+    return isAutoRetryable(code) && attempt < MAX_RETRY_ATTEMPTS;
+  },
+  maxAttempts() {
+    return MAX_RETRY_ATTEMPTS;
+  }
+});
+
+// src/core/ports/CameraPort.ts
+var unavailableCamera = Object.freeze({
+  isAvailable: false,
+  async capture() {
+    return Promise.reject(
+      new Error("CameraPort is unavailable; check isAvailable before calling capture")
+    );
+  }
+});
+
+// src/core/ports/optionalModule.ts
+function optionalModule(name, load, validate2) {
+  let candidate;
+  try {
+    candidate = load();
+  } catch (cause) {
+    return frozenUnavailable(`optional peer '${name}' is not installed: ${describe(cause)}`);
+  }
+  const resolved = unwrapDefault(candidate);
+  if (resolved === null || resolved === void 0) {
+    return frozenUnavailable(`optional peer '${name}' resolved to no module`);
+  }
+  if (validate2 && !validate2(resolved)) {
+    return frozenUnavailable(`optional peer '${name}' is present but failed its shape check`);
+  }
+  return Object.freeze({ available: true, module: resolved });
+}
+function unwrapDefault(candidate) {
+  if (typeof candidate === "object" && candidate !== null && "default" in candidate && Object.keys(candidate).length <= 2) {
+    return candidate.default;
+  }
+  return candidate;
+}
+function frozenUnavailable(reason) {
+  return Object.freeze({ available: false, module: null, reason });
+}
+function describe(cause) {
+  if (cause instanceof Error) return cause.message;
+  return typeof cause === "string" ? cause : "unknown load error";
+}
+
+// src/client/protocol/frames.ts
+function assertNever(x) {
+  throw new Error(
+    `assertNever: unhandled discriminated-union member ${JSON.stringify(x)}`
+  );
+}
+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
+  });
+}
+
+// src/client/errors/EverfurError.ts
+var USER_FACING_COPY = Object.freeze({
+  authExpired: "Please sign in again to continue.",
+  authRejected: "Please sign in again to continue.",
+  sessionRequired: "This app needs to be updated to keep using Everfur.",
+  accessDenied: "This feature isn't available on your account right now.",
+  paymentRequired: "This is part of a paid plan.",
+  quotaExceeded: "You have used today's messages. This resets tomorrow.",
+  rateLimited: "You are sending messages quickly. Try again in a few seconds.",
+  validationFailed: "Something in that request was not right. Check the details and try again.",
+  sdkUpdateRequired: "This app needs to be updated to keep using Everfur.",
+  conflict: "That is already running. Wait for it to finish, then try again.",
+  idempotencyConflict: "That message was already delivered.",
+  idempotencyInFlight: "That is still processing. Give it a moment.",
+  conversationNotFound: "This conversation is no longer available.",
+  petNotFound: "We could not find that pet. Please pick a pet and try again.",
+  resourceNotFound: "We could not find that.",
+  streamTimeout: "The response timed out. Tap retry to try again.",
+  mediaUploadFailed: "We could not upload that photo. Please attach it again.",
+  moderationBlocked: "This request cannot be answered here.",
+  upstreamLlmTimeout: "The response timed out. Tap retry to try again.",
+  internalError: "We hit a snag on our end. Please try again.",
+  notImplemented: "That is not available yet.",
+  serviceUnavailable: "That service is briefly unavailable. Try again shortly.",
+  streamIncomplete: "The connection dropped mid-answer. Tap retry to continue.",
+  unknown: "Something went wrong. Please try again."
+});
+function userFacingError(code) {
+  return USER_FACING_COPY[code];
+}
+function defineHidden(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+}
+function makeEverfurError(code, opts) {
+  contractErrorFor(opts?.wireCode);
+  const error = {
+    code,
+    category: categoryFor(code),
+    retryable: opts?.retryable ?? isRetryableCode(code),
+    displayMessage: userFacingError(code)
+  };
+  if (opts?.httpStatus !== void 0) error.httpStatus = opts.httpStatus;
+  if (opts?.requestId) error.requestId = opts.requestId;
+  if (opts?.wireMessage) defineHidden(error, "wireMessage", opts.wireMessage);
+  if (opts?.raw !== void 0 && opts.raw !== null) defineHidden(error, "raw", opts.raw);
+  return Object.freeze(error);
+}
+
+// src/client/identity.ts
+function createIdentityProvider(userRef, 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,
+    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 } : {}
+  });
+}
+var BLOCK_SEPARATOR = "\n\n";
+var MAX_PENDING_BLOCK_CHARS = 1048576;
+var wireObjectSchema = zod.z.record(zod.z.string(), zod.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/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 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 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/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?.();
+  }
+}
+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 deadline2 = timeoutSignal(UNARY_TIMEOUT_MS);
+  const signal = mergeAbortSignals(deadline2.signal, req.signal);
+  let res;
+  try {
+    res = await fetchImpl(url, buildInit({ ...req, signal }, headers));
+  } catch (cause) {
+    return err(networkError(cause));
+  } finally {
+    deadline2.cancel();
+  }
+  const bodyJson = await safeJson(res);
+  if (!res.ok) return err(errorFromResponse(res.status, bodyJson, requestIdOf(res)));
+  return ok(bodyJson);
+}
+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(deadline2, caller) {
+  if (!caller) return deadline2;
+  const ctrl = new AbortController();
+  if (deadline2.aborted || caller.aborted) {
+    ctrl.abort();
+    return ctrl.signal;
+  }
+  const onAbort = () => ctrl.abort();
+  deadline2.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 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/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 deadline2 = boundedSignal(timeoutMs, timers);
+      const merged = mergeSignals(deadline2.signal, req.signal);
+      let settled;
+      try {
+        settled = await authedSend({ ...base, signal: merged.signal }, deps.auth);
+      } catch (cause) {
+        settled = err(networkError(cause));
+      } finally {
+        merged.dispose();
+        deadline2.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(deadline2, caller) {
+  const noop = () => void 0;
+  if (!caller) return { signal: deadline2, dispose: noop };
+  const ctrl = new AbortController();
+  if (deadline2.aborted || caller.aborted) {
+    ctrl.abort();
+    return { signal: ctrl.signal, dispose: noop };
+  }
+  const onAbort = () => ctrl.abort();
+  deadline2.addEventListener("abort", onAbort, { once: true });
+  caller.addEventListener("abort", onAbort, { once: true });
+  return {
+    signal: ctrl.signal,
+    dispose: () => {
+      deadline2.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;
+}
+function serverLength(value) {
+  return [...value].length;
+}
+
+// src/core/media/ports.ts
+var unavailableUpload = Object.freeze({
+  async presignedPut() {
+    return Promise.reject(new Error("UploadPort is unavailable; no presigned-upload adapter was injected"));
+  }
+});
+function delayAbortable2(ms, signal, timers) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const holder = { handle: void 0 };
+    const done = () => {
+      timers.clearTimeout(holder.handle);
+      signal.removeEventListener("abort", done);
+      resolve();
+    };
+    holder.handle = timers.setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+function mergeSignals2(a, b) {
+  if (!b) return a;
+  const ctrl = new AbortController();
+  if (a.aborted || b.aborted) {
+    ctrl.abort();
+    return ctrl.signal;
+  }
+  const onAbort = () => ctrl.abort();
+  a.addEventListener("abort", onAbort, { once: true });
+  b.addEventListener("abort", onAbort, { once: true });
+  return ctrl.signal;
+}
+var MediaStore = class {
+  constructor(initial) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.epoch = 0;
+    this.inFlight = null;
+    this.snapshot = Object.freeze({ ...initial });
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  patch(partial) {
+    this.snapshot = Object.freeze({ ...this.snapshot, ...partial });
+    for (const listener of this.listeners) listener();
+  }
+  beginOperation(external) {
+    this.inFlight?.abort();
+    const ctrl = new AbortController();
+    this.inFlight = ctrl;
+    const epoch = this.epoch;
+    const signal = external ? mergeSignals2(ctrl.signal, external) : ctrl.signal;
+    return {
+      signal,
+      epoch,
+      settle: () => {
+        if (this.inFlight === ctrl) this.inFlight = null;
+      }
+    };
+  }
+  alive(epoch) {
+    return epoch === this.epoch;
+  }
+  /** Re-scope on user/pet switch: aborts in-flight and bumps the epoch so a late write drops. */
+  rescope() {
+    this.epoch += 1;
+    this.inFlight?.abort();
+    this.inFlight = null;
+  }
+  /** Idempotent teardown: aborts in-flight, bumps the epoch, drops every listener. */
+  dispose() {
+    this.epoch += 1;
+    this.inFlight?.abort();
+    this.inFlight = null;
+    this.listeners.clear();
+  }
+};
+
+// src/core/chat/chatMappers.ts
+function makeUser(id, text) {
+  return Object.freeze({ id, role: "user", text, pending: true });
+}
+function makeAssistant(id, text) {
+  return Object.freeze({ id, role: "assistant", text });
+}
+function stripPending(m) {
+  return Object.freeze({ id: m.id, role: m.role, text: m.text });
+}
+function appendText(m, text) {
+  const next = {
+    id: m.id,
+    role: m.role,
+    text: m.text + text
+  };
+  if (m.citations) next.citations = m.citations;
+  if (m.responseId) next.responseId = m.responseId;
+  return Object.freeze(next);
+}
+function finalizeAssistant(m, done) {
+  const next = {
+    id: done.messageId ? done.messageId : m.id,
+    role: "assistant",
+    text: m.text
+  };
+  if (done.citations.length > 0) next.citations = done.citations;
+  if (done.messageId) next.responseId = brandResponseId(done.messageId);
+  return Object.freeze(next);
+}
+function freezeSnapshot(s) {
+  return Object.freeze({
+    status: s.status,
+    messages: Object.freeze([...s.messages]),
+    conversationId: s.conversationId,
+    error: s.error,
+    isStreaming: s.isStreaming,
+    isBootstrapping: s.isBootstrapping,
+    suggestedPrompts: Object.freeze([...s.suggestedPrompts])
+  });
+}
+function makeError(code, retryable, wireMessage) {
+  return makeEverfurError(code, { retryable, ...wireMessage ? { wireMessage } : {} });
+}
+function errorFromFrame(frame) {
+  const code = fromWire(frame.code);
+  return makeEverfurError(code, {
+    retryable: frame.retryable || shouldRetry(code),
+    wireCode: frame.code,
+    ...frame.serverRequestId ? { requestId: frame.serverRequestId } : {},
+    ...frame.wireMessage ? { wireMessage: frame.wireMessage } : {},
+    raw: frame
+  });
+}
+function synthErrorFrame(error) {
+  return errorFrame({
+    code: canonicalWireCode(error.code),
+    retryable: error.retryable,
+    wireMessage: error.wireMessage ?? null,
+    synthesized: true,
+    lastEventId: null,
+    serverRequestId: error.requestId ?? null
+  });
+}
+function canonicalWireCode(code) {
+  switch (code) {
+    case "authExpired":
+      return "AUTH_EXPIRED";
+    case "authRejected":
+      return "AuthorizationException";
+    case "sessionRequired":
+      return "session_required";
+    case "accessDenied":
+      return "ACCESS_DENIED";
+    case "paymentRequired":
+      return "TIER_UPGRADE_REQUIRED";
+    case "quotaExceeded":
+      return "QUOTA_EXCEEDED";
+    case "rateLimited":
+      return "RATE_LIMITED";
+    case "validationFailed":
+      return "ValidationException";
+    case "sdkUpdateRequired":
+      return "invalidRequest";
+    case "conflict":
+      return "ConflictException";
+    case "idempotencyConflict":
+      return "IDEMPOTENCY_CONFLICT";
+    case "idempotencyInFlight":
+      return "IDEMPOTENCY_KEY_IN_FLIGHT";
+    case "conversationNotFound":
+      return "CONVERSATION_NOT_FOUND";
+    case "petNotFound":
+      return "PET_NOT_FOUND";
+    case "resourceNotFound":
+      return "ResourceNotFoundException";
+    case "streamTimeout":
+      return "STREAM_TIMEOUT";
+    case "mediaUploadFailed":
+      return "MEDIA_UPLOAD_FAILED";
+    case "moderationBlocked":
+      return "MODERATION_BLOCKED";
+    case "upstreamLlmTimeout":
+      return "UPSTREAM_LLM_TIMEOUT";
+    case "internalError":
+      return "INTERNAL_ERROR";
+    case "notImplemented":
+      return "NotImplementedException";
+    case "serviceUnavailable":
+      return "ServiceUnavailableException";
+    case "streamIncomplete":
+      return "STREAM_INCOMPLETE";
+    case "unknown":
+      return "UNKNOWN";
+    default:
+      return assertNever(code);
+  }
+}
+function parsePromptCategories(raw) {
+  const list = Array.isArray(raw) ? raw : isPlainObject2(raw) && Array.isArray(raw["categories"]) ? raw["categories"] : [];
+  const out = [];
+  for (const entry of list) {
+    if (!isPlainObject2(entry)) continue;
+    const category = asStr(entry["category"]) ?? asStr(entry["title"]) ?? "";
+    const prompts = asPromptTextList(entry["prompts"] ?? entry["questions"]);
+    if (category.length === 0 && prompts.length === 0) continue;
+    out.push(Object.freeze({ category, prompts: Object.freeze(prompts) }));
+  }
+  return Object.freeze(out);
+}
+function flattenPrompts(categories) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const category of categories) {
+    for (const prompt of category.prompts) {
+      const trimmed = prompt.trim();
+      if (trimmed.length === 0 || seen.has(trimmed)) continue;
+      seen.add(trimmed);
+      out.push(trimmed);
+    }
+  }
+  return out;
+}
+function isPlainObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function asStr(v) {
+  return typeof v === "string" ? v : null;
+}
+function asPromptTextList(v) {
+  if (!Array.isArray(v)) return [];
+  const out = [];
+  for (const entry of v) {
+    if (typeof entry === "string") {
+      out.push(entry);
+    } else if (isPlainObject2(entry)) {
+      const text = asStr(entry["text"]) ?? asStr(entry["prompt"]) ?? asStr(entry["title"]);
+      if (text !== null) out.push(text);
+    }
+  }
+  return out;
+}
+function defaultIdFactory() {
+  let counter = 0;
+  return () => `m-${Date.now().toString(36)}-${(counter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function defaultIdempotencyFactory() {
+  let counter = 0;
+  return () => `chat-send-${Date.now().toString(36)}-${(counter++).toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function brandConversationId(raw) {
+  return raw;
+}
+function brandResponseId(raw) {
+  return raw;
+}
+
+// src/core/chat/watchdog.ts
+var defaultTimers2 = {
+  setTimeout: (handler, ms) => setTimeout(handler, ms),
+  clearTimeout: (handle) => clearTimeout(handle),
+  now: () => Date.now()
+};
+async function* withWatchdog(source, budget, signal, timers) {
+  const it = source[Symbol.asyncIterator]();
+  const overall = deadline(budget.overallMs, timers);
+  const idle = deadline(budget.idleMs, timers);
+  const abort = abortPromise(signal);
+  try {
+    for (; ; ) {
+      if (signal.aborted) return;
+      const nextTagged = it.next().then(
+        (value) => ({ tag: "next", value }),
+        // A rejected it.next() is a RAW mid-stream transport drop (WiFi->cellular, backgrounding), NOT a clean
+        // end-of-stream. The prior code coerced it to { done: true }, which silently short-circuited the SDK's
+        // own retry ladder (SPEC-10 §7). Tag it so the loop can emit a retryable frame instead.
+        () => ({ tag: "streamError" })
+      );
+      const outcome = await Promise.race([
+        nextTagged,
+        idle.promise.then(() => ({ tag: "idle" })),
+        overall.promise.then(() => ({ tag: "overall" })),
+        abort.then(() => ({ tag: "abort" }))
+      ]);
+      if (outcome.tag === "abort") return;
+      if (outcome.tag === "streamError") {
+        if (signal.aborted) return;
+        yield synthStreamErrorFrame();
+        return;
+      }
+      if (outcome.tag === "idle" || outcome.tag === "overall") {
+        yield synthTimeoutFrame();
+        return;
+      }
+      const result = outcome.value;
+      if (result.done) return;
+      idle.reset(budget.idleMs);
+      yield result.value;
+      if (result.value.terminal) return;
+    }
+  } finally {
+    idle.cancel();
+    overall.cancel();
+    void Promise.resolve(it.return?.(void 0)).catch(() => {
+    });
+  }
+}
+function synthTimeoutFrame() {
+  return errorFrame({
+    code: "STREAM_TIMEOUT",
+    retryable: true,
+    wireMessage: null,
+    synthesized: true,
+    lastEventId: null
+  });
+}
+function synthStreamErrorFrame() {
+  return errorFrame({
+    code: "STREAM_INCOMPLETE",
+    retryable: true,
+    wireMessage: null,
+    synthesized: true,
+    lastEventId: null
+  });
+}
+function deadline(ms, timers) {
+  let resolveFn = () => {
+  };
+  const promise = new Promise((resolve) => {
+    resolveFn = resolve;
+  });
+  let handle = timers.setTimeout(() => resolveFn(), ms);
+  return {
+    promise,
+    reset(next) {
+      timers.clearTimeout(handle);
+      handle = timers.setTimeout(() => resolveFn(), next);
+    },
+    cancel() {
+      timers.clearTimeout(handle);
+    }
+  };
+}
+function abortPromise(signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    signal.addEventListener("abort", () => resolve(), { once: true });
+  });
+}
+
+// src/core/chat/ChatController.ts
+var DEFAULT_IDLE_MS = 6e4;
+var DEFAULT_OVERALL_MS = 18e4;
+var DELTA_FLUSH_MS = 24;
+var DELTA_FLUSH_CHARS = 512;
+var SEND_IS_SERVER_DEDUPED = false;
+function createChatController(deps) {
+  return new ChatControllerImpl(deps);
+}
+var ChatControllerImpl = class extends MediaStore {
+  constructor(deps) {
+    super(
+      freezeSnapshot({
+        status: "idle",
+        messages: [],
+        conversationId: deps.initialConversationId ?? null,
+        error: null,
+        isStreaming: false,
+        isBootstrapping: false,
+        suggestedPrompts: []
+      })
+    );
+    this.handlerTeardowns = /* @__PURE__ */ new Set();
+    this.lastTurn = null;
+    this.lastResponseIdValue = null;
+    /** Delta coalescing buffer (PERF1): accumulated assistant text not yet flushed to the snapshot. */
+    this.pendingDelta = "";
+    this.flushHandle = null;
+    this.auth = deps.auth;
+    this.funnel = deps.funnel ?? createRequestFunnel({
+      auth: deps.auth,
+      ...deps.errorPolicy ? { errorPolicy: deps.errorPolicy } : {}
+    });
+    this.telemetry = deps.telemetry ?? noopTelemetry;
+    this.errorPolicy = deps.errorPolicy ?? defaultErrorPolicy;
+    this.timers = deps.timers ?? defaultTimers2;
+    this.rng = deps.rng ?? Math.random;
+    this.newId = deps.newId ?? defaultIdFactory();
+    this.makeIdempotencyKey = deps.makeIdempotencyKey ?? defaultIdempotencyFactory();
+    this.budget = {
+      idleMs: deps.budget?.idleMs ?? DEFAULT_IDLE_MS,
+      overallMs: deps.budget?.overallMs ?? DEFAULT_OVERALL_MS
+    };
+  }
+  // ---- store ------------------------------------------------------------
+  // subscribe / getSnapshot / beginOperation / alive are inherited from MediaStore. patch is overridden so the
+  // messages array stays deep-frozen (the base freezes only the snapshot object).
+  patch(partial) {
+    if (partial.messages !== void 0) {
+      const frozen = Object.freeze([...partial.messages]);
+      super.patch({ ...partial, messages: frozen });
+      return;
+    }
+    super.patch(partial);
+  }
+  send(text, opts, handlers) {
+    const options = opts ?? {};
+    const invalid2 = validateMessageText(text);
+    if (invalid2 !== null) {
+      this.telemetry.track("chat.send.rejected", { reason: invalid2.reason });
+      this.patch({ status: "error", isStreaming: false, error: invalid2.error });
+      if (handlers) {
+        handlers.onError(invalid2.error);
+        return () => {
+        };
+      }
+      return singleFrameStream(synthErrorFrame(invalid2.error));
+    }
+    if (handlers) return this.driveWithHandlers(text, options, handlers);
+    const turn = this.beginTurn(text, options);
+    return this.runTurn(turn, options.signal);
+  }
+  retryLast() {
+    const turn = this.lastTurn;
+    if (turn === null) return emptyStream();
+    turn.assistantMessageId = null;
+    turn.sawDelta = false;
+    turn.conversationIdOverride = null;
+    this.discardPendingDelta();
+    const hasUser = this.snapshot.messages.some((m) => m.id === turn.userMessageId);
+    const messages = hasUser ? this.snapshot.messages : [...this.snapshot.messages, makeUser(turn.userMessageId, turn.text)];
+    this.patch({ error: null, messages });
+    return this.runTurn(turn, void 0);
+  }
+  stop() {
+    this.inFlight?.abort();
+    this.inFlight = null;
+    this.discardPendingDelta();
+    this.telemetry.track("chat.cancel", {});
+    const messages = this.snapshot.messages.filter((m) => !(m.role === "user" && m.pending === true));
+    const changed = messages.length !== this.snapshot.messages.length;
+    if (this.snapshot.status === "streaming" || changed) {
+      this.patch({ status: "idle", isStreaming: false, ...changed ? { messages } : {} });
+    }
+  }
+  rescope() {
+    super.rescope();
+    this.discardPendingDelta();
+    if (this.snapshot.status === "streaming") this.patch({ status: "idle", isStreaming: false });
+  }
+  dispose() {
+    this.discardPendingDelta();
+    for (const teardown of this.handlerTeardowns) teardown();
+    this.handlerTeardowns.clear();
+    super.dispose();
+  }
+  adoptConversation(id) {
+    if (this.snapshot.conversationId === id) return;
+    this.patch({ conversationId: id });
+  }
+  adoptPrompts(categories) {
+    const prompts = flattenPrompts(categories);
+    if (prompts.length === 0 && this.snapshot.suggestedPrompts.length === 0) return;
+    this.patch({ suggestedPrompts: Object.freeze(prompts) });
+  }
+  // ---- unary bootstrap helpers (§8) -------------------------------------
+  async createConversation(opts) {
+    return this.createConversationBounded(opts?.petRef ?? null);
+  }
+  /** The bounded create used by both the public helper and the turn pipeline (a caller signal ties it to op). */
+  async createConversationBounded(petRef, signal) {
+    const req = {
+      method: "POST",
+      path: "/widget/v1/conversations",
+      body: petRef ? { pet_ref: petRef } : {}
+    };
+    const res = await this.authedUnary(
+      "chat.createConversation",
+      req,
+      signal,
+      // The widget lane does NOT read `Idempotency-Key`: its router is a plain APIRouter with no
+      // idempotency route class, so a replay is a second CREATE, not a dedup, and retrying leaves the
+      // partner with orphan threads nobody asked for. `maxAttempts: 1` stops the replay.
+      //
+      // The key itself is deliberately STILL SENT (no `idempotent: false`): it costs nothing on the wire,
+      // it is what the funnel would mint anyway, and it starts working by itself the day the route dedups.
+      // Deleting this one option is then the whole reversal.
+      { maxAttempts: 1 }
+    );
+    if (!res.ok) return err(res.error);
+    const raw = res.value?.conversation_id ?? res.value?.id;
+    if (typeof raw !== "string" || raw.length === 0) {
+      return err(makeError("internalError", true));
+    }
+    return ok(brandConversationId(raw));
+  }
+  async getPrompts(opts) {
+    const petRef = opts?.petRef ?? null;
+    if (petRef !== null && hasLoneSurrogate(petRef)) {
+      return err(
+        makeEverfurError("validationFailed", {
+          retryable: false,
+          wireMessage: "pet_ref contains an unpaired surrogate and cannot be encoded"
+        })
+      );
+    }
+    const query = petRef !== null ? `?pet_ref=${encodeURIComponent(petRef)}` : "";
+    const res = await this.authedUnary("chat.getPrompts", {
+      method: "GET",
+      path: `/widget/v1/suggested-prompts${query}`
+    });
+    if (!res.ok) return err(res.error);
+    return ok(parsePromptCategories(res.value));
+  }
+  /**
+   * A unary authed hop, through the ONE REQUEST FUNNEL. The funnel owns the per-attempt deadline (PERF2:
+   * a stalled connection settles to a retryable error instead of hanging the spinner forever), the auth
+   * spine, retry with full jitter, the client-minted idempotency key, and telemetry. Settles; never throws.
+   */
+  async authedUnary(call, req, external, opts) {
+    return this.funnel.send(call, external ? { ...req, signal: external } : req, opts);
+  }
+  // ---- imperative escape hatch ------------------------------------------
+  driveWithHandlers(text, opts, handlers) {
+    const cancel = new AbortController();
+    const signal = mergeSignals2(cancel.signal, opts.signal);
+    const turn = this.beginTurn(text, opts);
+    const iterable = this.runTurn(turn, signal);
+    let torn = false;
+    const teardown = () => {
+      if (torn) return;
+      torn = true;
+      cancel.abort();
+      this.handlerTeardowns.delete(teardown);
+    };
+    this.handlerTeardowns.add(teardown);
+    void (async () => {
+      for await (const frame of iterable) {
+        if (torn) break;
+        handlers.onFrame(frame);
+        if (frame.kind === "done") handlers.onDone(this.lastResponseIdValue);
+      }
+      if (!torn && this.snapshot.status === "error" && this.snapshot.error !== null) {
+        handlers.onError(this.snapshot.error);
+      }
+      this.handlerTeardowns.delete(teardown);
+    })();
+    return teardown;
+  }
+  // ---- the turn pipeline ------------------------------------------------
+  beginTurn(text, opts) {
+    const turn = {
+      epoch: this.epoch,
+      text,
+      petRef: opts.petRef ?? null,
+      idempotencyKey: opts.idempotencyKey ?? this.makeIdempotencyKey(),
+      userMessageId: this.newId(),
+      assistantMessageId: null,
+      sawDelta: false,
+      conversationIdOverride: opts.conversationId ?? null
+    };
+    this.patch({
+      error: null,
+      messages: [...this.snapshot.messages, makeUser(turn.userMessageId, text)]
+    });
+    return turn;
+  }
+  async *runTurn(turn, external) {
+    const op = this.beginOperation(external);
+    turn.epoch = op.epoch;
+    this.patch({ status: "streaming", isStreaming: true, error: null });
+    this.lastTurn = turn;
+    let retries = 0;
+    let recreated = false;
+    let refreshedOnce = false;
+    try {
+      for (; ; ) {
+        if (op.signal.aborted || !this.alive(op.epoch)) return;
+        const needsConversation = turn.conversationIdOverride === null && this.snapshot.conversationId === null;
+        if (needsConversation) {
+          const created = await this.createConversationBounded(turn.petRef, op.signal);
+          if (op.signal.aborted || !this.alive(op.epoch)) return;
+          if (!created.ok) {
+            yield* this.emitTerminal(turn, created.error, synthErrorFrame(created.error));
+            return;
+          }
+          this.adoptConversation(created.value);
+        }
+        const convId = turn.conversationIdOverride ?? this.snapshot.conversationId;
+        if (convId === null) {
+          const e = makeError("internalError", true);
+          yield* this.emitTerminal(turn, e, synthErrorFrame(e));
+          return;
+        }
+        this.clearAssistantInProgress(turn);
+        const attemptCtrl = new AbortController();
+        const attemptSignal = mergeSignals2(op.signal, attemptCtrl.signal);
+        let terminalError = null;
+        try {
+          let authedReq;
+          try {
+            authedReq = await this.funnel.authorize(this.buildSendRequest(turn, convId));
+          } catch {
+            const e = this.authRejected();
+            yield* this.emitTerminal(turn, e, synthErrorFrame(e));
+            return;
+          }
+          if (op.signal.aborted || !this.alive(op.epoch)) return;
+          const source = this.funnel.stream("chat.send", authedReq, attemptSignal);
+          for await (const frame of withWatchdog(source, this.budget, attemptSignal, this.timers)) {
+            if (!this.alive(op.epoch)) return;
+            if (frame.kind === "error" && frame.terminal) {
+              terminalError = frame;
+              break;
+            }
+            this.applyFrame(frame, turn);
+            yield frame;
+            if (frame.terminal) {
+              op.settle();
+              return;
+            }
+          }
+        } finally {
+          attemptCtrl.abort();
+        }
+        if (op.signal.aborted || !this.alive(op.epoch)) return;
+        if (terminalError === null) {
+          if (this.snapshot.status === "complete") return;
+          const e = makeError("streamIncomplete", true);
+          yield* this.emitTerminal(turn, e, synthErrorFrame(e));
+          return;
+        }
+        const code = fromWire(terminalError.code);
+        if (code === "authExpired" && this.auth.mode === "personalized" && !refreshedOnce) {
+          refreshedOnce = true;
+          this.telemetry.track("chat.auth.refresh", {});
+          const refreshed = await this.tryForceRefresh();
+          if (op.signal.aborted || !this.alive(op.epoch)) return;
+          if (!refreshed) {
+            const e = this.authRejected();
+            yield* this.emitTerminal(turn, e, terminalError);
+            return;
+          }
+          continue;
+        }
+        if (code === "authExpired") {
+          this.telemetry.track("chat.auth.rejected", {});
+          const e = this.authRejected();
+          yield* this.emitTerminal(turn, e, terminalError);
+          return;
+        }
+        if (code === "accessDenied") {
+          this.telemetry.track("chat.access_denied", {});
+          yield* this.emitTerminal(turn, errorFromFrame(terminalError), terminalError);
+          return;
+        }
+        if (canRecreateOnNotFound(code) && !recreated) {
+          recreated = true;
+          this.telemetry.track("chat.conv.recreate", {});
+          this.adoptConversation(null);
+          turn.conversationIdOverride = null;
+          continue;
+        }
+        const framedRetry = terminalError.retryable && shouldRetry(code, true);
+        if (SEND_IS_SERVER_DEDUPED && framedRetry && retries + 1 < this.errorPolicy.maxAttempts(code)) ;
+        yield* this.emitTerminal(turn, errorFromFrame(terminalError), terminalError);
+        return;
+      }
+    } finally {
+      op.settle();
+    }
+  }
+  *emitTerminal(turn, error, frame) {
+    this.applyError(turn, error);
+    yield frame;
+  }
+  // ---- frame -> state ---------------------------------------------------
+  applyFrame(frame, turn) {
+    switch (frame.kind) {
+      case "accepted":
+        if (!this.snapshot.isStreaming) this.patch({ status: "streaming", isStreaming: true });
+        return;
+      case "heartbeat":
+        return;
+      // silent; the watchdog resets its idle timer on any frame
+      case "delta":
+        this.applyDelta(frame.delta, turn);
+        return;
+      case "done":
+        this.applyDone(frame, turn);
+        return;
+      case "analysisStarted":
+      case "analysisComplete":
+        return;
+      // not part of chat render (analyze streams project elsewhere)
+      case "unknown":
+        this.telemetry.track("chat.frame.unknown", {});
+        return;
+      // forward-compat: ignore for render, keep streaming, never crash
+      case "error":
+        return;
+      // terminal errors are driven by the recovery switch, never here
+      default:
+        return assertNever(frame);
+    }
+  }
+  applyDelta(text, turn) {
+    if (turn.assistantMessageId === null) {
+      const assistantId = this.newId();
+      turn.assistantMessageId = assistantId;
+      turn.sawDelta = true;
+      const cleared = this.snapshot.messages.map(
+        (m) => m.id === turn.userMessageId && m.pending === true ? stripPending(m) : m
+      );
+      this.patch({
+        status: "streaming",
+        isStreaming: true,
+        messages: [...cleared, makeAssistant(assistantId, text)]
+      });
+      return;
+    }
+    this.pendingDelta += text;
+    if (this.pendingDelta.length >= DELTA_FLUSH_CHARS) {
+      this.flushPendingDelta(turn);
+      return;
+    }
+    this.scheduleDeltaFlush(turn);
+  }
+  scheduleDeltaFlush(turn) {
+    if (this.flushHandle !== null) return;
+    const scheduledEpoch = this.epoch;
+    this.flushHandle = this.timers.setTimeout(() => {
+      this.flushHandle = null;
+      if (!this.alive(scheduledEpoch)) {
+        this.pendingDelta = "";
+        return;
+      }
+      this.flushPendingDelta(turn);
+    }, DELTA_FLUSH_MS);
+  }
+  /** Fold the buffered deltas into the streaming assistant message as ONE patch (one listener notification). */
+  flushPendingDelta(turn) {
+    this.clearFlushTimer();
+    if (this.pendingDelta.length === 0) return;
+    const chunk = this.pendingDelta;
+    this.pendingDelta = "";
+    const assistantId = turn.assistantMessageId;
+    if (assistantId === null) return;
+    const messages = this.snapshot.messages.map((m) => m.id === assistantId ? appendText(m, chunk) : m);
+    this.patch({ messages });
+  }
+  /** Drop a buffered-but-unflushed delta (cancel / rescope / dispose / retry): no stale text leaks forward. */
+  discardPendingDelta() {
+    this.clearFlushTimer();
+    this.pendingDelta = "";
+  }
+  clearFlushTimer() {
+    if (this.flushHandle !== null) {
+      this.timers.clearTimeout(this.flushHandle);
+      this.flushHandle = null;
+    }
+  }
+  applyDone(done, turn) {
+    this.flushPendingDelta(turn);
+    this.lastResponseIdValue = done.messageId ? brandResponseId(done.messageId) : null;
+    const nextConv = done.conversationId ? brandConversationId(done.conversationId) : this.snapshot.conversationId;
+    let messages;
+    if (turn.assistantMessageId !== null) {
+      messages = this.snapshot.messages.map(
+        (m) => m.id === turn.assistantMessageId ? finalizeAssistant(m, done) : m
+      );
+    } else {
+      const assistantId = this.newId();
+      turn.assistantMessageId = assistantId;
+      turn.sawDelta = true;
+      const cleared = this.snapshot.messages.map(
+        (m) => m.id === turn.userMessageId && m.pending === true ? stripPending(m) : m
+      );
+      messages = [...cleared, finalizeAssistant(makeAssistant(assistantId, ""), done)];
+    }
+    this.patch({
+      status: "complete",
+      isStreaming: false,
+      error: null,
+      conversationId: nextConv,
+      messages
+    });
+  }
+  applyError(turn, error) {
+    this.flushPendingDelta(turn);
+    this.errorPolicy.onExpectedFailure?.(error);
+    const messages = turn.sawDelta ? this.snapshot.messages : this.snapshot.messages.filter((m) => m.id !== turn.userMessageId);
+    this.patch({ status: "error", isStreaming: false, error, messages });
+  }
+  clearAssistantInProgress(turn) {
+    this.discardPendingDelta();
+    if (turn.assistantMessageId === null) return;
+    const assistantId = turn.assistantMessageId;
+    turn.assistantMessageId = null;
+    turn.sawDelta = false;
+    const messages = this.snapshot.messages.filter((m) => m.id !== assistantId);
+    if (messages.length !== this.snapshot.messages.length) this.patch({ messages });
+  }
+  // ---- auth + request build --------------------------------------------
+  buildSendRequest(turn, convId) {
+    const body = { message: turn.text };
+    return {
+      method: "POST",
+      path: `/widget/v1/conversations/${convId}/messages`,
+      body,
+      // The TURN's own key, not a funnel mint. This is the streaming path, which the funnel deliberately
+      // leaves alone, and the key is the identity of one logical turn: the same value is replayed by the
+      // 404 recreate-and-resend and by the mid-stream refresh replay, so neither duplicates the user's
+      // message. It is SDK-minted (`defaultIdempotencyFactory`), never taken from partner code.
+      headers: { "Idempotency-Key": turn.idempotencyKey }
+    };
+  }
+  async tryForceRefresh() {
+    if (this.auth.mode !== "personalized") return false;
+    try {
+      await this.auth.identity.currentToken({ forceRefresh: true });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  authRejected() {
+    return makeError("authRejected", false);
+  }
+};
+var MESSAGE_MAX_CHARS = 4e3;
+function validateMessageText(text) {
+  const raw = typeof text === "string" ? text : "";
+  if (raw.trim().length === 0) {
+    return { reason: "empty", error: makeError("validationFailed", false, "message is empty or whitespace-only") };
+  }
+  const codePoints = [...raw].length;
+  if (codePoints > MESSAGE_MAX_CHARS) {
+    return {
+      reason: "too_long",
+      error: makeError(
+        "validationFailed",
+        false,
+        `message is ${codePoints} characters; the server accepts at most ${MESSAGE_MAX_CHARS}`
+      )
+    };
+  }
+  return null;
+}
+async function* singleFrameStream(frame) {
+  yield frame;
+}
+async function* emptyStream() {
+}
+
+// src/core/bootstrap.ts
+async function bootstrapChat(input, deps) {
+  const { controller } = deps;
+  const petRef = input.petRef ?? null;
+  const resume = input.resumeConversationId ?? null;
+  const candidateConversationIds = [];
+  let sawForbidden = false;
+  let sawUnauthorized = false;
+  let sawConversationInitFailure = false;
+  let authBlock = null;
+  const conversationPromise = resume ? Promise.resolve(ok(resume)) : controller.createConversation(petRef ? { petRef } : void 0);
+  const promptsPromise = controller.getPrompts(petRef !== null ? { petRef } : void 0);
+  const [conversationRes, initialPromptsRes] = await Promise.all([conversationPromise, promptsPromise]);
+  let conversationId = null;
+  if (conversationRes.ok) {
+    conversationId = conversationRes.value;
+    candidateConversationIds.push(conversationRes.value);
+    controller.adoptConversation(conversationRes.value);
+  } else {
+    const e = conversationRes.error;
+    if (isUnauthorized(e)) {
+      sawUnauthorized = true;
+      authBlock = e;
+    } else if (isForbidden(e)) {
+      sawForbidden = true;
+      sawConversationInitFailure = true;
+    } else {
+      sawConversationInitFailure = true;
+    }
+  }
+  let suggestedPrompts = [];
+  if (initialPromptsRes.ok) {
+    suggestedPrompts = initialPromptsRes.value;
+  } else {
+    recordAuthSignals(initialPromptsRes.error);
+  }
+  function recordAuthSignals(e) {
+    if (isUnauthorized(e)) {
+      sawUnauthorized = true;
+      if (authBlock === null) authBlock = e;
+    } else if (isForbidden(e)) {
+      sawForbidden = true;
+    }
+  }
+  const error = authBlock !== null ? authBlock.displayMessage : null;
+  const warning = error === null && conversationId === null && sawConversationInitFailure ? CONVERSATION_NOT_PRIMED_WARNING : null;
+  return Object.freeze({
+    conversationId,
+    petRef,
+    suggestedPrompts,
+    error,
+    warning,
+    diagnostics: Object.freeze({
+      candidateConversationIds: Object.freeze([...candidateConversationIds]),
+      sawForbidden,
+      sawUnauthorized,
+      sawConversationInitFailure
+    })
+  });
+}
+var CONVERSATION_NOT_PRIMED_WARNING = "Chat is ready. Your first message will start the conversation.";
+function isUnauthorized(e) {
+  return e.httpStatus === 401 || e.code === "authExpired" || e.code === "authRejected";
+}
+function isForbidden(e) {
+  return e.httpStatus === 403 || e.code === "accessDenied";
+}
+
+// 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(petRef, profile) {
+  if (typeof petRef !== "string") return invalid("pet_ref must be a string");
+  if (petRef.trim().length === 0) return invalid("pet_ref must not be blank");
+  if (hasLoneSurrogate(petRef)) 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", petRef, 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, petRef) {
+  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"]) ?? petRef,
+    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(petRef, profile, opts) {
+      const invalid2 = validate(petRef, profile);
+      if (invalid2 !== null) return err(invalid2);
+      const path = `/widget/v1/pets/${encodeURIComponent(petRef)}`;
+      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, petRef));
+    }
+  };
+}
+
+// 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 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);
+}
+
+// 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");
+}
+
+// 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/core/entitlements/entitlementPoller.ts
+var MIN_POLL_INTERVAL_SECONDS = 30;
+function createEntitlementPoller(deps) {
+  const scheduler = deps.scheduler ?? defaultScheduler;
+  const resolve = deps.resolve ?? fetchEntitlements;
+  const floorSeconds = Math.max(1, deps.floorSeconds ?? MIN_POLL_INTERVAL_SECONDS);
+  const rng = deps.rng ?? Math.random;
+  const jitteredFloorSeconds = () => floorSeconds + rng() * floorSeconds;
+  let started = false;
+  let stopped = false;
+  let timer = null;
+  let cachedRevision = null;
+  let lastCadenceSeconds = floorSeconds;
+  let generation = 0;
+  const clearTimer = () => {
+    if (timer !== null) {
+      scheduler.clear(timer);
+      timer = null;
+    }
+  };
+  const schedule = (seconds) => {
+    if (stopped) return;
+    lastCadenceSeconds = Math.max(floorSeconds, seconds);
+    timer = scheduler.set(() => {
+      timer = null;
+      void tick();
+    }, lastCadenceSeconds * 1e3);
+  };
+  const tick = async () => {
+    if (stopped) return;
+    const myGen = generation;
+    const args = deps.region ? { cachedRevision, region: deps.region } : { cachedRevision };
+    let resolution;
+    try {
+      resolution = await resolve(deps.authFor(), args);
+    } catch (cause) {
+      deps.telemetry?.track("sdk.entitlements.poll_error", { reason: describe2(cause) });
+      if (!stopped && myGen === generation) schedule(jitteredFloorSeconds());
+      return;
+    }
+    if (stopped || myGen !== generation) return;
+    switch (resolution.kind) {
+      case "updated":
+        cachedRevision = resolution.revision;
+        deps.update(resolution.decisions, resolution.branding ?? null);
+        schedule(resolution.ttlSeconds);
+        return;
+      case "notModified":
+        schedule(lastCadenceSeconds);
+        return;
+      case "failed":
+        deps.telemetry?.track("sdk.entitlements.poll_failed", { code: resolution.error.code });
+        schedule(jitteredFloorSeconds());
+        return;
+      default:
+        schedule(jitteredFloorSeconds());
+    }
+  };
+  return {
+    start() {
+      if (started || stopped) return;
+      started = true;
+      void tick();
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      generation++;
+      clearTimer();
+    },
+    refresh() {
+      if (stopped || !started) return;
+      generation++;
+      cachedRevision = null;
+      clearTimer();
+      void tick();
+    }
+  };
+}
+var defaultScheduler = {
+  set(callback, ms) {
+    const handle = setTimeout(callback, ms);
+    handle.unref?.();
+    return handle;
+  },
+  clear(handle) {
+    clearTimeout(handle);
+  }
+};
+function describe2(cause) {
+  return cause instanceof Error ? cause.message : "poll failed";
+}
+
+// src/core/runtime.ts
+function compiledDefaultDecisions() {
+  return Object.freeze([Object.freeze({ resource: "chat.message.create", granted: true })]);
+}
+function createEntitlementStore(floorDecisions = compiledDefaultDecisions) {
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = Object.freeze({
+    decisions: floorDecisions(),
+    isPending: false,
+    branding: null
+  });
+  const emit = () => {
+    for (const listener of listeners) listener();
+  };
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot() {
+      return snapshot;
+    },
+    set(next) {
+      snapshot = Object.freeze({
+        decisions: Object.freeze([...next.decisions]),
+        isPending: next.isPending,
+        // Branding is additive; default to null (the compiled Everfur theme) when a caller omits it.
+        branding: next.branding ?? null
+      });
+      emit();
+    },
+    reset() {
+      snapshot = Object.freeze({
+        decisions: floorDecisions(),
+        isPending: false,
+        branding: null
+      });
+      emit();
+    }
+  };
+}
+function createEverfurRuntime(input, opts) {
+  return new EverfurRuntimeImpl(input, opts);
+}
+var PER_USER_KV_KEYS = Object.freeze([]);
+var EverfurRuntimeImpl = class {
+  constructor(input, opts) {
+    /**
+     * One `x-everfur-session-id` for the life of this runtime. It MUST be stable across requests: the server
+     * derives the anonymous identity from it, so a per-request value makes every call a different user and the
+     * create/send pair can never agree. Minted here, never persisted, never a credential.
+     */
+    /**
+     * Rotated on sign-out. The server derives the ANONYMOUS identity from this
+     * (`user_ref = f"anon-{session_id}"`), so keeping it across a logout would leave the next anonymous
+     * session inheriting the previous user's server-side conversation history.
+     */
+    this.sessionId = newSessionId();
+    // ONE ref-counted controller table keyed by `${epoch}|${kind}|${scopeKey}`, plus each controller's
+    // destroyer, so a re-scope / dispose can tear every open controller down without naming its type.
+    this.entries = /* @__PURE__ */ new Map();
+    this.destroyers = /* @__PURE__ */ new Map();
+    this.epoch = 0;
+    this.disposed = false;
+    const cfg = input.config;
+    if (cfg.secureStore !== void 0 && cfg.secureStore.isAvailable === true) {
+      throw new EverfurConfigError(
+        "invalid-argument",
+        "config.secureStore is not yet consumable: SDK token persistence is unimplemented. Omit secureStore to keep memory-only tokens (SPEC-10 \xA75.3)."
+      );
+    }
+    this.telemetry = cfg.telemetry ?? noopTelemetry;
+    const publishableKey = typeof cfg?.publishableKey === "string" ? cfg.publishableKey.trim() : "";
+    let failure = checkPublishableKey(cfg?.publishableKey);
+    const transportInjected = cfg.transport !== void 0;
+    let resolvedTransport;
+    if (failure !== null) {
+      resolvedTransport = refusingTransport(failure);
+    } else if (cfg.transport !== void 0) {
+      resolvedTransport = cfg.transport;
+    } else {
+      const resolved = tryResolveClient(cfg);
+      if (resolved.ok) {
+        resolvedTransport = createHttpTransport({
+          config: resolved.config,
+          ...opts?.eventSourceFactory ? { eventSourceFactory: opts.eventSourceFactory } : {}
+        });
+      } else {
+        failure = resolved.failure;
+        resolvedTransport = refusingTransport(resolved.failure);
+      }
+    }
+    this.configFailure = failure;
+    this.publishableKey = failure === null ? publishableKey : "";
+    this.transport = resolvedTransport;
+    if (failure !== null) {
+      reportConfigFailure(failure, this.telemetry);
+    }
+    this.errorPolicy = cfg.errorPolicy;
+    this.camera = cfg.camera ?? unavailableCamera;
+    this.upload = cfg.upload ?? unavailableUpload;
+    this.uploadTransport = cfg.uploadTransport ?? unavailableUploadTransport;
+    this.imageCache = cfg.imageCache ?? noopImageCache;
+    this.kv = cfg.storage ?? createInMemoryKv();
+    this.currentUser = input.user;
+    this.identity = input.user ? createIdentityProvider(input.user.userRef, input.user.getToken) : null;
+    this.activePet = input.activePet;
+    this.store = failure === null ? createEntitlementStore() : createEntitlementStore(() => deniedDecisionsFor("sdk_config", userFacingError("accessDenied")));
+    this.services = {
+      authFor: (userRef) => this.buildAuth(userRef),
+      telemetry: this.telemetry,
+      errorPolicy: this.errorPolicy,
+      camera: this.camera,
+      upload: this.upload,
+      uploadTransport: this.uploadTransport,
+      imageCache: this.imageCache,
+      kv: this.kv
+    };
+    this.registry = {
+      services: this.services,
+      acquireChat: (scope) => this.acquireInternal(
+        "chat",
+        `${scope.userRef ?? ""}|${scope.petRef ?? ""}|${scope.conversationId ?? ""}`,
+        () => this.buildChatController(scope),
+        (controller) => controller.dispose()
+      ),
+      releaseChat: (controller) => this.releaseInternal(controller),
+      acquire: (kind, scopeKey, create, destroy) => this.acquireInternal(kind, scopeKey, create, destroy),
+      release: (controller) => this.releaseInternal(controller)
+    };
+    this.entitlements = this.store;
+    const shouldPoll = failure === null && (opts?.startEntitlementPolling ?? !transportInjected);
+    this.poller = shouldPoll ? this.buildPoller(opts?.pollScheduler) : null;
+    this.poller?.start();
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  /**
+   * Build the entitlement poller. `authFor` re-derives the device AuthContext each poll (so a token refresh /
+   * re-scope is reflected), and `update` feeds the resolved decisions into the render store. The SERVER stays
+   * authoritative; this only populates what the SDK renders.
+   */
+  buildPoller(scheduler) {
+    return createEntitlementPoller({
+      authFor: () => this.buildAuth(this.currentUser?.userRef ?? null),
+      update: (decisions, branding) => this.updateEntitlements({ decisions, isPending: false, branding }),
+      telemetry: this.telemetry,
+      ...scheduler ? { scheduler } : {}
+    });
+  }
+  // ---- ref-counted acquire / release (epoch-keyed) -----------------------
+  acquireInternal(kind, scopeKey, create, destroy) {
+    const key = `${this.epoch}|${kind}|${scopeKey}`;
+    const existing = this.entries.get(key);
+    if (existing) {
+      existing.refCount += 1;
+      return existing.controller;
+    }
+    const controller = create();
+    this.entries.set(key, { controller, refCount: 1 });
+    this.destroyers.set(controller, destroy);
+    return controller;
+  }
+  releaseInternal(controller) {
+    for (const [key, entry] of this.entries) {
+      if (entry.controller !== controller) continue;
+      entry.refCount -= 1;
+      if (entry.refCount <= 0) {
+        this.runDestroyer(controller);
+        this.entries.delete(key);
+      }
+      return;
+    }
+  }
+  runDestroyer(controller) {
+    const destroy = this.destroyers.get(controller);
+    this.destroyers.delete(controller);
+    if (destroy) destroy(controller);
+  }
+  // ---- controller construction (only the spine capability is built here) -
+  buildChatController(scope) {
+    const controller = createChatController({
+      auth: this.buildAuth(scope.userRef),
+      telemetry: this.telemetry,
+      ...this.errorPolicy ? { errorPolicy: this.errorPolicy } : {},
+      initialConversationId: scope.conversationId
+    });
+    const input = {};
+    if (scope.petRef !== null) input.petRef = scope.petRef;
+    if (scope.conversationId !== null) input.resumeConversationId = scope.conversationId;
+    void bootstrapChat(input, { controller }).then((result) => controller.adoptPrompts(result.suggestedPrompts)).catch(() => {
+    });
+    return controller;
+  }
+  buildAuth(scopeUserRef) {
+    if (this.identity !== null && this.currentUser !== null) {
+      return {
+        mode: "personalized",
+        transport: this.transport,
+        identity: this.identity,
+        userRef: this.currentUser.userRef,
+        sessionId: this.sessionId
+      };
+    }
+    return {
+      mode: "anonymous",
+      transport: this.transport,
+      publishableKey: this.publishableKey,
+      // Only name a user while one is actually signed in. `scopeUserRef` is the REGISTRY scope key,
+      // taken from the host's `user` prop, which a `logout()` call does not touch — so carrying it here
+      // meant that after sign-out the SDK kept sending `x-everfur-user-ref` for the signed-out user
+      // alongside the publishable key, and the widget plane resolves identity from exactly that pair.
+      userRef: this.currentUser === null ? null : scopeUserRef,
+      sessionId: this.sessionId
+    };
+  }
+  // ---- imperative verbs (re-scope in one commit; SPEC-10 §3) -------------
+  setUser(user) {
+    if (this.disposed) return;
+    const nextRef = user?.userRef ?? null;
+    const currentRef = this.currentUser?.userRef ?? null;
+    if (nextRef === currentRef) {
+      this.currentUser = user;
+      if (user && this.identity === null) {
+        this.identity = createIdentityProvider(user.userRef, user.getToken);
+      }
+      return;
+    }
+    this.identity?.clear();
+    this.currentUser = user;
+    this.identity = user ? createIdentityProvider(user.userRef, user.getToken) : null;
+    this.rescopeAll();
+  }
+  async logout() {
+    if (this.disposed) return;
+    const wasAnonymous = this.currentUser === null;
+    this.sessionId = newSessionId();
+    this.setUser(null);
+    if (wasAnonymous) this.rescopeAll();
+    await this.sweepPerUserKv();
+  }
+  async sweepPerUserKv() {
+    if (PER_USER_KV_KEYS.length === 0) return;
+    const results = await Promise.allSettled(
+      PER_USER_KV_KEYS.map((key) => this.kv.removeItem(key))
+    );
+    const failedCount = results.filter((result) => result.status === "rejected").length;
+    if (failedCount > 0) {
+      this.telemetry.track("sdk.logout.sweepPartialFailure", {
+        failedCount,
+        totalCount: results.length
+      });
+    }
+  }
+  async registerPet(pet, profile) {
+    if (this.disposed) {
+      return err(
+        makeEverfurError("validationFailed", {
+          retryable: false,
+          wireMessage: "the Everfur runtime is disposed; registerPet was called after unmount"
+        })
+      );
+    }
+    const repo = createPetsRepository(this.buildAuth(this.currentUser?.userRef ?? null));
+    return profile === void 0 ? repo.registerPet(pet) : repo.registerPet(pet, profile);
+  }
+  setActivePet(pet) {
+    if (this.disposed) return;
+    const next = pet ?? null;
+    if (next === this.activePet) return;
+    this.activePet = next;
+    this.rescopeAll();
+  }
+  updateEntitlements(next) {
+    if (this.disposed) return;
+    if (this.configFailure !== null) return;
+    this.store.set(next);
+  }
+  open(capability) {
+    this.telemetry.track("sdk.open", { capability });
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.epoch += 1;
+    this.poller?.stop();
+    this.identity?.clear();
+    this.disposeAllControllers();
+  }
+  rescopeAll() {
+    this.epoch += 1;
+    this.disposeAllControllers();
+    this.store.reset();
+    this.poller?.refresh();
+  }
+  disposeAllControllers() {
+    for (const entry of this.entries.values()) this.runDestroyer(entry.controller);
+    this.entries.clear();
+    this.destroyers.clear();
+  }
+};
+function tryResolveClient(cfg) {
+  const clientCfg = {
+    publishableKey: cfg.publishableKey,
+    ...cfg.apiBaseUrl !== void 0 ? { apiBaseUrl: cfg.apiBaseUrl } : {},
+    ...cfg.contractVersion !== void 0 ? { contractVersion: cfg.contractVersion } : {},
+    ...cfg.debug !== void 0 ? { debug: cfg.debug } : {}
+  };
+  return tryResolveClientConfig(clientCfg);
+}
+function reportConfigFailure(failure, telemetry) {
+  try {
+    telemetry.trackExpectedFailure("sdk.config.invalid", { reason: failure.reason });
+  } catch {
+  }
+  const globalConsole = globalThis.console;
+  globalConsole?.error?.(
+    `[everfur] SDK disabled: ${failure.message}
+[everfur] Every Everfur capability will render its off-state until this is fixed. If the value is set in your environment, note that babel-preset-expo inlines only EXPO_PUBLIC_* variables into a release bundle.`
+  );
+}
+function refusingTransport(failure) {
+  const build = () => (
+    // NOT `internalError`: the funnel's `decideRetry` keys on `isAutoRetryable(code)` and deliberately
+    // ignores `error.retryable`, so `internalError` would be retried with backoff on every call even though
+    // it can never succeed; and `categoryFor('internalError')` is `server`, i.e. "the server admits fault",
+    // which would blame Everfur's backend for the partner's own config defect on their dashboards. The
+    // whole point of the `sdk_config` level is to attribute this correctly. `validationFailed` is terminal
+    // (`invalidRequest`: "retrying it unchanged can never succeed"), which is exactly true here.
+    makeEverfurError("validationFailed", {
+      retryable: false,
+      // Developer-facing only: `wireMessage` is NON-ENUMERABLE and never rendered (EverfurError.ts).
+      wireMessage: `Everfur SDK is not configured: ${failure.message}`
+    })
+  );
+  return Object.freeze({
+    request() {
+      return Promise.resolve(err(build()));
+    },
+    stream(_req, signal) {
+      const frame = errorFrame({
+        code: "sdk_not_configured",
+        retryable: false,
+        wireMessage: `Everfur SDK is not configured: ${failure.message}`,
+        synthesized: true,
+        lastEventId: null
+      });
+      return {
+        async *[Symbol.asyncIterator]() {
+          if (signal.aborted) return;
+          yield frame;
+        }
+      };
+    }
+  });
+}
+function createInMemoryKv() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    async getItem(key) {
+      return map.get(key) ?? null;
+    },
+    async setItem(key, value) {
+      map.set(key, value);
+    },
+    async removeItem(key) {
+      map.delete(key);
+    },
+    async keys(prefix) {
+      return [...map.keys()].filter((k) => k.startsWith(prefix));
+    }
+  };
+}
+var unavailableUploadTransport = Object.freeze({
+  postMultipart() {
+    return Promise.reject(
+      new Error("UploadTransport is unavailable; no records upload adapter was injected")
+    );
+  }
+});
+var noopImageCache = Object.freeze({
+  clearMemoryCache() {
+  },
+  clearDiskCache() {
+  }
+});
+
+exports.MESSAGE_MAX_CHARS = MESSAGE_MAX_CHARS;
+exports.MIN_POLL_INTERVAL_SECONDS = MIN_POLL_INTERVAL_SECONDS;
+exports.NULL_SECURE_STORE = NULL_SECURE_STORE;
+exports.bootstrapChat = bootstrapChat;
+exports.createChatController = createChatController;
+exports.createEntitlementPoller = createEntitlementPoller;
+exports.createEverfurRuntime = createEverfurRuntime;
+exports.defaultErrorPolicy = defaultErrorPolicy;
+exports.noopTelemetry = noopTelemetry;
+exports.optionalModule = optionalModule;
+exports.unavailableCamera = unavailableCamera;