@hipnation-truth/sdk 0.17.2 → 0.19.0

package/dist/react.js

@@ -57,12 +57,17 @@ var __async = (__this, __arguments, generator) => {
 var react_exports = {};
 __export(react_exports, {
   ACTIVE_CALL_STATES: () => ACTIVE_CALL_STATES,
+  API_BASE_URLS: () => API_BASE_URLS,
   CONNECTED_CALL_STATES: () => CONNECTED_CALL_STATES,
+  CONVEX_URLS: () => CONVEX_URLS2,
   DialpadCallState: () => DialpadCallState,
   RINGING_CALL_STATES: () => RINGING_CALL_STATES,
   TERMINAL_CALL_STATES: () => TERMINAL_CALL_STATES,
   TruthProvider: () => TruthProvider,
   TruthTrackingProvider: () => TruthTrackingProvider,
+  getTruthClient: () => getTruthClient,
+  resolveApiBaseUrl: () => resolveApiBaseUrl,
+  resolveConvexUrl: () => resolveConvexUrl,
   useActiveCalls: () => useActiveCalls,
   useAppointment: () => useAppointment,
   useAppointmentByElationId: () => useAppointmentByElationId,
@@ -82,6 +87,7 @@ __export(react_exports, {
   useDialpadCallsForConversation: () => useDialpadCallsForConversation,
   useMessages: () => useMessages,
   useNotifications: () => useNotifications,
+  useNotificationsActions: () => useNotificationsActions,
   usePatient: () => usePatient,
   usePatientBasic: () => usePatientBasic,
   usePatientByElationId: () => usePatientByElationId,
@@ -98,9 +104,12 @@ __export(react_exports, {
   usePhysiciansByElationIds: () => usePhysiciansByElationIds,
   useRemindersForConversations: () => useRemindersForConversations,
   useTruth: () => useTruth,
+  useTruthClient: () => useTruthClient,
+  useTruthSdkContext: () => useTruthSdkContext,
   useUnreadAggregate: () => useUnreadAggregate,
   useUnreadCount: () => useUnreadCount,
   useUserSettings: () => useUserSettings,
+  useUserSync: () => useUserSync,
   useVoicemailUrl: () => useVoicemailUrl
 });
 module.exports = __toCommonJS(react_exports);
@@ -291,7 +300,7 @@ function useUnreadAggregate(userId, options) {
 function useMemoizedPhones(phones) {
   const key = phones ? [...phones].sort().join("|") : "";
   return (0, import_react4.useMemo)(
-    () => phones && phones.length ? [...phones].sort() : void 0,
+    () => (phones == null ? void 0 : phones.length) ? [...phones].sort() : void 0,
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [key]
   );
@@ -338,87 +347,2172 @@ function useConversationTasksByPhonePair(phonePair) {
 }
 
 // src/react/hooks.ts
+var import_react7 = require("convex/react");
+var import_react8 = require("react");
+
+// src/react/provider.ts
 var import_react5 = require("convex/react");
 var import_react6 = require("react");
-var import_server4 = require("convex/server");
-var patientsListRef = (0, import_server4.makeFunctionReference)("patients:list");
-var patientsGetRef = (0, import_server4.makeFunctionReference)("patients:get");
-var patientsByElationIdRef = (0, import_server4.makeFunctionReference)("patients:getByElationId");
-var patientsByHintIdRef = (0, import_server4.makeFunctionReference)("patients:getByHintId");
-var appointmentsListRef = (0, import_server4.makeFunctionReference)("appointments:list");
-var appointmentsGetRef = (0, import_server4.makeFunctionReference)("appointments:get");
-var appointmentsByElationIdRef = (0, import_server4.makeFunctionReference)("appointments:getByElationId");
+
+// src/client.ts
+var import_browser = require("convex/browser");
+
+// src/resources/appointments.ts
+var AppointmentResource = class {
+  constructor(convexClient) {
+    this.convex = convexClient;
+  }
+  /**
+   * Get an appointment by its Truth platform ID.
+   */
+  get(id) {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.convex.query(
+          "appointments:getById",
+          { id }
+        );
+        return result != null ? result : null;
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  /**
+   * List appointments with optional filters, pagination, and limit.
+   */
+  list(options) {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.convex.query(
+          "appointments:list",
+          {
+            patientId: options == null ? void 0 : options.patientId,
+            startDate: options == null ? void 0 : options.startDate,
+            endDate: options == null ? void 0 : options.endDate,
+            status: options == null ? void 0 : options.status,
+            limit: options == null ? void 0 : options.limit,
+            cursor: options == null ? void 0 : options.cursor
+          }
+        );
+        const typed = result;
+        return typed != null ? typed : { data: [], cursor: null, hasMore: false };
+      } catch (e) {
+        return { data: [], cursor: null, hasMore: false };
+      }
+    });
+  }
+};
+
+// src/resources/attachments.ts
+var AttachmentsError = class extends Error {
+  constructor(operation, status, message) {
+    super(message != null ? message : `Attachment ${operation} failed (HTTP ${status})`);
+    this.name = "AttachmentsError";
+    this.status = status;
+  }
+};
+var AttachmentsResource = class {
+  constructor(apiBaseUrl, apiKey, convexClient) {
+    this.baseUrl = apiBaseUrl;
+    this.apiKey = apiKey;
+    this.convex = convexClient;
+  }
+  post(path, body) {
+    return __async(this, null, function* () {
+      const res = yield fetch(`${this.baseUrl}/api${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "X-API-Key": this.apiKey
+        },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new AttachmentsError(path, res.status, text.slice(0, 200));
+      }
+      return yield res.json();
+    });
+  }
+  createUploadUrl(input) {
+    return __async(this, null, function* () {
+      return yield this.post(
+        "/attachments/upload-url",
+        input
+      );
+    });
+  }
+  getDownloadUrl(s3Key, expiresIn) {
+    return __async(this, null, function* () {
+      return yield this.post("/attachments/download-url", {
+        s3Key,
+        expiresIn
+      });
+    });
+  }
+  record(input) {
+    return __async(this, null, function* () {
+      return yield this.convex.mutation(
+        "attachments:record",
+        input
+      );
+    });
+  }
+  get(attachmentId) {
+    return __async(this, null, function* () {
+      try {
+        const row = yield this.convex.query(
+          "attachments:getById",
+          { attachmentId }
+        );
+        return row != null ? row : null;
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  listByConversation(conversationId) {
+    return __async(this, null, function* () {
+      try {
+        const rows = yield this.convex.query(
+          "attachments:listByConversation",
+          { conversationId }
+        );
+        return rows != null ? rows : [];
+      } catch (e) {
+        return [];
+      }
+    });
+  }
+  /**
+   * One-shot upload: presign → PUT to S3 → record in Convex → return a
+   * 7-day signed download URL ready to embed in an outbound SMS. Caller
+   * passes the resulting `downloadUrl` to `messages.dialpad.sendSms` (or
+   * the new `messages.sendAttachmentMessage`) to actually deliver it.
+   *
+   * Replaces CommHub's NestJS `/send-attachment` controller in a single
+   * SDK call — no base64 round-trip, no legacy `/attachments/:id/download`
+   * REST endpoint required.
+   */
+  upload(input) {
+    return __async(this, null, function* () {
+      var _a;
+      const presigned = yield this.createUploadUrl({
+        fileName: input.fileName,
+        mimeType: input.mimeType,
+        size: input.size,
+        conversationId: input.conversationId
+      });
+      const body = input.file instanceof Blob ? input.file : input.file instanceof Uint8Array ? input.file : new Uint8Array(input.file);
+      const abort = new AbortController();
+      const timer = setTimeout(() => abort.abort(), 3e4);
+      let putRes;
+      try {
+        putRes = yield fetch(presigned.uploadUrl, {
+          method: "PUT",
+          headers: { "Content-Type": input.mimeType },
+          body,
+          signal: abort.signal
+        });
+      } catch (err) {
+        const isAbort = err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+        if (isAbort) {
+          throw new AttachmentsError(
+            "s3-put",
+            0,
+            "S3 upload timed out after 30s"
+          );
+        }
+        throw err;
+      } finally {
+        clearTimeout(timer);
+      }
+      if (!putRes.ok) {
+        throw new AttachmentsError(
+          "s3-put",
+          putRes.status,
+          `S3 PUT ${putRes.status} for ${presigned.s3Key}`
+        );
+      }
+      const recorded = yield this.record({
+        s3Key: presigned.s3Key,
+        fileName: input.fileName,
+        mimeType: input.mimeType,
+        size: input.size,
+        conversationId: input.conversationId,
+        uploadedBy: input.uploadedBy
+      });
+      const signed = yield this.getDownloadUrl(
+        presigned.s3Key,
+        (_a = input.downloadExpiresIn) != null ? _a : 7 * 24 * 3600
+      );
+      return {
+        attachmentId: recorded.attachmentId,
+        s3Key: presigned.s3Key,
+        downloadUrl: signed.url
+      };
+    });
+  }
+};
+
+// src/resources/conversations.ts
+var ConversationsError = class extends Error {
+  constructor(operation, status, message) {
+    super(message != null ? message : `Conversations ${operation} failed (HTTP ${status})`);
+    this.name = "ConversationsError";
+    this.status = status;
+  }
+};
+function assertConversationAddress(operation, input) {
+  if (!input.conversationId && !input.phonePair) {
+    throw new ConversationsError(
+      operation,
+      0,
+      "Either `conversationId` or `phonePair` is required"
+    );
+  }
+}
+var ConversationNotesSubresource = class {
+  constructor(post) {
+    this.post = post;
+  }
+  /** Create a note on a conversation (addressed by id or phonePair). */
+  create(input) {
+    return __async(this, null, function* () {
+      assertConversationAddress("notes.create", input);
+      return this.post("/conversations/notes", input);
+    });
+  }
+};
+var ConversationTasksSubresource = class {
+  constructor(post, patch) {
+    this.post = post;
+    this.patch = patch;
+  }
+  /** Create a task on a conversation. */
+  create(input) {
+    return __async(this, null, function* () {
+      assertConversationAddress("tasks.create", input);
+      return this.post("/conversations/tasks", input);
+    });
+  }
+  /** Mark a task pending or completed. */
+  setStatus(input) {
+    return __async(this, null, function* () {
+      return this.post(
+        `/conversations/tasks/${encodeURIComponent(input.taskId)}/status`,
+        __spreadValues({
+          id: input.taskId,
+          status: input.status
+        }, input.resolvedBy ? { resolvedBy: input.resolvedBy } : {})
+      );
+    });
+  }
+  /**
+   * Update task fields (priority, assignee, description, type). Wraps
+   * `PATCH /api/conversations/tasks/{id}` so CommHub doesn't have to
+   * direct-fetch for non-status field edits.
+   */
+  update(input) {
+    return __async(this, null, function* () {
+      return this.patch(
+        `/conversations/tasks/${encodeURIComponent(input.taskId)}`,
+        __spreadValues(__spreadValues(__spreadValues(__spreadValues({
+          id: input.taskId,
+          conversationId: input.conversationId,
+          author: input.author,
+          description: input.description
+        }, input.priority ? { priority: input.priority } : {}), input.status ? { status: input.status } : {}), input.assignee !== void 0 ? { assignee: input.assignee } : {}), input.type !== void 0 ? { type: input.type } : {})
+      );
+    });
+  }
+};
+var ConversationMessagesSubresource = class {
+  constructor(post) {
+    this.post = post;
+  }
+  /**
+   * Send an outbound SMS / MMS via the typed `sendMessage` oRPC procedure.
+   *
+   * Prefer this over the generic Dialpad proxy (`messages.dialpad.sendSms`)
+   * — this hits the validated Truth route and consistently surfaces
+   * `ConversationsError` on failure.
+   */
+  send(input) {
+    return __async(this, null, function* () {
+      if (!input.message && !input.media) {
+        throw new ConversationsError(
+          "messages.send",
+          0,
+          "send requires `message` or `media`"
+        );
+      }
+      return this.post(
+        "/conversations/messages",
+        input
+      );
+    });
+  }
+};
+var _ConversationsResource = class _ConversationsResource {
+  constructor(apiBaseUrl, apiKey, convex) {
+    this.baseUrl = apiBaseUrl;
+    this.apiKey = apiKey;
+    this.convex = convex != null ? convex : null;
+    const post = (path, body) => this.postRequest(path, body);
+    const patch = (path, body) => this.patchRequest(path, body);
+    this.notes = new ConversationNotesSubresource(post);
+    this.tasks = new ConversationTasksSubresource(post, patch);
+    this.messages = new ConversationMessagesSubresource(post);
+  }
+  /**
+   * Mark a conversation read for the calling user (zeroes unreadCount,
+   * stamps `lastReadAt`). Calls the public Convex `markRead` mutation
+   * which enforces self-tenancy on the auth identity.
+   */
+  markRead(input) {
+    return __async(this, null, function* () {
+      if (!this.convex) {
+        throw new ConversationsError(
+          "/markRead",
+          0,
+          "ConversationsResource missing Convex client"
+        );
+      }
+      return yield this.convex.mutation(
+        "conversations:markRead",
+        input
+      );
+    });
+  }
+  /**
+   * Mark a conversation unread for the calling user (sets unreadCount=1).
+   */
+  markUnread(input) {
+    return __async(this, null, function* () {
+      if (!this.convex) {
+        throw new ConversationsError(
+          "/markUnread",
+          0,
+          "ConversationsResource missing Convex client"
+        );
+      }
+      return yield this.convex.mutation(
+        "conversations:markUnread",
+        input
+      );
+    });
+  }
+  /**
+   * Zero unread on every conversation the user has reads for, except
+   * those whose `providerPhone` is in `excludedProviderPhones`.
+   */
+  clearAllUnread(input) {
+    return __async(this, null, function* () {
+      if (!this.convex) {
+        throw new ConversationsError(
+          "/clearAllUnread",
+          0,
+          "ConversationsResource missing Convex client"
+        );
+      }
+      return yield this.convex.mutation(
+        "conversations:clearAllUnread",
+        input
+      );
+    });
+  }
+  postRequest(path, body) {
+    return __async(this, null, function* () {
+      if (!this.apiKey) {
+        throw new ConversationsError(
+          path,
+          0,
+          "Truth API key not configured \u2014 request blocked"
+        );
+      }
+      const controller = new AbortController();
+      const timeout = setTimeout(
+        () => controller.abort(),
+        _ConversationsResource.REQUEST_TIMEOUT_MS
+      );
+      let res;
+      try {
+        res = yield fetch(`${this.baseUrl}/api${path}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "X-API-Key": this.apiKey
+          },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
+      } catch (err) {
+        const isAbort = err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+        const message = isAbort ? `Conversations ${path} timed out after ${_ConversationsResource.REQUEST_TIMEOUT_MS}ms` : err instanceof Error ? err.message : "Conversations request failed before response";
+        throw new ConversationsError(path, 0, message);
+      } finally {
+        clearTimeout(timeout);
+      }
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new ConversationsError(path, res.status, text.slice(0, 200));
+      }
+      return yield res.json();
+    });
+  }
+  /**
+   * PATCH variant of `postRequest`. Mirrors the timeout + API-key
+   * handling so callers like `tasks.update()` don't need to roll their
+   * own fetch. The Truth task router treats unknown methods as 405, so
+   * a dedicated PATCH path is required.
+   */
+  patchRequest(path, body) {
+    return __async(this, null, function* () {
+      if (!this.apiKey) {
+        throw new ConversationsError(
+          path,
+          0,
+          "Truth API key not configured \u2014 request blocked"
+        );
+      }
+      const controller = new AbortController();
+      const timeout = setTimeout(
+        () => controller.abort(),
+        _ConversationsResource.REQUEST_TIMEOUT_MS
+      );
+      let res;
+      try {
+        res = yield fetch(`${this.baseUrl}/api${path}`, {
+          method: "PATCH",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "X-API-Key": this.apiKey
+          },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
+      } catch (err) {
+        const isAbort = err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+        const message = isAbort ? `Conversations ${path} timed out after ${_ConversationsResource.REQUEST_TIMEOUT_MS}ms` : err instanceof Error ? err.message : String(err);
+        throw new ConversationsError(path, 0, message);
+      } finally {
+        clearTimeout(timeout);
+      }
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new ConversationsError(
+          path,
+          res.status,
+          `Conversations ${path} failed: ${text.slice(0, 200)}`
+        );
+      }
+      return yield res.json();
+    });
+  }
+};
+/** 30s upstream timeout — matches NotesResource for consistency. */
+_ConversationsResource.REQUEST_TIMEOUT_MS = 3e4;
+var ConversationsResource = _ConversationsResource;
+
+// src/resources/dialpad.ts
+var DialpadResource = class {
+  constructor(apiBaseUrl, apiKey) {
+    this.baseUrl = apiBaseUrl;
+    this.apiKey = apiKey;
+  }
+  /**
+   * Send an SMS or MMS message via Dialpad.
+   */
+  sendSms(params) {
+    return __async(this, null, function* () {
+      const body = __spreadValues(__spreadValues({
+        to_numbers: [params.to_number],
+        from_number: params.from_number,
+        infer_country_code: false
+      }, params.message ? { text: params.message } : {}), params.media ? { media: params.media } : {});
+      return this.post("/sms", body);
+    });
+  }
+  /**
+   * Initiate an outbound call from a Dialpad user to a phone number.
+   */
+  initiateCall(userId, phoneNumber) {
+    return __async(this, null, function* () {
+      return this.post(`/users/${userId}/initiate_call`, {
+        phone_number: phoneNumber
+      });
+    });
+  }
+  /**
+   * Hang up an active call.
+   */
+  hangupCall(callId) {
+    return __async(this, null, function* () {
+      yield this.put(`/call/${callId}/actions/hangup`);
+    });
+  }
+  /**
+   * Alias for `hangupCall` — mirrors the CommHub `endCall` action name so
+   * the SDK swap is a direct rename.
+   */
+  endCall(callId) {
+    return __async(this, null, function* () {
+      yield this.hangupCall(callId);
+    });
+  }
+  /**
+   * Send an MMS with a pre-uploaded attachment. Takes the S3 key returned
+   * by `client.attachments.createUploadUrl(...)` + PUT, fetches a short-
+   * lived download URL, and hands it to Dialpad as `media[]`.
+   *
+   * Replaces CommHub's `sendAttachment` Hasura Action (which stored bytes
+   * as base64 in Postgres and served them through a GET endpoint).
+   */
+  sendAttachmentWithUrl(params) {
+    return __async(this, null, function* () {
+      return this.sendSms({
+        from_number: params.from_number,
+        to_number: params.to_number,
+        message: params.message,
+        media: [params.mediaUrl]
+      });
+    });
+  }
+  /**
+   * Get the status of a call.
+   */
+  getCallStatus(callId) {
+    return __async(this, null, function* () {
+      try {
+        return yield this.get(`/call/${callId}`);
+      } catch (error) {
+        if (error instanceof DialpadProxyError && error.status === 404) {
+          return null;
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Get a Dialpad user by their user ID.
+   */
+  getUser(userId) {
+    return __async(this, null, function* () {
+      try {
+        return yield this.get(`/users/${userId}`);
+      } catch (error) {
+        if (error instanceof DialpadProxyError && error.status === 404) {
+          return null;
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Find a Dialpad user by email.
+   */
+  getUserByEmail(email) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const result = yield this.get("/users", {
+        email
+      });
+      return (_b = (_a = result.items) == null ? void 0 : _a[0]) != null ? _b : null;
+    });
+  }
+  /**
+   * Find a Dialpad user by phone number.
+   */
+  getUserByPhoneNumber(phoneNumber) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const result = yield this.get("/users", {
+        number: phoneNumber
+      });
+      return (_b = (_a = result.items) == null ? void 0 : _a[0]) != null ? _b : null;
+    });
+  }
+  /**
+   * Get information about a Dialpad phone number.
+   */
+  getNumberInfo(phoneNumber) {
+    return __async(this, null, function* () {
+      try {
+        const cleanNumber = phoneNumber.replace(/[^\d+]/g, "");
+        return yield this.get(
+          `/numbers/${encodeURIComponent(cleanNumber)}`
+        );
+      } catch (error) {
+        if (error instanceof DialpadProxyError && error.status === 404) {
+          return null;
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Authenticate a voicemail download URL. Truth appends the Dialpad API key,
+   * follows redirects, and returns the clean URL for client-side playback.
+   */
+  authenticateVoicemail(voicemailLink) {
+    return __async(this, null, function* () {
+      const url = `${this.baseUrl}/api/messages/dialpad/voicemail/authenticate`;
+      const response = yield fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.apiKey
+        },
+        body: JSON.stringify({ voicemail_link: voicemailLink })
+      });
+      const result = yield response.json();
+      if (!response.ok || !result.success) {
+        return null;
+      }
+      return result.authenticated_url;
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Internal HTTP helpers
+  // -----------------------------------------------------------------------
+  get(path, params) {
+    return __async(this, null, function* () {
+      const url = new URL(`/api/messages/dialpad${path}`, this.baseUrl);
+      if (params) {
+        for (const [key, value] of Object.entries(params)) {
+          if (value !== void 0) {
+            url.searchParams.set(key, String(value));
+          }
+        }
+      }
+      const response = yield fetch(url.toString(), {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+          "X-API-Key": this.apiKey
+        }
+      });
+      if (!response.ok) {
+        throw new DialpadProxyError("GET", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+  post(path, body) {
+    return __async(this, null, function* () {
+      const url = `${this.baseUrl}/api/messages/dialpad${path}`;
+      const response = yield fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "X-API-Key": this.apiKey
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+      if (!response.ok) {
+        throw new DialpadProxyError("POST", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+  put(path, body) {
+    return __async(this, null, function* () {
+      var _a;
+      const url = `${this.baseUrl}/api/messages/dialpad${path}`;
+      const response = yield fetch(url, {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "X-API-Key": this.apiKey
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+      if (!response.ok) {
+        throw new DialpadProxyError("PUT", path, response.status);
+      }
+      if ((_a = response.headers.get("content-type")) == null ? void 0 : _a.includes("json")) {
+        return yield response.json();
+      }
+      return void 0;
+    });
+  }
+};
+var MessagesResource = class {
+  constructor(apiBaseUrl, apiKey) {
+    this.dialpad = new DialpadResource(apiBaseUrl, apiKey);
+    this.baseUrl = apiBaseUrl;
+    this.apiKey = apiKey;
+  }
+  /**
+   * Get an authenticated URL for a Dialpad voicemail recording.
+   *
+   * Replaces CommHub's `getAuthenticatedVoicemailUrl` Hasura mutation
+   * (which proxied to the legacy NestJS backend). Truth appends the
+   * Dialpad API key, follows redirects, strips the key from the final
+   * URL, and returns it for client-side audio playback.
+   *
+   * @param voicemailLink  The raw Dialpad voicemail download URL (value
+   *   of the `voicemail_link` field on the call event row).
+   * @returns An object with `url` (clean playback URL) and `expiresAt`
+   *   (ISO-8601 timestamp, ~5 min from request time, informational only).
+   */
+  getVoicemailUrl(voicemailLink) {
+    return __async(this, null, function* () {
+      const res = yield fetch(`${this.baseUrl}/api/conversations/voicemail/url`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "X-API-Key": this.apiKey
+        },
+        body: JSON.stringify({ voicemailLink })
+      });
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new Error(
+          `messages.getVoicemailUrl failed (HTTP ${res.status}): ${text.slice(0, 200)}`
+        );
+      }
+      return yield res.json();
+    });
+  }
+  /**
+   * End a Dialpad call via the typed oRPC procedure (POST hangup, with
+   * 404→`alreadyEnded` so the UI doesn't flash an error on a natural
+   * race). Replaces CommHub's `useEndCallMutation` Hasura action.
+   *
+   * Prefer this over `messages.dialpad.endCall` which goes through the
+   * generic proxy (PUT, no 404 handling).
+   */
+  endCall(callId) {
+    return __async(this, null, function* () {
+      const res = yield fetch(`${this.baseUrl}/api/conversations/calls/end`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "X-API-Key": this.apiKey
+        },
+        body: JSON.stringify({ callId })
+      });
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new Error(
+          `messages.endCall failed (HTTP ${res.status}): ${text.slice(0, 200)}`
+        );
+      }
+      return yield res.json();
+    });
+  }
+};
+var DialpadProxyError = class extends Error {
+  constructor(method, path, status) {
+    super(
+      `Dialpad proxy error: ${method} /api/messages/dialpad${path} returned ${status}`
+    );
+    this.name = "DialpadProxyError";
+    this.method = method;
+    this.path = path;
+    this.status = status;
+  }
+};
+
+// src/resources/ehr.ts
+var EhrProviderProxy = class {
+  constructor(apiBaseUrl, provider) {
+    this.baseUrl = apiBaseUrl;
+    this.provider = provider;
+  }
+  /**
+   * GET request to the EHR proxy.
+   * @param path — path relative to the provider root (e.g., "/patients/123/")
+   * @param params — optional query parameters
+   */
+  get(path, params) {
+    return __async(this, null, function* () {
+      const url = new URL(`/api/ehr/${this.provider}${path}`, this.baseUrl);
+      if (params) {
+        for (const [key, value] of Object.entries(params)) {
+          if (value !== void 0) {
+            url.searchParams.set(key, String(value));
+          }
+        }
+      }
+      const response = yield fetch(url.toString(), {
+        method: "GET",
+        headers: { Accept: "application/json" }
+      });
+      if (!response.ok) {
+        throw new EhrProxyError(this.provider, "GET", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+  /**
+   * POST request to the EHR proxy.
+   */
+  post(path, body) {
+    return __async(this, null, function* () {
+      const url = `${this.baseUrl}/api/ehr/${this.provider}${path}`;
+      const response = yield fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+      if (!response.ok) {
+        throw new EhrProxyError(this.provider, "POST", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+  /**
+   * PUT request to the EHR proxy.
+   */
+  put(path, body) {
+    return __async(this, null, function* () {
+      const url = `${this.baseUrl}/api/ehr/${this.provider}${path}`;
+      const response = yield fetch(url, {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+      if (!response.ok) {
+        throw new EhrProxyError(this.provider, "PUT", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+  /**
+   * PATCH request to the EHR proxy.
+   */
+  patch(path, body) {
+    return __async(this, null, function* () {
+      const url = `${this.baseUrl}/api/ehr/${this.provider}${path}`;
+      const response = yield fetch(url, {
+        method: "PATCH",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+      if (!response.ok) {
+        throw new EhrProxyError(this.provider, "PATCH", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+  /**
+   * DELETE request to the EHR proxy.
+   */
+  delete(path) {
+    return __async(this, null, function* () {
+      const url = `${this.baseUrl}/api/ehr/${this.provider}${path}`;
+      const response = yield fetch(url, {
+        method: "DELETE",
+        headers: { Accept: "application/json" }
+      });
+      if (!response.ok) {
+        throw new EhrProxyError(this.provider, "DELETE", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+};
+var EhrResource = class {
+  constructor(apiBaseUrl) {
+    this.elation = new EhrProviderProxy(apiBaseUrl, "elation");
+    this.hint = new EhrProviderProxy(apiBaseUrl, "hint");
+  }
+};
+var EhrProxyError = class extends Error {
+  constructor(provider, method, path, status) {
+    super(
+      `EHR proxy error: ${method} /api/ehr/${provider}${path} returned ${status}`
+    );
+    this.name = "EhrProxyError";
+    this.provider = provider;
+    this.method = method;
+    this.path = path;
+    this.status = status;
+  }
+};
+
+// src/resources/notes.ts
+var NotesError = class extends Error {
+  constructor(operation, status, message) {
+    super(message != null ? message : `Notes ${operation} failed (HTTP ${status})`);
+    this.name = "NotesError";
+    this.status = status;
+  }
+};
+var _NotesResource = class _NotesResource {
+  constructor(apiBaseUrl, apiKey) {
+    this.baseUrl = apiBaseUrl;
+    this.apiKey = apiKey;
+  }
+  post(path, body) {
+    return __async(this, null, function* () {
+      const controller = new AbortController();
+      const timeout = setTimeout(
+        () => controller.abort(),
+        _NotesResource.REQUEST_TIMEOUT_MS
+      );
+      let res;
+      try {
+        res = yield fetch(`${this.baseUrl}/api${path}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "X-API-Key": this.apiKey
+          },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
+      } catch (err) {
+        const isAbort = err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+        const message = isAbort ? `Notes ${path} timed out after ${_NotesResource.REQUEST_TIMEOUT_MS}ms` : err instanceof Error ? err.message : "Notes request failed before response";
+        throw new NotesError(path, 0, message);
+      } finally {
+        clearTimeout(timeout);
+      }
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new NotesError(path, res.status, text.slice(0, 200));
+      }
+      return yield res.json();
+    });
+  }
+  /**
+   * Low-level — caller has already resolved Elation patient / physician
+   * / practice. Use `pushConversationToElation` if you only have a
+   * conversation handle.
+   */
+  pushToElation(input) {
+    return __async(this, null, function* () {
+      return yield this.post(
+        "/notes/push-to-elation",
+        input
+      );
+    });
+  }
+  /**
+   * Orchestrator — pass a conversation handle + pre-assembled note text.
+   * Truth resolves the linked patient via Convex, looks up
+   * physician/practice in Elation, posts the note, and writes an audit
+   * row to `elationSyncEvents`. Replaces CommHub's `pushNotesToElation`
+   * Hasura action.
+   */
+  pushConversationToElation(input) {
+    return __async(this, null, function* () {
+      return yield this.post(
+        "/notes/push-conversation-to-elation",
+        input
+      );
+    });
+  }
+};
+/** 30s upstream timeout — Elation API has occasional slow hops; we
+ *  don't want a pending mutation to hold the UI thread indefinitely. */
+_NotesResource.REQUEST_TIMEOUT_MS = 3e4;
+var NotesResource = _NotesResource;
+
+// src/resources/notifications.ts
+var NotificationsError = class extends Error {
+  constructor(operation, status, message) {
+    super(message != null ? message : `Notifications ${operation} failed (HTTP ${status})`);
+    this.name = "NotificationsError";
+    this.status = status;
+  }
+};
+var NotificationsResource = class {
+  constructor(apiBaseUrl, apiKey) {
+    this.baseUrl = apiBaseUrl;
+    this.apiKey = apiKey;
+  }
+  post(path, body) {
+    return __async(this, null, function* () {
+      const res = yield fetch(`${this.baseUrl}/api${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "X-API-Key": this.apiKey
+        },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new NotificationsError(path, res.status, text.slice(0, 200));
+      }
+      return yield res.json();
+    });
+  }
+  get(path, params) {
+    return __async(this, null, function* () {
+      const url = new URL(`${this.baseUrl}/api${path}`);
+      for (const [k, v] of Object.entries(params)) {
+        url.searchParams.set(k, v);
+      }
+      const res = yield fetch(url.toString(), {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+          "X-API-Key": this.apiKey
+        }
+      });
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new NotificationsError(path, res.status, text.slice(0, 200));
+      }
+      return yield res.json();
+    });
+  }
+  delete(path) {
+    return __async(this, null, function* () {
+      const res = yield fetch(`${this.baseUrl}/api${path}`, {
+        method: "DELETE",
+        headers: {
+          Accept: "application/json",
+          "X-API-Key": this.apiKey
+        }
+      });
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new NotificationsError(path, res.status, text.slice(0, 200));
+      }
+      return yield res.json();
+    });
+  }
+  /**
+   * Register a device (or refresh its metadata) for push delivery.
+   * Safe to call repeatedly — the server dedupes by native token.
+   */
+  registerDevice(input) {
+    return __async(this, null, function* () {
+      return this.post("/notifications/devices/register", input);
+    });
+  }
+  /** Revoke a device — on sign-out or when the OS reports an invalid token. */
+  unregisterDevice(input) {
+    return __async(this, null, function* () {
+      return this.post("/notifications/devices/unregister", input);
+    });
+  }
+  /**
+   * Send a push notification to every active device belonging to
+   * `userId`. Honors the user's notificationPreferences (quiet hours,
+   * DND, channel off) before publishing.
+   */
+  send(input) {
+    return __async(this, null, function* () {
+      return this.post("/notifications/send", input);
+    });
+  }
+  /** Read a user's notification preferences. Returns defaults when no row exists. */
+  getPreferences(userId) {
+    return __async(this, null, function* () {
+      return this.get("/notifications/preferences", { userId });
+    });
+  }
+  updatePreferences(input) {
+    return __async(this, null, function* () {
+      return this.post("/notifications/preferences", input);
+    });
+  }
+  /**
+   * Schedule a future push notification. Convex's native scheduler
+   * fires the send at `scheduledAt` and runs the same delivery
+   * pipeline as `send()` (preferences, devices, history audit).
+   *
+   * Throws `NotificationsError` with status 400 if `scheduledAt` is
+   * not strictly in the future.
+   */
+  schedule(input) {
+    return __async(this, null, function* () {
+      return this.post("/notifications/schedule", input);
+    });
+  }
+  /**
+   * Cancel a pending scheduled notification. Returns `cancelled: false`
+   * (no error) if the job has already executed, was previously
+   * cancelled, or no longer exists — `reason` describes which case.
+   */
+  cancelScheduled(jobId) {
+    return __async(this, null, function* () {
+      return this.delete(`/notifications/schedule/${encodeURIComponent(jobId)}`);
+    });
+  }
+  /**
+   * List scheduled notifications for a user — pending, executed,
+   * cancelled, or failed. Most-recent first. Default limit 100.
+   */
+  listScheduled(userId, options) {
+    return __async(this, null, function* () {
+      const params = { userId };
+      if ((options == null ? void 0 : options.limit) !== void 0) {
+        params.limit = String(options.limit);
+      }
+      return this.get("/notifications/schedule", params);
+    });
+  }
+  getVapidKey() {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.get(
+          "/notifications/vapid-key",
+          {}
+        );
+        return result.vapidPublicKey;
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  onPushReceived(callback) {
+    if (typeof navigator === "undefined" || !("serviceWorker" in navigator)) {
+      return () => {
+      };
+    }
+    const handler = (event) => {
+      var _a;
+      if (((_a = event.data) == null ? void 0 : _a.type) === "TRUTH_PUSH_RECEIVED") {
+        callback(event.data.payload);
+      }
+    };
+    navigator.serviceWorker.addEventListener("message", handler);
+    return () => navigator.serviceWorker.removeEventListener("message", handler);
+  }
+  onPushTapped(callback) {
+    if (typeof navigator === "undefined" || !("serviceWorker" in navigator)) {
+      return () => {
+      };
+    }
+    const handler = (event) => {
+      var _a;
+      if (((_a = event.data) == null ? void 0 : _a.type) === "TRUTH_PUSH_TAPPED") {
+        callback(event.data.payload);
+      }
+    };
+    navigator.serviceWorker.addEventListener("message", handler);
+    return () => navigator.serviceWorker.removeEventListener("message", handler);
+  }
+};
+
+// src/resources/patient-details.ts
+var PatientDetailsError = class extends Error {
+  constructor(operation, status, message) {
+    super(message != null ? message : `Patient ${operation} failed (HTTP ${status})`);
+    this.name = "PatientDetailsError";
+    this.status = status;
+  }
+};
+var PatientDetailsResource = class {
+  constructor(apiBaseUrl, apiKey) {
+    this.baseUrl = apiBaseUrl;
+    this.apiKey = apiKey;
+  }
+  post(path, body) {
+    return __async(this, null, function* () {
+      const res = yield fetch(`${this.baseUrl}/api${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "X-API-Key": this.apiKey
+        },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new PatientDetailsError(path, res.status, text.slice(0, 200));
+      }
+      return yield res.json();
+    });
+  }
+  get(input) {
+    return __async(this, null, function* () {
+      return yield this.post("/patients/details", input);
+    });
+  }
+  getBasic(input) {
+    return __async(this, null, function* () {
+      return yield this.post(
+        "/patients/details/basic",
+        input
+      );
+    });
+  }
+  getMedical(elationId) {
+    return __async(this, null, function* () {
+      return yield this.post(
+        "/patients/details/medical",
+        { elationId }
+      );
+    });
+  }
+  /**
+   * Trigger a server-side refresh of the patient's Elation medical
+   * records (medications, problems, allergies, appointments) into the
+   * Convex cache. Fire-and-forget — the UI should read via the Convex-
+   * reactive `usePatientMedical` hook.
+   */
+  refreshMedical(elationId) {
+    return __async(this, null, function* () {
+      return yield this.post("/patients/medical/refresh", { elationId });
+    });
+  }
+};
+
+// src/resources/patients.ts
+var PatientResource = class {
+  constructor(convexClient) {
+    this.convex = convexClient;
+  }
+  /**
+   * Get a patient by their Truth platform ID.
+   */
+  get(id) {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.convex.query(
+          "patients:getById",
+          {
+            id
+          }
+        );
+        return result != null ? result : null;
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  /**
+   * Get a patient by their Elation EHR ID.
+   */
+  getByElationId(elationId) {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.convex.query(
+          "patients:getByElationId",
+          { elationId }
+        );
+        return result != null ? result : null;
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  /**
+   * Get a patient by their Hint EHR ID.
+   */
+  getByHintId(hintId) {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.convex.query(
+          "patients:getByHintId",
+          {
+            hintId
+          }
+        );
+        return result != null ? result : null;
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  /**
+   * List patients with optional search, pagination, and limit.
+   */
+  list(options) {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.convex.query(
+          "patients:list",
+          {
+            search: options == null ? void 0 : options.search,
+            limit: options == null ? void 0 : options.limit,
+            cursor: options == null ? void 0 : options.cursor
+          }
+        );
+        const typed = result;
+        return typed != null ? typed : { data: [], cursor: null, hasMore: false };
+      } catch (e) {
+        return { data: [], cursor: null, hasMore: false };
+      }
+    });
+  }
+};
+
+// src/resources/physicians.ts
+var PhysiciansResource = class {
+  constructor(convex) {
+    this.convex = convex;
+  }
+  /**
+   * Resolve a batch of physicians by Elation IDs. Missing ids are dropped.
+   */
+  getByElationIds(ids) {
+    return __async(this, null, function* () {
+      if (ids.length === 0) {
+        return [];
+      }
+      try {
+        const rows = yield this.convex.query(
+          "physicians:getByElationIds",
+          { ids }
+        );
+        return rows != null ? rows : [];
+      } catch (e) {
+        return [];
+      }
+    });
+  }
+  getByElationId(id) {
+    return __async(this, null, function* () {
+      try {
+        const row = yield this.convex.query(
+          "physicians:getByElationId",
+          { id }
+        );
+        return row != null ? row : null;
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  listByPractice(practice, limit) {
+    return __async(this, null, function* () {
+      try {
+        const rows = yield this.convex.query(
+          "physicians:listByPractice",
+          { practice, limit }
+        );
+        return rows != null ? rows : [];
+      } catch (e) {
+        return [];
+      }
+    });
+  }
+};
+
+// src/resources/reminders.ts
+var RemindersResource = class {
+  constructor(convexClient) {
+    this.convex = convexClient;
+  }
+  /**
+   * Schedule a reminder to fire at `remindAt`. Returns the reminder id,
+   * which callers should store if they may want to cancel it later.
+   */
+  schedule(input) {
+    return __async(this, null, function* () {
+      const remindAt = input.remindAt instanceof Date ? input.remindAt.toISOString() : input.remindAt;
+      const result = yield this.convex.mutation(
+        "reminders:schedule",
+        {
+          conversationId: input.conversationId,
+          remindAt,
+          note: input.note,
+          createdBy: input.createdBy
+        }
+      );
+      return result;
+    });
+  }
+  /**
+   * Cancel a pending reminder. No-op if the reminder has already fired or
+   * been cancelled.
+   */
+  cancel(reminderId, cancelledBy) {
+    return __async(this, null, function* () {
+      return yield this.convex.mutation(
+        "reminders:cancel",
+        { reminderId, cancelledBy }
+      );
+    });
+  }
+  /**
+   * List reminders for a conversation (most recent first).
+   */
+  listByConversation(conversationId) {
+    return __async(this, null, function* () {
+      try {
+        const rows = yield this.convex.query(
+          "reminders:listByConversation",
+          { conversationId }
+        );
+        return rows != null ? rows : [];
+      } catch (e) {
+        return [];
+      }
+    });
+  }
+};
+
+// src/resources/tasks.ts
+var TasksResource = class {
+  constructor(convexClient) {
+    this.convex = convexClient;
+  }
+  create(input) {
+    return __async(this, null, function* () {
+      return yield this.convex.mutation(
+        "tasks:create",
+        input
+      );
+    });
+  }
+  updateStatus(input) {
+    return __async(this, null, function* () {
+      return yield this.convex.mutation(
+        "tasks:updateStatus",
+        input
+      );
+    });
+  }
+  get(taskId) {
+    return __async(this, null, function* () {
+      try {
+        const row = yield this.convex.query(
+          "tasks:get",
+          { taskId }
+        );
+        return row != null ? row : null;
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  listByAssignee(assignedTo, options) {
+    return __async(this, null, function* () {
+      try {
+        const rows = yield this.convex.query(
+          "tasks:listByAssignee",
+          {
+            assignedTo,
+            status: options == null ? void 0 : options.status,
+            limit: options == null ? void 0 : options.limit
+          }
+        );
+        return rows != null ? rows : [];
+      } catch (e) {
+        return [];
+      }
+    });
+  }
+  listOpen(limit) {
+    return __async(this, null, function* () {
+      try {
+        const rows = yield this.convex.query(
+          "tasks:listOpen",
+          { limit }
+        );
+        return rows != null ? rows : [];
+      } catch (e) {
+        return [];
+      }
+    });
+  }
+  /**
+   * Mark a conversation task as seen by the given user. Appends `userId`
+   * to the `seenBy` array on the `conversationTasks` row if not already
+   * present. Replaces CommHub's `useMark_Event_Activity_SeenMutation`.
+   *
+   * @returns `{ ok: true }` on success.
+   * @throws if the task does not exist in Convex.
+   */
+  markSeen(input) {
+    return __async(this, null, function* () {
+      return yield this.convex.mutation(
+        "conversationTasks:markSeen",
+        input
+      );
+    });
+  }
+};
+
+// src/resources/translation.ts
+var TranslationError = class extends Error {
+  constructor(operation, status, message) {
+    super(message != null ? message : `Translation ${operation} failed (HTTP ${status})`);
+    this.name = "TranslationError";
+    this.status = status;
+    this.operation = operation;
+  }
+};
+var TranslationResource = class {
+  constructor(apiBaseUrl, apiKey) {
+    this.baseUrl = apiBaseUrl;
+    this.apiKey = apiKey;
+  }
+  post(path, body) {
+    return __async(this, null, function* () {
+      const url = `${this.baseUrl}/api${path}`;
+      const res = yield fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "X-API-Key": this.apiKey
+        },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new TranslationError(path, res.status, text.slice(0, 200));
+      }
+      return yield res.json();
+    });
+  }
+  translate(input) {
+    return __async(this, null, function* () {
+      return yield this.post("/translation/translate", input);
+    });
+  }
+  translateBatch(input) {
+    return __async(this, null, function* () {
+      const response = yield this.post(
+        "/translation/translate-batch",
+        input
+      );
+      return response.results;
+    });
+  }
+  detect(text) {
+    return __async(this, null, function* () {
+      return yield this.post("/translation/detect", { text });
+    });
+  }
+};
+
+// src/resources/user-settings.ts
+var import_server4 = require("convex/server");
+var upsertNotificationsRef = (0, import_server4.makeFunctionReference)("userSettings:upsertNotifications");
+var UserSettingsResource = class {
+  constructor(convex) {
+    this.convex = convex;
+  }
+  /**
+   * Upsert notification preferences for a user. Creates the row if it
+   * doesn't exist; patches `notificationsEnabled` + `updatedAt` otherwise.
+   */
+  updateNotifications(input) {
+    return __async(this, null, function* () {
+      return this.convex.mutation(upsertNotificationsRef, input);
+    });
+  }
+};
+
+// src/tracking/tracker.ts
+function generateUuidV7() {
+  const now = Date.now();
+  const timeBytes = new Uint8Array(6);
+  let ts = now;
+  for (let i = 5; i >= 0; i--) {
+    timeBytes[i] = ts & 255;
+    ts = Math.floor(ts / 256);
+  }
+  const randomBytes = new Uint8Array(10);
+  if (typeof globalThis.crypto !== "undefined" && globalThis.crypto.getRandomValues) {
+    globalThis.crypto.getRandomValues(randomBytes);
+  } else {
+    for (let i = 0; i < 10; i++) {
+      randomBytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  const bytes = new Uint8Array(16);
+  bytes.set(timeBytes, 0);
+  bytes.set(randomBytes, 6);
+  bytes[6] = bytes[6] & 15 | 112;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20, 32)
+  ].join("-");
+}
+var API_URLS = {
+  local: "http://localhost:3000",
+  staging: "https://app.sandbox.communication-hub.com",
+  stg: "https://app.sandbox.communication-hub.com",
+  sandbox: "https://app.sandbox.communication-hub.com",
+  uat: "https://app.truth.communication-hub.com",
+  production: "https://app.truth.communication-hub.com"
+};
+var DEFAULT_BATCH_SIZE = 25;
+var DEFAULT_FLUSH_INTERVAL_MS = 5e3;
+var MAX_RETRIES = 3;
+var BASE_RETRY_DELAY_MS = 500;
+var Tracker = class {
+  constructor(config) {
+    this.queue = [];
+    this.flushTimer = null;
+    this.isFlushing = false;
+    this.isShutdown = false;
+    var _a, _b;
+    this.config = config;
+    this.apiUrl = (_b = (_a = config.apiBaseUrl) != null ? _a : API_URLS[config.environment]) != null ? _b : API_URLS.local;
+    this.startFlushInterval();
+    this.registerShutdownHooks();
+  }
+  /**
+   * Set the default actor context for subsequent events.
+   */
+  setActor(actor) {
+    this.defaultActor = actor;
+  }
+  /**
+   * Enqueue a typed event for delivery. This is fire-and-forget from
+   * the caller's perspective -- events are buffered and flushed in batches.
+   */
+  track(eventType, payload, options) {
+    var _a, _b, _c;
+    if (this.isShutdown) {
+      return;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const envelope = {
+      event_id: generateUuidV7(),
+      event_type: eventType,
+      schema_version: 1,
+      occurred_at: (_a = options == null ? void 0 : options.occurredAt) != null ? _a : now,
+      received_at: now,
+      source: this.config.source,
+      source_version: this.config.sourceVersion,
+      tenant_id: (_b = options == null ? void 0 : options.tenantId) != null ? _b : this.config.tenantId,
+      actor: (_c = options == null ? void 0 : options.actor) != null ? _c : this.defaultActor ? {
+        actor_id: this.defaultActor.actorId,
+        actor_type: this.defaultActor.actorType
+      } : void 0,
+      subject: options == null ? void 0 : options.subject,
+      compliance: options == null ? void 0 : options.compliance,
+      payload
+    };
+    this.queue.push(envelope);
+    if (this.queue.length >= this.config.batchSize) {
+      void this.flush();
+    }
+  }
+  /**
+   * Force an immediate flush of all buffered events.
+   * Returns a promise that resolves when the flush completes.
+   */
+  flush() {
+    return __async(this, null, function* () {
+      if (this.queue.length === 0 || this.isFlushing) {
+        return;
+      }
+      this.isFlushing = true;
+      const batch = this.queue.splice(0, this.config.batchSize);
+      try {
+        yield this.sendBatch(batch);
+      } catch (e) {
+        this.queue.unshift(...batch);
+      } finally {
+        this.isFlushing = false;
+      }
+      if (this.queue.length >= this.config.batchSize) {
+        yield this.flush();
+      }
+    });
+  }
+  /**
+   * Gracefully shut down the tracker. Flushes remaining events and
+   * clears the flush interval.
+   */
+  shutdown() {
+    return __async(this, null, function* () {
+      this.isShutdown = true;
+      this.stopFlushInterval();
+      yield this.flush();
+    });
+  }
+  /**
+   * Send a batch of events to the Truth API with exponential backoff retry.
+   */
+  sendBatch(batch) {
+    return __async(this, null, function* () {
+      let lastError;
+      for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        try {
+          const response = yield fetch(`${this.apiUrl}/api/events/ingest`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "X-API-Key": this.config.apiKey
+            },
+            body: JSON.stringify({ events: batch })
+          });
+          if (response.ok) {
+            return;
+          }
+          if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+            return;
+          }
+          lastError = new Error(
+            `HTTP ${response.status}: ${response.statusText}`
+          );
+        } catch (error) {
+          lastError = error;
+        }
+        if (attempt < MAX_RETRIES) {
+          const delay = BASE_RETRY_DELAY_MS * __pow(2, attempt);
+          const jitter = Math.random() * delay * 0.5;
+          yield sleep(delay + jitter);
+        }
+      }
+      throw lastError;
+    });
+  }
+  startFlushInterval() {
+    if (this.config.flushIntervalMs > 0) {
+      this.flushTimer = setInterval(() => {
+        void this.flush();
+      }, this.config.flushIntervalMs);
+      if (typeof this.flushTimer === "object" && "unref" in this.flushTimer) {
+        this.flushTimer.unref();
+      }
+    }
+  }
+  stopFlushInterval() {
+    if (this.flushTimer !== null) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  registerShutdownHooks() {
+    if (typeof globalThis.process !== "undefined" && globalThis.process.on) {
+      const shutdownHandler = () => {
+        void this.shutdown();
+      };
+      globalThis.process.on("beforeExit", shutdownHandler);
+      globalThis.process.on("SIGTERM", shutdownHandler);
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/web-push.ts
+function isWebPushSupported() {
+  return typeof window !== "undefined" && "serviceWorker" in navigator && "PushManager" in window;
+}
+function registerServiceWorker(path = "/truth-sw.js") {
+  return __async(this, null, function* () {
+    return navigator.serviceWorker.register(path);
+  });
+}
+function subscribeToPush(registration, vapidPublicKey) {
+  return __async(this, null, function* () {
+    const existing = yield registration.pushManager.getSubscription();
+    if (existing) {
+      return existing;
+    }
+    return registration.pushManager.subscribe({
+      userVisibleOnly: true,
+      applicationServerKey: urlBase64ToUint8Array(
+        vapidPublicKey
+      )
+    });
+  });
+}
+function subscriptionToJSON(sub) {
+  var _a, _b, _c, _d;
+  const json = sub.toJSON();
+  return {
+    endpoint: sub.endpoint,
+    keys: {
+      p256dh: (_b = (_a = json.keys) == null ? void 0 : _a.p256dh) != null ? _b : "",
+      auth: (_d = (_c = json.keys) == null ? void 0 : _c.auth) != null ? _d : ""
+    }
+  };
+}
+function urlBase64ToUint8Array(base64String) {
+  const padding = "=".repeat((4 - base64String.length % 4) % 4);
+  const base64 = (base64String + padding).replace(/-/g, "+").replace(/_/g, "/");
+  const rawData = atob(base64);
+  const outputArray = new Uint8Array(rawData.length);
+  for (let i = 0; i < rawData.length; ++i) {
+    outputArray[i] = rawData.charCodeAt(i);
+  }
+  return outputArray;
+}
+
+// src/client.ts
+var CONVEX_URLS = {
+  local: "https://courteous-duck-623.convex.cloud",
+  staging: "https://courteous-duck-623.convex.cloud",
+  stg: "https://courteous-duck-623.convex.cloud",
+  sandbox: "https://courteous-duck-623.convex.cloud",
+  uat: "https://gallant-gecko-217.convex.cloud",
+  production: "https://gallant-gecko-217.convex.cloud"
+};
+var TruthClient = class {
+  constructor(config) {
+    this._vapidPublicKey = null;
+    this._webPushReady = null;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const convexUrl = (_b = (_a = config.convexUrl) != null ? _a : CONVEX_URLS[config.environment]) != null ? _b : CONVEX_URLS.local;
+    this.convex = new import_browser.ConvexHttpClient(convexUrl);
+    this.tracker = new Tracker({
+      apiKey: config.apiKey,
+      environment: config.environment,
+      source: (_c = config.source) != null ? _c : "unknown",
+      sourceVersion: (_d = config.sourceVersion) != null ? _d : "unknown",
+      tenantId: (_e = config.tenantId) != null ? _e : "",
+      batchSize: (_f = config.batchSize) != null ? _f : DEFAULT_BATCH_SIZE,
+      flushIntervalMs: (_g = config.flushIntervalMs) != null ? _g : DEFAULT_FLUSH_INTERVAL_MS,
+      apiBaseUrl: config.apiBaseUrl
+    });
+    const apiUrl = this.tracker.apiUrl;
+    this.patients = new PatientResource(this.convex);
+    this.appointments = new AppointmentResource(this.convex);
+    this.ehr = new EhrResource(apiUrl);
+    this.messages = new MessagesResource(apiUrl, config.apiKey);
+    this.reminders = new RemindersResource(this.convex);
+    this.translation = new TranslationResource(apiUrl, config.apiKey);
+    this.tasks = new TasksResource(this.convex);
+    this.patientDetails = new PatientDetailsResource(apiUrl, config.apiKey);
+    this.attachments = new AttachmentsResource(
+      apiUrl,
+      config.apiKey,
+      this.convex
+    );
+    this.notes = new NotesResource(apiUrl, config.apiKey);
+    this.physicians = new PhysiciansResource(this.convex);
+    this.notifications = new NotificationsResource(apiUrl, config.apiKey);
+    this.conversations = new ConversationsResource(
+      apiUrl,
+      config.apiKey,
+      this.convex
+    );
+    this.userSettings = new UserSettingsResource(this.convex);
+    this._serviceWorkerPath = (_h = config.serviceWorkerPath) != null ? _h : "/truth-sw.js";
+    if (typeof window !== "undefined" && isWebPushSupported() && config.autoInitServiceWorker !== false) {
+      this._webPushReady = this.initWebPush();
+    }
+  }
+  get vapidPublicKey() {
+    return this._vapidPublicKey;
+  }
+  get webPushReady() {
+    return this._webPushReady;
+  }
+  initWebPush() {
+    return __async(this, null, function* () {
+      try {
+        const key = yield this.notifications.getVapidKey();
+        if (!key) {
+          return;
+        }
+        this._vapidPublicKey = key;
+        const registration = yield registerServiceWorker(this._serviceWorkerPath);
+        yield navigator.serviceWorker.ready;
+        const subscription = yield subscribeToPush(registration, key);
+        const subJSON = subscriptionToJSON(subscription);
+        yield this.notifications.registerDevice({
+          userId: "__pending__",
+          platform: "web",
+          webPushSubscription: subJSON,
+          locale: navigator.language,
+          timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+        });
+      } catch (e) {
+      }
+    });
+  }
+  /**
+   * The resolved Truth API base URL for this environment.
+   * Use this when making HTTP calls to Truth's proxy endpoints
+   * (e.g., EHR proxy, messages proxy).
+   *
+   * @example
+   * ```ts
+   * const url = `${truth.apiBaseUrl}/api/ehr/elation/patients/123`;
+   * ```
+   */
+  get apiBaseUrl() {
+    return this.tracker.apiUrl;
+  }
+  /**
+   * Track an event. Fire-and-forget -- the event is buffered internally
+   * and flushed in batches to the Truth API.
+   *
+   * @example
+   * ```ts
+   * truth.track('conversation.message_sent.v1', {
+   *   channel: 'sms',
+   *   direction: 'outbound',
+   *   message_chars: 140,
+   *   has_attachment: false,
+   *   provider_system: 'dialpad',
+   * });
+   * ```
+   */
+  track(eventType, payload, options) {
+    this.tracker.track(eventType, payload, options);
+  }
+  /**
+   * Set the default actor context for all subsequent tracked events.
+   * Can be overridden per-event via TrackOptions.
+   *
+   * @example
+   * ```ts
+   * truth.identify('user_123', 'user');
+   * ```
+   */
+  identify(actorId, actorType) {
+    this.tracker.setActor({ actorId, actorType });
+  }
+  /**
+   * Flush all buffered events immediately. Returns a Promise that resolves
+   * when the flush completes. Use this for graceful shutdown.
+   *
+   * @example
+   * ```ts
+   * process.on('SIGTERM', async () => {
+   *   await truth.flush();
+   *   process.exit(0);
+   * });
+   * ```
+   */
+  flush() {
+    return __async(this, null, function* () {
+      yield this.tracker.flush();
+    });
+  }
+  /**
+   * Gracefully shut down the client. Flushes all pending events and
+   * releases resources.
+   */
+  destroy() {
+    return __async(this, null, function* () {
+      yield this.tracker.shutdown();
+    });
+  }
+};
+
+// src/react/provider.ts
+var CONVEX_URLS2 = {
+  local: "https://courteous-duck-623.convex.cloud",
+  staging: "https://courteous-duck-623.convex.cloud",
+  stg: "https://courteous-duck-623.convex.cloud",
+  sandbox: "https://courteous-duck-623.convex.cloud",
+  uat: "https://gallant-gecko-217.convex.cloud",
+  production: "https://gallant-gecko-217.convex.cloud"
+};
+var API_BASE_URLS = {
+  local: "https://app.sandbox.communication-hub.com",
+  staging: "https://app.sandbox.communication-hub.com",
+  stg: "https://app.sandbox.communication-hub.com",
+  sandbox: "https://app.sandbox.communication-hub.com",
+  uat: "https://app.truth.communication-hub.com",
+  production: "https://app.truth.communication-hub.com"
+};
+function resolveConvexUrl(environment, override) {
+  var _a;
+  if (override) {
+    return override;
+  }
+  const env = environment != null ? environment : "sandbox";
+  return (_a = CONVEX_URLS2[env]) != null ? _a : CONVEX_URLS2.sandbox;
+}
+function resolveApiBaseUrl(environment, override) {
+  var _a;
+  if (override) {
+    return override;
+  }
+  const env = environment != null ? environment : "sandbox";
+  return (_a = API_BASE_URLS[env]) != null ? _a : API_BASE_URLS.sandbox;
+}
+function readEnv(name) {
+  if (typeof process === "undefined" || !process.env) {
+    return void 0;
+  }
+  const v = process.env[name];
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+var TruthSdkContext = (0, import_react6.createContext)(null);
+function useTruthSdkContext() {
+  return (0, import_react6.useContext)(TruthSdkContext);
+}
+function useTruthClient() {
+  const ctx = (0, import_react6.useContext)(TruthSdkContext);
+  if (!ctx) {
+    throw new Error(
+      "useTruthClient() called outside <TruthProvider>. Wrap your app in <TruthProvider> from @hipnation-truth/sdk/react."
+    );
+  }
+  return ctx.client;
+}
+var _activeClient = null;
+function getTruthClient() {
+  if (!_activeClient) {
+    throw new Error(
+      "getTruthClient() called before <TruthProvider> mounted. Either wrap your app in <TruthProvider> or call useTruthClient() inside a component."
+    );
+  }
+  return _activeClient;
+}
+function TruthProvider({
+  environment = "sandbox",
+  convexUrl,
+  apiBaseUrl,
+  apiKey,
+  source,
+  sourceVersion,
+  tenantId,
+  children
+}) {
+  var _a, _b;
+  const url = resolveConvexUrl(environment, convexUrl);
+  const resolvedApiBaseUrl = (_a = apiBaseUrl != null ? apiBaseUrl : readEnv("EXPO_PUBLIC_TRUTH_API_BASE_URL")) != null ? _a : resolveApiBaseUrl(environment);
+  const resolvedApiKey = (_b = apiKey != null ? apiKey : readEnv("EXPO_PUBLIC_TRUTH_API_KEY")) != null ? _b : "";
+  const convexClient = (0, import_react6.useMemo)(() => new import_react5.ConvexReactClient(url), [url]);
+  const truthClient = (0, import_react6.useMemo)(
+    () => new TruthClient({
+      apiKey: resolvedApiKey,
+      environment,
+      apiBaseUrl: resolvedApiBaseUrl,
+      source: source != null ? source : "unknown",
+      sourceVersion: sourceVersion != null ? sourceVersion : "unknown",
+      tenantId: tenantId != null ? tenantId : "",
+      autoInitServiceWorker: false
+    }),
+    [
+      resolvedApiKey,
+      resolvedApiBaseUrl,
+      environment,
+      source,
+      sourceVersion,
+      tenantId
+    ]
+  );
+  (0, import_react6.useEffect)(() => {
+    _activeClient = truthClient;
+    return () => {
+      if (_activeClient === truthClient) {
+        _activeClient = null;
+      }
+    };
+  }, [truthClient]);
+  const sdkContext = (0, import_react6.useMemo)(
+    () => ({
+      apiBaseUrl: resolvedApiBaseUrl,
+      apiKey: resolvedApiKey,
+      environment,
+      client: truthClient
+    }),
+    [resolvedApiBaseUrl, resolvedApiKey, environment, truthClient]
+  );
+  return (0, import_react6.createElement)(
+    TruthSdkContext.Provider,
+    { value: sdkContext },
+    (0, import_react6.createElement)(import_react5.ConvexProvider, { client: convexClient }, children)
+  );
+}
+
+// src/react/hooks.ts
+var import_server5 = require("convex/server");
+var patientsListRef = (0, import_server5.makeFunctionReference)("patients:list");
+var patientsGetRef = (0, import_server5.makeFunctionReference)("patients:get");
+var patientsByElationIdRef = (0, import_server5.makeFunctionReference)("patients:getByElationId");
+var patientsByHintIdRef = (0, import_server5.makeFunctionReference)("patients:getByHintId");
+var appointmentsListRef = (0, import_server5.makeFunctionReference)("appointments:list");
+var appointmentsGetRef = (0, import_server5.makeFunctionReference)("appointments:get");
+var appointmentsByElationIdRef = (0, import_server5.makeFunctionReference)("appointments:getByElationId");
 function usePatients(options) {
-  return (0, import_react5.useQuery)(patientsListRef, options != null ? options : {});
+  return (0, import_react7.useQuery)(patientsListRef, options != null ? options : {});
 }
 function usePatient(id) {
-  return (0, import_react5.useQuery)(patientsGetRef, { id });
+  return (0, import_react7.useQuery)(patientsGetRef, { id });
 }
 function usePatientByElationId(elationId) {
-  return (0, import_react5.useQuery)(patientsByElationIdRef, {
+  return (0, import_react7.useQuery)(patientsByElationIdRef, {
     elationId
   });
 }
 function usePatientByHintId(hintId) {
-  return (0, import_react5.useQuery)(patientsByHintIdRef, {
+  return (0, import_react7.useQuery)(patientsByHintIdRef, {
     hintId
   });
 }
 function useAppointments(options) {
-  return (0, import_react5.useQuery)(
+  return (0, import_react7.useQuery)(
     appointmentsListRef,
     options != null ? options : {}
   );
 }
 function useAppointment(id) {
-  return (0, import_react5.useQuery)(appointmentsGetRef, { id });
+  return (0, import_react7.useQuery)(appointmentsGetRef, { id });
 }
 function useAppointmentByElationId(elationId) {
-  return (0, import_react5.useQuery)(appointmentsByElationIdRef, {
+  return (0, import_react7.useQuery)(appointmentsByElationIdRef, {
     elationId
   });
 }
-var physiciansGetByElationIdsRef = (0, import_server4.makeFunctionReference)("physicians:getByElationIds");
-var physiciansGetByElationIdRef = (0, import_server4.makeFunctionReference)("physicians:getByElationId");
+var physiciansGetByElationIdsRef = (0, import_server5.makeFunctionReference)("physicians:getByElationIds");
+var physiciansGetByElationIdRef = (0, import_server5.makeFunctionReference)("physicians:getByElationId");
 function usePhysiciansByElationIds(ids) {
-  return (0, import_react5.useQuery)(
+  return (0, import_react7.useQuery)(
     physiciansGetByElationIdsRef,
     ids && ids.length > 0 ? { ids } : "skip"
   );
 }
 function usePhysicianByElationId(id) {
-  return (0, import_react5.useQuery)(
+  return (0, import_react7.useQuery)(
     physiciansGetByElationIdRef,
     id !== void 0 ? { id } : "skip"
   );
 }
-var medicationsByPatientRef = (0, import_server4.makeFunctionReference)("medicalRecords:getMedicationsByElationPatient");
-var problemsByPatientRef = (0, import_server4.makeFunctionReference)("medicalRecords:getProblemsByElationPatient");
-var allergiesByPatientRef = (0, import_server4.makeFunctionReference)("medicalRecords:getAllergiesByElationPatient");
-var appointmentsByPatientRef = (0, import_server4.makeFunctionReference)("medicalRecords:getAppointmentsByElationPatient");
+var medicationsByPatientRef = (0, import_server5.makeFunctionReference)("medicalRecords:getMedicationsByElationPatient");
+var problemsByPatientRef = (0, import_server5.makeFunctionReference)("medicalRecords:getProblemsByElationPatient");
+var allergiesByPatientRef = (0, import_server5.makeFunctionReference)("medicalRecords:getAllergiesByElationPatient");
+var appointmentsByPatientRef = (0, import_server5.makeFunctionReference)("medicalRecords:getAppointmentsByElationPatient");
 function usePatientMedical(elationId, options) {
-  const medications = (0, import_react5.useQuery)(
+  var _a, _b;
+  const sdkContext = useTruthSdkContext();
+  const apiBaseUrl = (_a = options == null ? void 0 : options.apiBaseUrl) != null ? _a : sdkContext == null ? void 0 : sdkContext.apiBaseUrl;
+  const apiKey = (_b = options == null ? void 0 : options.apiKey) != null ? _b : sdkContext == null ? void 0 : sdkContext.apiKey;
+  const medications = (0, import_react7.useQuery)(
     medicationsByPatientRef,
     elationId !== void 0 ? { elationPatientId: elationId } : "skip"
   );
-  const problems = (0, import_react5.useQuery)(
+  const problems = (0, import_react7.useQuery)(
     problemsByPatientRef,
     elationId !== void 0 ? { elationPatientId: elationId } : "skip"
   );
-  const allergies = (0, import_react5.useQuery)(
+  const allergies = (0, import_react7.useQuery)(
     allergiesByPatientRef,
     elationId !== void 0 ? { elationPatientId: elationId } : "skip"
   );
-  const appointments = (0, import_react5.useQuery)(
+  const appointments = (0, import_react7.useQuery)(
     appointmentsByPatientRef,
     elationId !== void 0 ? { elationPatientId: elationId } : "skip"
   );
-  (0, import_react6.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     if (elationId === void 0 || (options == null ? void 0 : options.skipRefresh)) {
       return;
     }
-    const apiBaseUrl = options == null ? void 0 : options.apiBaseUrl;
-    const apiKey = options == null ? void 0 : options.apiKey;
     if (!apiBaseUrl || !apiKey) {
       return;
     }
@@ -434,32 +2528,33 @@ function usePatientMedical(elationId, options) {
     }).catch(() => {
     });
     return () => controller.abort();
-  }, [elationId, options == null ? void 0 : options.apiBaseUrl, options == null ? void 0 : options.apiKey, options == null ? void 0 : options.skipRefresh]);
+  }, [elationId, apiBaseUrl, apiKey, options == null ? void 0 : options.skipRefresh]);
   return { medications, problems, allergies, appointments };
 }
-var elationPatientByIdRef = (0, import_server4.makeFunctionReference)("elationPatients:getByElationId");
-var hintPatientByIdRef = (0, import_server4.makeFunctionReference)("hintPatients:getByHintId");
-var pharmacyByNcpdpRef = (0, import_server4.makeFunctionReference)("elationPharmacies:getByNcpdpId");
-var patientPhotoByIdRef = (0, import_server4.makeFunctionReference)("elationPatientPhotos:getByElationPatientId");
+var elationPatientByIdRef = (0, import_server5.makeFunctionReference)("elationPatients:getByElationId");
+var hintPatientByIdRef = (0, import_server5.makeFunctionReference)("hintPatients:getByHintId");
+var pharmacyByNcpdpRef = (0, import_server5.makeFunctionReference)("elationPharmacies:getByNcpdpId");
+var patientPhotoByIdRef = (0, import_server5.makeFunctionReference)("elationPatientPhotos:getByElationPatientId");
 function usePatientBasic(input, options) {
-  var _a, _b;
-  const elationRow = (0, import_react5.useQuery)(
+  var _a, _b, _c, _d;
+  const sdkContext = useTruthSdkContext();
+  const apiBaseUrl = (_a = options == null ? void 0 : options.apiBaseUrl) != null ? _a : sdkContext == null ? void 0 : sdkContext.apiBaseUrl;
+  const apiKey = (_b = options == null ? void 0 : options.apiKey) != null ? _b : sdkContext == null ? void 0 : sdkContext.apiKey;
+  const elationRow = (0, import_react7.useQuery)(
     elationPatientByIdRef,
     input.elationId !== void 0 ? { elationId: input.elationId } : "skip"
   );
-  const hintRow = (0, import_react5.useQuery)(
+  const hintRow = (0, import_react7.useQuery)(
     hintPatientByIdRef,
     input.hintId !== void 0 ? { hintId: input.hintId } : "skip"
   );
-  (0, import_react6.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     if (options == null ? void 0 : options.skipRefresh) {
       return;
     }
     if (!input.hintId && input.elationId === void 0) {
       return;
     }
-    const apiBaseUrl = options == null ? void 0 : options.apiBaseUrl;
-    const apiKey = options == null ? void 0 : options.apiKey;
     if (!apiBaseUrl || !apiKey) {
       return;
     }
@@ -478,15 +2573,9 @@ function usePatientBasic(input, options) {
     }).catch(() => {
     });
     return () => controller.abort();
-  }, [
-    input.hintId,
-    input.elationId,
-    options == null ? void 0 : options.apiBaseUrl,
-    options == null ? void 0 : options.apiKey,
-    options == null ? void 0 : options.skipRefresh
-  ]);
-  const elationPatient = elationRow === void 0 ? void 0 : elationRow === null ? null : (_a = elationRow.raw) != null ? _a : null;
-  const hintPatient = hintRow === void 0 ? void 0 : hintRow === null ? null : (_b = hintRow.raw) != null ? _b : null;
+  }, [input.hintId, input.elationId, apiBaseUrl, apiKey, options == null ? void 0 : options.skipRefresh]);
+  const elationPatient = elationRow === void 0 ? void 0 : elationRow === null ? null : (_c = elationRow.raw) != null ? _c : null;
+  const hintPatient = hintRow === void 0 ? void 0 : hintRow === null ? null : (_d = hintRow.raw) != null ? _d : null;
   const elationLoading = input.elationId !== void 0 && elationRow === void 0;
   const hintLoading = input.hintId !== void 0 && hintRow === void 0;
   return {
@@ -498,25 +2587,27 @@ function usePatientBasic(input, options) {
   };
 }
 function usePharmacyByNcpdpId(ncpdpId) {
-  return (0, import_react5.useQuery)(
+  return (0, import_react7.useQuery)(
     pharmacyByNcpdpRef,
     ncpdpId ? { ncpdpId } : "skip"
   );
 }
 function usePatientPhoto(elationId, options) {
-  const photo = (0, import_react5.useQuery)(
+  var _a, _b;
+  const sdkContext = useTruthSdkContext();
+  const apiBaseUrl = (_a = options == null ? void 0 : options.apiBaseUrl) != null ? _a : sdkContext == null ? void 0 : sdkContext.apiBaseUrl;
+  const apiKey = (_b = options == null ? void 0 : options.apiKey) != null ? _b : sdkContext == null ? void 0 : sdkContext.apiKey;
+  const photo = (0, import_react7.useQuery)(
     patientPhotoByIdRef,
     elationId !== void 0 ? { elationPatientId: elationId } : "skip"
   );
-  (0, import_react6.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     if (options == null ? void 0 : options.skipRefresh) {
       return;
     }
     if (elationId === void 0) {
       return;
     }
-    const apiBaseUrl = options == null ? void 0 : options.apiBaseUrl;
-    const apiKey = options == null ? void 0 : options.apiKey;
     if (!apiBaseUrl || !apiKey) {
       return;
     }
@@ -532,14 +2623,14 @@ function usePatientPhoto(elationId, options) {
     }).catch(() => {
     });
     return () => controller.abort();
-  }, [elationId, options == null ? void 0 : options.apiBaseUrl, options == null ? void 0 : options.apiKey, options == null ? void 0 : options.skipRefresh]);
+  }, [elationId, apiBaseUrl, apiKey, options == null ? void 0 : options.skipRefresh]);
   return photo;
 }
-var messagesByPhonesRef = (0, import_server4.makeFunctionReference)("conversationMessages:getByPhones");
-var messagesByConversationIdRef = (0, import_server4.makeFunctionReference)("conversationMessages:getByConversationId");
+var messagesByPhonesRef = (0, import_server5.makeFunctionReference)("conversationMessages:getByPhones");
+var messagesByConversationIdRef = (0, import_server5.makeFunctionReference)("conversationMessages:getByConversationId");
 function useConversationMessages(input, options) {
   const hasPair = !!input.phoneA && !!input.phoneB;
-  const byPair = (0, import_react5.useQuery)(
+  const byPair = (0, import_react7.useQuery)(
     messagesByPhonesRef,
     hasPair ? {
       phoneA: input.phoneA,
@@ -547,7 +2638,7 @@ function useConversationMessages(input, options) {
       limit: options == null ? void 0 : options.limit
     } : "skip"
   );
-  const byConvo = (0, import_react5.useQuery)(
+  const byConvo = (0, import_react7.useQuery)(
     messagesByConversationIdRef,
     !hasPair && input.conversationId ? { conversationId: input.conversationId, limit: options == null ? void 0 : options.limit } : "skip"
   );
@@ -555,54 +2646,7 @@ function useConversationMessages(input, options) {
 }
 
 // src/react/notifications.ts
-var import_react7 = require("react");
-
-// src/web-push.ts
-function isWebPushSupported() {
-  return typeof window !== "undefined" && "serviceWorker" in navigator && "PushManager" in window;
-}
-function registerServiceWorker(path = "/truth-sw.js") {
-  return __async(this, null, function* () {
-    return navigator.serviceWorker.register(path);
-  });
-}
-function subscribeToPush(registration, vapidPublicKey) {
-  return __async(this, null, function* () {
-    const existing = yield registration.pushManager.getSubscription();
-    if (existing) {
-      return existing;
-    }
-    return registration.pushManager.subscribe({
-      userVisibleOnly: true,
-      applicationServerKey: urlBase64ToUint8Array(
-        vapidPublicKey
-      )
-    });
-  });
-}
-function subscriptionToJSON(sub) {
-  var _a, _b, _c, _d;
-  const json = sub.toJSON();
-  return {
-    endpoint: sub.endpoint,
-    keys: {
-      p256dh: (_b = (_a = json.keys) == null ? void 0 : _a.p256dh) != null ? _b : "",
-      auth: (_d = (_c = json.keys) == null ? void 0 : _c.auth) != null ? _d : ""
-    }
-  };
-}
-function urlBase64ToUint8Array(base64String) {
-  const padding = "=".repeat((4 - base64String.length % 4) % 4);
-  const base64 = (base64String + padding).replace(/-/g, "+").replace(/_/g, "/");
-  const rawData = atob(base64);
-  const outputArray = new Uint8Array(rawData.length);
-  for (let i = 0; i < rawData.length; ++i) {
-    outputArray[i] = rawData.charCodeAt(i);
-  }
-  return outputArray;
-}
-
-// src/react/notifications.ts
+var import_react9 = require("react");
 function loadExpo() {
   return __async(this, null, function* () {
     try {
@@ -613,13 +2657,16 @@ function loadExpo() {
   });
 }
 function useNotifications(options) {
-  var _a;
-  const [permissionStatus, setPermissionStatus] = (0, import_react7.useState)("unknown");
-  const [devicePushToken, setDevicePushToken] = (0, import_react7.useState)(null);
-  const expoRef = (0, import_react7.useRef)(null);
-  const isWebRef = (0, import_react7.useRef)(false);
-  const vapidKeyRef = (0, import_react7.useRef)((_a = options.vapidPublicKey) != null ? _a : null);
-  (0, import_react7.useEffect)(() => {
+  var _a, _b, _c, _d, _e;
+  const sdkContext = useTruthSdkContext();
+  const apiBaseUrl = (_b = (_a = options.apiBaseUrl) != null ? _a : sdkContext == null ? void 0 : sdkContext.apiBaseUrl) != null ? _b : "";
+  const apiKey = (_d = (_c = options.apiKey) != null ? _c : sdkContext == null ? void 0 : sdkContext.apiKey) != null ? _d : "";
+  const [permissionStatus, setPermissionStatus] = (0, import_react9.useState)("unknown");
+  const [devicePushToken, setDevicePushToken] = (0, import_react9.useState)(null);
+  const expoRef = (0, import_react9.useRef)(null);
+  const isWebRef = (0, import_react9.useRef)(false);
+  const vapidKeyRef = (0, import_react9.useRef)((_e = options.vapidPublicKey) != null ? _e : null);
+  (0, import_react9.useEffect)(() => {
     let mounted = true;
     void (() => __async(null, null, function* () {
       var _a2;
@@ -645,11 +2692,11 @@ function useNotifications(options) {
         if (!vapidKeyRef.current) {
           try {
             const res = yield fetch(
-              `${options.apiBaseUrl}/api/notifications/vapid-key`,
+              `${apiBaseUrl}/api/notifications/vapid-key`,
               {
                 headers: {
                   Accept: "application/json",
-                  "X-API-Key": options.apiKey
+                  "X-API-Key": apiKey
                 }
               }
             );
@@ -674,9 +2721,9 @@ function useNotifications(options) {
     return () => {
       mounted = false;
     };
-  }, [options.apiBaseUrl, options.apiKey]);
-  const register = (0, import_react7.useCallback)(() => __async(null, null, function* () {
-    var _a2, _b;
+  }, [apiBaseUrl, apiKey]);
+  const register = (0, import_react9.useCallback)(() => __async(null, null, function* () {
+    var _a2, _b2;
     if (!options.userId) {
       return { ok: false, reason: "missing_userId" };
     }
@@ -700,12 +2747,12 @@ function useNotifications(options) {
         const subJSON = subscriptionToJSON(subscription);
         setDevicePushToken(subscription.endpoint);
         const res2 = yield fetch(
-          `${options.apiBaseUrl}/api/notifications/devices/register`,
+          `${apiBaseUrl}/api/notifications/devices/register`,
           {
             method: "POST",
             headers: {
               "Content-Type": "application/json",
-              "X-API-Key": options.apiKey
+              "X-API-Key": apiKey
             },
             body: JSON.stringify({
               userId: options.userId,
@@ -732,7 +2779,7 @@ function useNotifications(options) {
         };
       }
     }
-    const expo = (_b = expoRef.current) != null ? _b : yield loadExpo();
+    const expo = (_b2 = expoRef.current) != null ? _b2 : yield loadExpo();
     expoRef.current = expo;
     if (!expo) {
       return { ok: false, reason: "expo_notifications_missing" };
@@ -753,12 +2800,12 @@ function useNotifications(options) {
     }
     setDevicePushToken(nativeToken);
     const res = yield fetch(
-      `${options.apiBaseUrl}/api/notifications/devices/register`,
+      `${apiBaseUrl}/api/notifications/devices/register`,
       {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          "X-API-Key": options.apiKey
+          "X-API-Key": apiKey
         },
         body: JSON.stringify(__spreadValues({
           userId: options.userId,
@@ -779,28 +2826,28 @@ function useNotifications(options) {
     }
     return { ok: true };
   }), [
-    options.apiBaseUrl,
-    options.apiKey,
+    apiBaseUrl,
+    apiKey,
     options.userId,
     options.appVersion,
     options.serviceWorkerPath
   ]);
-  const unregister = (0, import_react7.useCallback)(() => __async(null, null, function* () {
+  const unregister = (0, import_react9.useCallback)(() => __async(null, null, function* () {
     if (!devicePushToken) {
       return;
     }
-    yield fetch(`${options.apiBaseUrl}/api/notifications/devices/unregister`, {
+    yield fetch(`${apiBaseUrl}/api/notifications/devices/unregister`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-API-Key": options.apiKey
+        "X-API-Key": apiKey
       },
       body: JSON.stringify({ nativeToken: devicePushToken })
     }).catch(() => {
     });
     setDevicePushToken(null);
-  }), [options.apiBaseUrl, options.apiKey, devicePushToken]);
-  const addReceivedListener = (0, import_react7.useCallback)(
+  }), [apiBaseUrl, apiKey, devicePushToken]);
+  const addReceivedListener = (0, import_react9.useCallback)(
     (listener) => {
       if (isWebRef.current) {
         if (typeof navigator === "undefined" || !("serviceWorker" in navigator)) {
@@ -829,7 +2876,7 @@ function useNotifications(options) {
     },
     []
   );
-  const addResponseListener = (0, import_react7.useCallback)(
+  const addResponseListener = (0, import_react9.useCallback)(
     (listener) => {
       if (isWebRef.current) {
         if (typeof navigator === "undefined" || !("serviceWorker" in navigator)) {
@@ -858,7 +2905,7 @@ function useNotifications(options) {
     },
     []
   );
-  const getBadgeCount = (0, import_react7.useCallback)(() => __async(null, null, function* () {
+  const getBadgeCount = (0, import_react9.useCallback)(() => __async(null, null, function* () {
     var _a2;
     const expo = expoRef.current;
     if (!(expo == null ? void 0 : expo.getBadgeCountAsync)) {
@@ -866,7 +2913,7 @@ function useNotifications(options) {
     }
     return (_a2 = yield expo.getBadgeCountAsync()) != null ? _a2 : 0;
   }), []);
-  const setBadgeCount = (0, import_react7.useCallback)((count) => __async(null, null, function* () {
+  const setBadgeCount = (0, import_react9.useCallback)((count) => __async(null, null, function* () {
     const expo = expoRef.current;
     if (!(expo == null ? void 0 : expo.setBadgeCountAsync)) {
       return;
@@ -874,7 +2921,7 @@ function useNotifications(options) {
     yield expo.setBadgeCountAsync(count);
   }), []);
   const autoRegister = options.autoRegister !== false;
-  (0, import_react7.useEffect)(() => {
+  (0, import_react9.useEffect)(() => {
     if (!autoRegister) {
       return;
     }
@@ -906,6 +2953,71 @@ function useNotifications(options) {
     setBadgeCount
   };
 }
+function useNotificationsActions() {
+  var _a, _b;
+  const sdkContext = useTruthSdkContext();
+  const apiBaseUrl = (_a = sdkContext == null ? void 0 : sdkContext.apiBaseUrl) != null ? _a : "";
+  const apiKey = (_b = sdkContext == null ? void 0 : sdkContext.apiKey) != null ? _b : "";
+  const post = (0, import_react9.useCallback)(
+    (path, body) => __async(null, null, function* () {
+      const res = yield fetch(`${apiBaseUrl}/api${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "X-API-Key": apiKey
+        },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new Error(
+          `Truth API ${path} failed (${res.status}): ${text.slice(0, 200)}`
+        );
+      }
+      return yield res.json();
+    }),
+    [apiBaseUrl, apiKey]
+  );
+  const get = (0, import_react9.useCallback)(
+    (path) => __async(null, null, function* () {
+      const res = yield fetch(`${apiBaseUrl}/api${path}`, {
+        method: "GET",
+        headers: { Accept: "application/json", "X-API-Key": apiKey }
+      });
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        throw new Error(
+          `Truth API ${path} failed (${res.status}): ${text.slice(0, 200)}`
+        );
+      }
+      return yield res.json();
+    }),
+    [apiBaseUrl, apiKey]
+  );
+  const send = (0, import_react9.useCallback)(
+    (input) => post("/notifications/send", input),
+    [post]
+  );
+  const schedule = (0, import_react9.useCallback)(
+    (input) => post("/notifications/schedule", input),
+    [post]
+  );
+  const getPreferences = (0, import_react9.useCallback)(
+    (userId) => get(
+      `/notifications/preferences/${encodeURIComponent(userId)}`
+    ),
+    [get]
+  );
+  const updatePreferences = (0, import_react9.useCallback)(
+    (userId, prefs) => post(
+      `/notifications/preferences/${encodeURIComponent(userId)}`,
+      prefs
+    ),
+    [post]
+  );
+  return { send, schedule, getPreferences, updatePreferences };
+}
 function mapStatus(status) {
   if (status === "granted") {
     return "granted";
@@ -932,16 +3044,16 @@ function detectPlatform(tokenType) {
 }
 
 // src/react/patient-family.ts
-var import_react8 = require("convex/react");
-var import_server5 = require("convex/server");
-var patientsFamilyMembersRef = (0, import_server5.makeFunctionReference)("patients:listFamilyMembers");
+var import_react10 = require("convex/react");
+var import_server6 = require("convex/server");
+var patientsFamilyMembersRef = (0, import_server6.makeFunctionReference)("patients:listFamilyMembers");
 var SKIP3 = "skip";
 function usePatientFamilyMembers(input) {
   const hasFamilyId = !!(input == null ? void 0 : input.familyId);
   const hasPhoneNumbers = !!((input == null ? void 0 : input.phoneNumbers) && input.phoneNumbers.length > 0);
   const shouldQuery = hasFamilyId || hasPhoneNumbers;
   const args = shouldQuery ? __spreadValues(__spreadValues(__spreadValues({}, (input == null ? void 0 : input.familyId) ? { familyId: input.familyId } : {}), (input == null ? void 0 : input.phoneNumbers) && input.phoneNumbers.length > 0 ? { phoneNumbers: input.phoneNumbers } : {}), (input == null ? void 0 : input.excludeHintId) ? { excludeHintId: input.excludeHintId } : {}) : SKIP3;
-  const result = (0, import_react8.useQuery)(
+  const result = (0, import_react10.useQuery)(
     patientsFamilyMembersRef,
     args
   );
@@ -956,15 +3068,15 @@ function usePatientFamilyMembers(input) {
 }
 
 // src/react/patient-search.ts
-var import_react9 = require("convex/react");
-var import_server6 = require("convex/server");
-var patientsSearchRef = (0, import_server6.makeFunctionReference)("patients:search");
+var import_react11 = require("convex/react");
+var import_server7 = require("convex/server");
+var patientsSearchRef = (0, import_server7.makeFunctionReference)("patients:search");
 var SKIP4 = "skip";
 function usePatientSearch(options) {
   var _a;
   const trimmedQuery = ((_a = options.query) != null ? _a : "").trim();
   const skipped = trimmedQuery.length === 0;
-  const result = (0, import_react9.useQuery)(
+  const result = (0, import_react11.useQuery)(
     patientsSearchRef,
     skipped ? SKIP4 : __spreadValues(__spreadValues(__spreadValues({
       query: trimmedQuery
@@ -981,24 +3093,26 @@ function usePatientSearch(options) {
 }
 
 // src/react/patients-bulk.ts
-var import_react10 = require("convex/react");
-var import_server7 = require("convex/server");
-var import_react11 = require("react");
-var patientsGetByIdsRef = (0, import_server7.makeFunctionReference)("patients:getByIds");
-var patientsGetByPhonesRef = (0, import_server7.makeFunctionReference)("patients:getByPhones");
+var import_react12 = require("convex/react");
+var import_server8 = require("convex/server");
+var import_react13 = require("react");
+var patientsGetByIdsRef = (0, import_server8.makeFunctionReference)("patients:getByIds");
+var patientsGetByPhonesRef = (0, import_server8.makeFunctionReference)("patients:getByPhones");
 var SKIP5 = "skip";
 function usePatientsByIds(ids) {
-  const stableIds = (0, import_react11.useMemo)(() => {
+  const stableIds = (0, import_react13.useMemo)(() => {
     const arr = ids != null ? ids : [];
     return [...new Set(arr)].sort();
   }, [ids]);
   const skipped = stableIds.length === 0;
-  const result = (0, import_react10.useQuery)(
+  const result = (0, import_react12.useQuery)(
     patientsGetByIdsRef,
     skipped ? SKIP5 : { ids: stableIds }
   );
-  const mapped = (0, import_react11.useMemo)(() => {
-    if (result === void 0) return void 0;
+  const mapped = (0, import_react13.useMemo)(() => {
+    if (result === void 0) {
+      return void 0;
+    }
     return Object.fromEntries(
       result.map((p) => {
         var _a, _b;
@@ -1017,18 +3131,20 @@ function usePatientsByIds(ids) {
   };
 }
 function usePatientsByPhones(phones) {
-  const stableDigits = (0, import_react11.useMemo)(() => {
+  const stableDigits = (0, import_react13.useMemo)(() => {
     const arr = phones != null ? phones : [];
     const digits = arr.map((p) => p.replace(/\D+/g, "")).filter((s) => s.length > 0);
     return [...new Set(digits)].sort();
   }, [phones]);
   const skipped = stableDigits.length === 0;
-  const result = (0, import_react10.useQuery)(
+  const result = (0, import_react12.useQuery)(
     patientsGetByPhonesRef,
     skipped ? SKIP5 : { phoneDigits: stableDigits }
   );
-  const mapped = (0, import_react11.useMemo)(() => {
-    if (result === void 0) return void 0;
+  const mapped = (0, import_react13.useMemo)(() => {
+    if (result === void 0) {
+      return void 0;
+    }
     return Object.fromEntries(result.map((r) => [r.phoneDigits, r.patient]));
   }, [result]);
   if (skipped) {
@@ -1041,39 +3157,10 @@ function usePatientsByPhones(phones) {
   };
 }
 
-// src/react/provider.ts
-var import_react12 = require("convex/react");
-var import_react13 = require("react");
-var CONVEX_URLS = {
-  local: "https://courteous-duck-623.convex.cloud",
-  staging: "https://courteous-duck-623.convex.cloud",
-  stg: "https://courteous-duck-623.convex.cloud",
-  sandbox: "https://courteous-duck-623.convex.cloud",
-  uat: "https://gallant-gecko-217.convex.cloud",
-  production: "https://gallant-gecko-217.convex.cloud"
-};
-function resolveConvexUrl(environment, override) {
-  var _a;
-  if (override) {
-    return override;
-  }
-  const env = environment != null ? environment : "sandbox";
-  return (_a = CONVEX_URLS[env]) != null ? _a : CONVEX_URLS.sandbox;
-}
-function TruthProvider({
-  environment = "sandbox",
-  convexUrl,
-  children
-}) {
-  const url = resolveConvexUrl(environment, convexUrl);
-  const client = (0, import_react13.useMemo)(() => new import_react12.ConvexReactClient(url), [url]);
-  return (0, import_react13.createElement)(import_react12.ConvexProvider, { client }, children);
-}
-
 // src/react/reminders.ts
 var import_react14 = require("convex/react");
-var import_server8 = require("convex/server");
-var remindersListPendingByConversationIdsRef = (0, import_server8.makeFunctionReference)("reminders:listPendingByConversationIds");
+var import_server9 = require("convex/server");
+var remindersListPendingByConversationIdsRef = (0, import_server9.makeFunctionReference)("reminders:listPendingByConversationIds");
 var SKIP6 = "skip";
 function useRemindersForConversations(conversationIds) {
   const ids = conversationIds != null ? conversationIds : [];
@@ -1095,9 +3182,9 @@ function useRemindersForConversations(conversationIds) {
 
 // src/react/tasks.ts
 var import_react15 = require("convex/react");
-var import_server9 = require("convex/server");
+var import_server10 = require("convex/server");
 var import_react16 = require("react");
-var conversationTasksMarkSeenRef = (0, import_server9.makeFunctionReference)("conversationTasks:markSeen");
+var conversationTasksMarkSeenRef = (0, import_server10.makeFunctionReference)("conversationTasks:markSeen");
 function useConversationTaskMarkSeen() {
   const mutate = (0, import_react15.useMutation)(
     conversationTasksMarkSeenRef
@@ -1110,200 +3197,6 @@ function useConversationTaskMarkSeen() {
 
 // src/react/tracking.ts
 var import_react17 = require("react");
-
-// src/tracking/tracker.ts
-function generateUuidV7() {
-  const now = Date.now();
-  const timeBytes = new Uint8Array(6);
-  let ts = now;
-  for (let i = 5; i >= 0; i--) {
-    timeBytes[i] = ts & 255;
-    ts = Math.floor(ts / 256);
-  }
-  const randomBytes = new Uint8Array(10);
-  if (typeof globalThis.crypto !== "undefined" && globalThis.crypto.getRandomValues) {
-    globalThis.crypto.getRandomValues(randomBytes);
-  } else {
-    for (let i = 0; i < 10; i++) {
-      randomBytes[i] = Math.floor(Math.random() * 256);
-    }
-  }
-  const bytes = new Uint8Array(16);
-  bytes.set(timeBytes, 0);
-  bytes.set(randomBytes, 6);
-  bytes[6] = bytes[6] & 15 | 112;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-  return [
-    hex.slice(0, 8),
-    hex.slice(8, 12),
-    hex.slice(12, 16),
-    hex.slice(16, 20),
-    hex.slice(20, 32)
-  ].join("-");
-}
-var API_URLS = {
-  local: "http://localhost:3000",
-  staging: "https://app.sandbox.communication-hub.com",
-  stg: "https://app.sandbox.communication-hub.com",
-  sandbox: "https://app.sandbox.communication-hub.com",
-  uat: "https://app.truth.communication-hub.com",
-  production: "https://app.truth.communication-hub.com"
-};
-var MAX_RETRIES = 3;
-var BASE_RETRY_DELAY_MS = 500;
-var Tracker = class {
-  constructor(config) {
-    this.queue = [];
-    this.flushTimer = null;
-    this.isFlushing = false;
-    this.isShutdown = false;
-    var _a, _b;
-    this.config = config;
-    this.apiUrl = (_b = (_a = config.apiBaseUrl) != null ? _a : API_URLS[config.environment]) != null ? _b : API_URLS.local;
-    this.startFlushInterval();
-    this.registerShutdownHooks();
-  }
-  /**
-   * Set the default actor context for subsequent events.
-   */
-  setActor(actor) {
-    this.defaultActor = actor;
-  }
-  /**
-   * Enqueue a typed event for delivery. This is fire-and-forget from
-   * the caller's perspective -- events are buffered and flushed in batches.
-   */
-  track(eventType, payload, options) {
-    var _a, _b, _c;
-    if (this.isShutdown) {
-      return;
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const envelope = {
-      event_id: generateUuidV7(),
-      event_type: eventType,
-      schema_version: 1,
-      occurred_at: (_a = options == null ? void 0 : options.occurredAt) != null ? _a : now,
-      received_at: now,
-      source: this.config.source,
-      source_version: this.config.sourceVersion,
-      tenant_id: (_b = options == null ? void 0 : options.tenantId) != null ? _b : this.config.tenantId,
-      actor: (_c = options == null ? void 0 : options.actor) != null ? _c : this.defaultActor ? {
-        actor_id: this.defaultActor.actorId,
-        actor_type: this.defaultActor.actorType
-      } : void 0,
-      subject: options == null ? void 0 : options.subject,
-      compliance: options == null ? void 0 : options.compliance,
-      payload
-    };
-    this.queue.push(envelope);
-    if (this.queue.length >= this.config.batchSize) {
-      void this.flush();
-    }
-  }
-  /**
-   * Force an immediate flush of all buffered events.
-   * Returns a promise that resolves when the flush completes.
-   */
-  flush() {
-    return __async(this, null, function* () {
-      if (this.queue.length === 0 || this.isFlushing) {
-        return;
-      }
-      this.isFlushing = true;
-      const batch = this.queue.splice(0, this.config.batchSize);
-      try {
-        yield this.sendBatch(batch);
-      } catch (e) {
-        this.queue.unshift(...batch);
-      } finally {
-        this.isFlushing = false;
-      }
-      if (this.queue.length >= this.config.batchSize) {
-        yield this.flush();
-      }
-    });
-  }
-  /**
-   * Gracefully shut down the tracker. Flushes remaining events and
-   * clears the flush interval.
-   */
-  shutdown() {
-    return __async(this, null, function* () {
-      this.isShutdown = true;
-      this.stopFlushInterval();
-      yield this.flush();
-    });
-  }
-  /**
-   * Send a batch of events to the Truth API with exponential backoff retry.
-   */
-  sendBatch(batch) {
-    return __async(this, null, function* () {
-      let lastError;
-      for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-        try {
-          const response = yield fetch(`${this.apiUrl}/api/events/ingest`, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              "X-API-Key": this.config.apiKey
-            },
-            body: JSON.stringify({ events: batch })
-          });
-          if (response.ok) {
-            return;
-          }
-          if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-            return;
-          }
-          lastError = new Error(
-            `HTTP ${response.status}: ${response.statusText}`
-          );
-        } catch (error) {
-          lastError = error;
-        }
-        if (attempt < MAX_RETRIES) {
-          const delay = BASE_RETRY_DELAY_MS * __pow(2, attempt);
-          const jitter = Math.random() * delay * 0.5;
-          yield sleep(delay + jitter);
-        }
-      }
-      throw lastError;
-    });
-  }
-  startFlushInterval() {
-    if (this.config.flushIntervalMs > 0) {
-      this.flushTimer = setInterval(() => {
-        void this.flush();
-      }, this.config.flushIntervalMs);
-      if (typeof this.flushTimer === "object" && "unref" in this.flushTimer) {
-        this.flushTimer.unref();
-      }
-    }
-  }
-  stopFlushInterval() {
-    if (this.flushTimer !== null) {
-      clearInterval(this.flushTimer);
-      this.flushTimer = null;
-    }
-  }
-  registerShutdownHooks() {
-    if (typeof globalThis.process !== "undefined" && globalThis.process.on) {
-      const shutdownHandler = () => {
-        void this.shutdown();
-      };
-      globalThis.process.on("beforeExit", shutdownHandler);
-      globalThis.process.on("SIGTERM", shutdownHandler);
-    }
-  }
-};
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/react/tracking.ts
 var TruthTrackingContext = (0, import_react17.createContext)(
   null
 );
@@ -1312,12 +3205,14 @@ function TruthTrackingProvider({
   source = "communication-hub.frontend",
   sourceVersion = "unknown",
   tenantId = "hipnation",
-  apiKey = "",
+  apiKey,
   children
 }) {
+  var _a, _b;
+  const resolvedApiKey = (_b = apiKey != null ? apiKey : typeof process !== "undefined" ? (_a = process.env) == null ? void 0 : _a.EXPO_PUBLIC_TRUTH_API_KEY : void 0) != null ? _b : "";
   const value = (0, import_react17.useMemo)(() => {
     const tracker = new Tracker({
-      apiKey,
+      apiKey: resolvedApiKey,
       environment,
       source,
       sourceVersion,
@@ -1333,7 +3228,7 @@ function TruthTrackingProvider({
         tracker.setActor({ actorId, actorType });
       }
     };
-  }, [apiKey, environment, source, sourceVersion, tenantId]);
+  }, [resolvedApiKey, environment, source, sourceVersion, tenantId]);
   return (0, import_react17.createElement)(TruthTrackingContext.Provider, { value }, children);
 }
 function useTruth() {
@@ -1346,8 +3241,8 @@ function useTruth() {
 
 // src/react/user-settings.ts
 var import_react18 = require("convex/react");
-var import_server10 = require("convex/server");
-var userSettingsGetByUserIdRef = (0, import_server10.makeFunctionReference)("userSettings:getByUserId");
+var import_server11 = require("convex/server");
+var userSettingsGetByUserIdRef = (0, import_server11.makeFunctionReference)("userSettings:getByUserId");
 var SKIP7 = "skip";
 function useUserSettings(userId) {
   const skip = !userId;
@@ -1365,16 +3260,103 @@ function useUserSettings(userId) {
   };
 }
 
-// src/react/voicemail.ts
+// src/react/users.ts
 var import_react19 = require("react");
-function useVoicemailUrl(client) {
-  const [url, setUrl] = (0, import_react19.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react19.useState)(false);
+function useUserSync(input) {
+  var _a, _b, _c, _d;
+  const sdkContext = useTruthSdkContext();
+  const apiBaseUrl = (_b = (_a = input.apiBaseUrl) != null ? _a : sdkContext == null ? void 0 : sdkContext.apiBaseUrl) != null ? _b : "";
+  const apiKey = (_d = (_c = input.apiKey) != null ? _c : sdkContext == null ? void 0 : sdkContext.apiKey) != null ? _d : "";
+  const [status, setStatus] = (0, import_react19.useState)("idle");
   const [error, setError] = (0, import_react19.useState)(null);
-  const inFlightRef = (0, import_react19.useRef)(false);
-  const fetchUrl = (0, import_react19.useCallback)(
+  const lastKeyRef = (0, import_react19.useRef)(null);
+  const sync = () => __async(null, null, function* () {
+    if (!input.userId) {
+      return { ok: false, reason: "missing_userId" };
+    }
+    if (!apiBaseUrl || !apiKey) {
+      return { ok: false, reason: "missing_truth_config" };
+    }
+    setStatus("syncing");
+    setError(null);
+    try {
+      const res = yield fetch(`${apiBaseUrl}/api/users/sync`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": apiKey
+        },
+        body: JSON.stringify({
+          userId: input.userId,
+          email: input.email,
+          name: input.name,
+          firstName: input.firstName,
+          lastName: input.lastName,
+          imageUrl: input.imageUrl,
+          notificationsEnabled: input.notificationsEnabled
+        })
+      });
+      if (!res.ok) {
+        const text = yield res.text().catch(() => "");
+        const reason = `sync_failed_${res.status}: ${text.slice(0, 120)}`;
+        setStatus("error");
+        setError(reason);
+        return { ok: false, reason };
+      }
+      setStatus("synced");
+      return { ok: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setStatus("error");
+      setError(message);
+      return { ok: false, reason: message };
+    }
+  });
+  (0, import_react19.useEffect)(() => {
+    var _a2, _b2, _c2, _d2, _e;
+    if (!input.userId) {
+      return;
+    }
+    const key = [
+      input.userId,
+      (_a2 = input.email) != null ? _a2 : "",
+      (_b2 = input.name) != null ? _b2 : "",
+      (_c2 = input.firstName) != null ? _c2 : "",
+      (_d2 = input.lastName) != null ? _d2 : "",
+      (_e = input.imageUrl) != null ? _e : "",
+      input.notificationsEnabled === void 0 ? "" : String(input.notificationsEnabled)
+    ].join("|");
+    if (key === lastKeyRef.current) {
+      return;
+    }
+    lastKeyRef.current = key;
+    void sync();
+  }, [
+    apiBaseUrl,
+    apiKey,
+    input.userId,
+    input.email,
+    input.name,
+    input.firstName,
+    input.lastName,
+    input.imageUrl,
+    input.notificationsEnabled
+  ]);
+  return { status, error, sync };
+}
+
+// src/react/voicemail.ts
+var import_react20 = require("react");
+function useVoicemailUrl(client) {
+  const [url, setUrl] = (0, import_react20.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react20.useState)(false);
+  const [error, setError] = (0, import_react20.useState)(null);
+  const inFlightRef = (0, import_react20.useRef)(false);
+  const fetchUrl = (0, import_react20.useCallback)(
     (voicemailLink) => __async(null, null, function* () {
-      if (inFlightRef.current) return null;
+      if (inFlightRef.current) {
+        return null;
+      }
       inFlightRef.current = true;
       setIsLoading(true);
       setError(null);
@@ -1398,12 +3380,17 @@ function useVoicemailUrl(client) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACTIVE_CALL_STATES,
+  API_BASE_URLS,
   CONNECTED_CALL_STATES,
+  CONVEX_URLS,
   DialpadCallState,
   RINGING_CALL_STATES,
   TERMINAL_CALL_STATES,
   TruthProvider,
   TruthTrackingProvider,
+  getTruthClient,
+  resolveApiBaseUrl,
+  resolveConvexUrl,
   useActiveCalls,
   useAppointment,
   useAppointmentByElationId,
@@ -1423,6 +3410,7 @@ function useVoicemailUrl(client) {
   useDialpadCallsForConversation,
   useMessages,
   useNotifications,
+  useNotificationsActions,
   usePatient,
   usePatientBasic,
   usePatientByElationId,
@@ -1439,9 +3427,12 @@ function useVoicemailUrl(client) {
   usePhysiciansByElationIds,
   useRemindersForConversations,
   useTruth,
+  useTruthClient,
+  useTruthSdkContext,
   useUnreadAggregate,
   useUnreadCount,
   useUserSettings,
+  useUserSync,
   useVoicemailUrl
 });
 //# sourceMappingURL=react.js.map