@ringg/react-native 0.0.1-alpha.9 → 0.2.0

package/dist/index.js

@@ -0,0 +1,1164 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createCallbackEventBus: () => createCallbackEventBus,
+  createRinggWidgetController: () => createRinggWidgetController,
+  useRinggComponents: () => useRinggComponents,
+  useRinggMessages: () => useRinggMessages,
+  useRinggSession: () => useRinggSession,
+  useRinggShell: () => useRinggShell,
+  useRinggSlashCommands: () => useRinggSlashCommands,
+  useRinggTyping: () => useRinggTyping,
+  useStoreSnapshot: () => useStoreSnapshot
+});
+module.exports = __toCommonJS(src_exports);
+
+// ../core/dist/generated/tokens.js
+var DEFAULT_WIDGET_THEME = {
+  "primaryColor": "#0a0a0b",
+  "primaryTextColor": "#ffffff",
+  "backgroundColor": "#ffffff",
+  "surfaceColor": "#f3f4f6",
+  "agentBubbleColor": "",
+  "textColor": "#0a0a0b",
+  "mutedTextColor": "#6b7280",
+  "borderColor": "#e5e7eb",
+  "errorColor": "#ef4444",
+  "successColor": "#16a34a",
+  "buttonStyle": "pill",
+  "borderRadius": "16px",
+  "fontFamily": "inherit"
+};
+var TIMING = {
+  "chatWidgetGraceMs": 800,
+  "chatWidgetAfterTextMs": 120,
+  "minTypingIndicatorMs": 500
+};
+var WIDGET_DEFAULTS = {
+  "mode": "prod",
+  "title": "Ringg AI Support",
+  "description": "Ringg AI offers 24/7 voice support to handle your business calls efficiently and professionally",
+  "defaultTab": "audio",
+  "hideTabSelector": false,
+  "defaultExpanded": false,
+  "bypassStartScreen": false,
+  "bypassFeedbackScreen": false,
+  "voiceCallShowAnimation": false,
+  "voiceCallShowTranscript": true,
+  "notificationTuneUrl": "https://assets.ringg.ai/audios/misc/widget_notification.mp3"
+};
+
+// ../core/dist/ports/event-bus.js
+function createCallbackEventBus() {
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    emit(event, payload) {
+      listeners.get(event)?.forEach((handler) => handler(payload));
+    },
+    on(event, handler) {
+      let set = listeners.get(event);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        listeners.set(event, set);
+      }
+      const typed = handler;
+      set.add(typed);
+      return () => {
+        listeners.get(event)?.delete(typed);
+      };
+    },
+    off(event) {
+      if (event) {
+        listeners.delete(event);
+      } else {
+        listeners.clear();
+      }
+    }
+  };
+}
+
+// ../core/dist/ports/clock.js
+function createSystemClock() {
+  return {
+    now() {
+      return Date.now();
+    },
+    setTimeout(fn, ms) {
+      return setTimeout(fn, ms);
+    },
+    clearTimeout(handle) {
+      clearTimeout(handle);
+    }
+  };
+}
+
+// ../core/dist/ports/platform.js
+var grantedMicPermission = {
+  isGranted: async () => true,
+  request: async () => true
+};
+var silentNotificationPlayer = {
+  play: () => {
+  }
+};
+
+// ../core/dist/api/client.js
+function createRinggApiClient(config) {
+  const { backendUrl, livekitUrl } = config.urlResolver.resolve(config.mode);
+  const authHeaders = config.authorization ? { Authorization: config.authorization } : config.xApiKey ? { "X-API-KEY": config.xApiKey } : {};
+  const headers = () => ({ "Content-Type": "application/json", ...authHeaders });
+  return {
+    backendUrl,
+    livekitUrl,
+    async startWebcall(params) {
+      const response = await fetch(`${backendUrl}/calling/webcall`, {
+        method: "POST",
+        body: JSON.stringify({
+          agent_id: params.agentId,
+          custom_args_values: params.variables,
+          media_type: params.mediaType,
+          // Marks this call as coming from the v2 embed so the backend can use
+          // the newer endpoint; absent on older embeds, which fall back.
+          embed_version: "v2"
+        }),
+        headers: headers()
+      });
+      const responseText = await response.text();
+      let data;
+      try {
+        data = JSON.parse(responseText);
+      } catch {
+        throw new Error(responseText.slice(0, 200) || `Request failed with status ${response.status}`);
+      }
+      if (!response.ok) {
+        throw new Error(data?.message || "Failed to make call");
+      }
+      return {
+        call_id: data.call_id,
+        user_token: data.user_token,
+        enabled_slash_commands: data.enabled_slash_commands
+      };
+    },
+    async submitFeedback(callId, feedback) {
+      await fetch(`${backendUrl}/calling/${callId}/feedback`, {
+        method: "POST",
+        body: JSON.stringify(feedback),
+        headers: headers()
+      });
+    },
+    async callComponentApi(method, endpoint, payload) {
+      const url = endpoint.startsWith("http") ? endpoint : `${backendUrl}${endpoint}`;
+      const response = await fetch(url, {
+        method,
+        body: method === "GET" ? void 0 : JSON.stringify(payload),
+        headers: headers()
+      });
+      return await response.json();
+    }
+  };
+}
+
+// ../core/dist/theme/theme-engine.js
+function mergeWidgetTheme(theme) {
+  return { ...DEFAULT_WIDGET_THEME, ...theme };
+}
+
+// ../core/dist/rpc/formatter.js
+function transformRpcToComponent(componentName, rpcPayload) {
+  const componentId = `${componentName}_${Date.now()}`;
+  const config = rpcPayload.component_config ?? rpcPayload.component_data;
+  switch (componentName) {
+    case "calendar":
+      return transformCalendar(componentId, config, rpcPayload);
+    case "form":
+      return transformForm(componentId, config);
+    case "buttons":
+      return transformButtons(componentId, config, rpcPayload);
+    case "quick_replay":
+      return transformQuickReplay(componentId, config);
+    case "confirmation":
+      return transformConfirmation(componentId, rpcPayload);
+    default:
+      if (rpcPayload.component_type && rpcPayload.component_id) {
+        return rpcPayload;
+      }
+      return null;
+  }
+}
+function transformCalendar(componentId, config, rpcPayload) {
+  const configObj = config;
+  const slots = configObj?.slots || [];
+  const timezone = configObj?.timezone || "UTC";
+  return {
+    component_type: "calendar_booking",
+    component_id: componentId,
+    data: {
+      available_slots: slots.map((slot) => ({ id: slot.id, datetime: slot.datetime })),
+      timezone,
+      title: rpcPayload.title || "Select a time slot"
+    }
+  };
+}
+function transformForm(componentId, config) {
+  const configObj = config;
+  const transformedFields = (configObj?.fields || []).map((field) => ({
+    name: field.key || field.name || "",
+    type: mapFieldType(field.type),
+    label: field.description || field.label || field.key || field.name || "",
+    required: field.required,
+    placeholder: field.placeholder,
+    options: field.options
+  }));
+  return {
+    component_type: "form",
+    component_id: componentId,
+    data: {
+      title: configObj?.title || "Form",
+      description: configObj?.description,
+      fields: transformedFields,
+      submit_label: configObj?.cta || configObj?.submit_label || "Submit"
+    }
+  };
+}
+function transformButtons(componentId, config, rpcPayload) {
+  return {
+    component_type: "buttons",
+    component_id: componentId,
+    data: {
+      title: rpcPayload.title,
+      buttons: Array.isArray(config) ? config : []
+    }
+  };
+}
+function transformQuickReplay(componentId, config) {
+  const configObj = config;
+  const options = Array.isArray(configObj?.options) ? configObj.options.filter((option) => typeof option === "string" && option.trim().length > 0) : [];
+  return {
+    component_type: "buttons",
+    component_id: componentId,
+    data: {
+      presentation: "free",
+      completionDisplay: "selected_item",
+      buttons: options.map((option) => ({
+        id: option,
+        label: option,
+        action: { type: "trigger_component" }
+      }))
+    }
+  };
+}
+function transformConfirmation(componentId, rpcPayload) {
+  return {
+    component_type: "confirmation",
+    component_id: componentId,
+    data: {
+      title: rpcPayload.title || "Confirmed",
+      message: rpcPayload.message || "",
+      icon: rpcPayload.icon || "success",
+      details: rpcPayload.details
+    }
+  };
+}
+function mapFieldType(backendType) {
+  const typeMap = {
+    text: "text",
+    string: "text",
+    number: "number",
+    email: "email",
+    phone_number: "tel",
+    single_select: "select",
+    multiselect: "multiselect",
+    checkbox: "boolean",
+    date: "date",
+    textarea: "textarea"
+  };
+  return typeMap[backendType] || "text";
+}
+var RECEIVE_RPC_METHOD = "receive_dynamic_data";
+function formatComponentResponse(componentName, componentId, responseData, originalConfig) {
+  let componentData;
+  const stepData = responseData.step_data;
+  if (componentName === "calendar") {
+    const slotId = stepData?.slot_id;
+    const configObj = originalConfig;
+    const slots = configObj?.slots || [];
+    const timezone = configObj?.timezone || "UTC";
+    const selectedSlot = slots.find((slot) => slot.id === slotId);
+    componentData = {
+      id: selectedSlot?.id || slotId,
+      datetime: selectedSlot?.datetime || stepData?.slot_datetime,
+      timezone,
+      slot_time: stepData?.slot_time,
+      slot_date: stepData?.slot_date
+    };
+  } else if (componentName === "form") {
+    componentData = responseData.step_data || responseData.all_data;
+  } else if (componentName === "buttons") {
+    const buttonId = stepData?.selected_button;
+    const buttons = Array.isArray(originalConfig) ? originalConfig : [];
+    const selectedButton = buttons.find((btn) => btn.id === buttonId);
+    componentData = selectedButton || { id: buttonId };
+  } else if (componentName === "quick_replay") {
+    componentData = { text: stepData?.selected_button };
+  } else {
+    componentData = responseData;
+  }
+  const toolId = originalConfig?.tool_id;
+  return {
+    method: RECEIVE_RPC_METHOD,
+    payload: JSON.stringify({
+      component_type: `receive_component_${componentName}`,
+      component_id: componentId,
+      component_data: componentData,
+      ...toolId && { tool_id: toolId }
+    })
+  };
+}
+function formatSlashCommand(command) {
+  return {
+    method: RECEIVE_RPC_METHOD,
+    payload: JSON.stringify({
+      component_type: "receive_component_slash_command",
+      command: command.replace(/^\//, "")
+    })
+  };
+}
+function formatBlocksAction(toolId, componentId, action) {
+  return {
+    method: RECEIVE_RPC_METHOD,
+    payload: JSON.stringify({
+      component_type: "receive_component_blocks",
+      component_id: componentId,
+      ...toolId && { tool_id: toolId },
+      component_data: {
+        action_id: action.action_id,
+        ...action.value !== void 0 && { value: action.value },
+        values: action.values
+      }
+    })
+  };
+}
+function formatDynamicData(payload) {
+  return {
+    method: RECEIVE_RPC_METHOD,
+    payload: JSON.stringify(payload)
+  };
+}
+
+// ../core/dist/stores/store.js
+function createStore(build) {
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = build();
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    commit() {
+      snapshot = build();
+      listeners.forEach((listener) => listener(snapshot));
+    },
+    dispose() {
+      listeners.clear();
+    }
+  };
+}
+
+// ../core/dist/stores/shell-store.js
+function createShellStore(eventBus, initialCallMode = "audio", defaultExpanded = false) {
+  let isOpen = defaultExpanded;
+  let feedbackPending = false;
+  let currentCallId = null;
+  let callMode = initialCallMode;
+  const buildViewState = () => {
+    if (!isOpen)
+      return "closed";
+    return feedbackPending ? "feedback" : "open";
+  };
+  const build = () => ({ viewState: buildViewState(), currentCallId, callMode });
+  const handle = createStore(build);
+  const store = {
+    getSnapshot: handle.getSnapshot,
+    subscribe: handle.subscribe,
+    dispose: handle.dispose,
+    get isOpen() {
+      return isOpen;
+    },
+    get isShowingFeedback() {
+      return feedbackPending;
+    },
+    open() {
+      if (isOpen)
+        return;
+      isOpen = true;
+      eventBus.emit("ringg:widget_status", { status: "maximised", mode: callMode });
+      handle.commit();
+    },
+    minimize() {
+      if (defaultExpanded)
+        return;
+      if (!isOpen)
+        return;
+      isOpen = false;
+      eventBus.emit("ringg:widget_status", { status: "minimised", mode: callMode });
+      handle.commit();
+    },
+    close() {
+      feedbackPending = false;
+      currentCallId = null;
+      if (!defaultExpanded) {
+        isOpen = false;
+        eventBus.emit("ringg:widget_status", { status: "minimised", mode: callMode });
+      }
+      handle.commit();
+    },
+    toggle() {
+      if (isOpen) {
+        store.minimize();
+      } else {
+        store.open();
+      }
+    },
+    showFeedback() {
+      feedbackPending = true;
+      handle.commit();
+    },
+    setCallMode(mode) {
+      if (callMode === mode)
+        return;
+      callMode = mode;
+      handle.commit();
+    },
+    setCurrentCallId(callId) {
+      currentCallId = callId;
+      handle.commit();
+    }
+  };
+  return store;
+}
+
+// ../core/dist/stores/session-store.js
+var NO_ERROR = { hasError: false, message: "" };
+var MIC_DENIED_MESSAGE = "Microphone access was denied. Please enable it in your browser settings.";
+var MEDIA_DEVICES_ERROR_MESSAGE = "Error acquiring microphone permission. Please make sure you grant the necessary permissions in your browser and reload the tab";
+function createSessionStore(api, transport, mic) {
+  let phase = "idle";
+  let isLoading = false;
+  let connectionState = "disconnected";
+  let error = NO_ERROR;
+  const computeIsSessionLive = () => phase === "live-optimistic" || phase === "connected";
+  const build = () => ({
+    phase,
+    isLoading,
+    isSessionLive: computeIsSessionLive(),
+    connectionState,
+    error
+  });
+  const handle = createStore(build);
+  transport.onConnectionStateChange((state) => {
+    connectionState = state;
+    if (state === "connected" && phase !== "idle")
+      phase = "connected";
+    handle.commit();
+  });
+  transport.onMediaDevicesError(() => {
+    error = { hasError: true, message: MEDIA_DEVICES_ERROR_MESSAGE };
+    handle.commit();
+  });
+  return {
+    getSnapshot: handle.getSnapshot,
+    subscribe: handle.subscribe,
+    dispose: handle.dispose,
+    get isSessionLive() {
+      return computeIsSessionLive();
+    },
+    prewarm() {
+      void transport.prepareConnection(api.livekitUrl).catch(() => {
+      });
+    },
+    async start(params) {
+      if (params.mediaType === "audio" && !await mic.isGranted()) {
+        if (!await mic.request()) {
+          error = { hasError: true, message: MIC_DENIED_MESSAGE };
+          handle.commit();
+          return null;
+        }
+      }
+      isLoading = true;
+      phase = "starting";
+      handle.commit();
+      try {
+        const response = await api.startWebcall({
+          agentId: params.agentId,
+          variables: params.variables,
+          mediaType: params.mediaType
+        });
+        phase = "live-optimistic";
+        error = NO_ERROR;
+        handle.commit();
+        await transport.connect(api.livekitUrl, response.user_token);
+        if (params.mediaType === "audio")
+          await transport.setMicrophoneEnabled(true);
+        return {
+          callId: response.call_id,
+          slashCommands: response.enabled_slash_commands ?? []
+        };
+      } catch (err) {
+        phase = "idle";
+        error = { hasError: true, message: err.message };
+        handle.commit();
+        return null;
+      } finally {
+        isLoading = false;
+        handle.commit();
+      }
+    },
+    async end() {
+      isLoading = true;
+      handle.commit();
+      try {
+        await transport.disconnect();
+      } catch {
+      } finally {
+        phase = "idle";
+        isLoading = false;
+        handle.commit();
+      }
+    },
+    clearError() {
+      error = NO_ERROR;
+      handle.commit();
+    }
+  };
+}
+
+// ../core/dist/stores/message-store.js
+var MONOTONIC_BUMP = 1e-3;
+function createMessageStore(clock) {
+  let entries = [];
+  const transcripts = /* @__PURE__ */ new Map();
+  let pendingSourceUrl = "";
+  let lastTimestamp = 0;
+  const build = () => {
+    const merged = [...transcripts.values(), ...entries].sort((a, b) => a.timestamp - b.timestamp);
+    return { messages: merged };
+  };
+  const handle = createStore(build);
+  const store = {
+    getSnapshot: handle.getSnapshot,
+    subscribe: handle.subscribe,
+    dispose: handle.dispose,
+    nextTimestamp() {
+      const now = clock.now();
+      lastTimestamp = now > lastTimestamp ? now : lastTimestamp + MONOTONIC_BUMP;
+      return lastTimestamp;
+    },
+    addChatMessage(params) {
+      const sourceUrl = !params.isSelf && pendingSourceUrl ? pendingSourceUrl : void 0;
+      if (sourceUrl)
+        pendingSourceUrl = "";
+      const msg = {
+        name: params.name ?? (params.isSelf ? "You" : "Agent"),
+        message: params.message,
+        isSelf: params.isSelf,
+        timestamp: params.timestamp ?? store.nextTimestamp(),
+        ...sourceUrl && { sourceUrl }
+      };
+      entries.push(msg);
+      handle.commit();
+      return msg;
+    },
+    addComponent(component) {
+      const msg = {
+        name: "Agent",
+        message: "",
+        isSelf: false,
+        timestamp: store.nextTimestamp(),
+        componentType: component.component_type,
+        componentData: component
+      };
+      entries.push(msg);
+      handle.commit();
+      return msg;
+    },
+    addSystemLog(params) {
+      entries.push({
+        name: "system",
+        message: params.label,
+        isSelf: false,
+        timestamp: store.nextTimestamp(),
+        kind: "system",
+        ...params.meta && { systemMeta: params.meta },
+        systemLevel: params.level
+      });
+      handle.commit();
+    },
+    addLocalSelection(componentId, label) {
+      const prompt = entries.find((m) => m.componentData?.component_id === componentId);
+      const anchor = prompt ? prompt.timestamp + MONOTONIC_BUMP / 2 : store.nextTimestamp();
+      entries.push({ name: "You", isSelf: true, message: label, timestamp: anchor });
+      handle.commit();
+    },
+    upsertTranscription(segment) {
+      const existing = transcripts.get(segment.id);
+      transcripts.set(segment.id, {
+        name: segment.participantName ?? (segment.isLocal ? "You" : "Agent"),
+        message: segment.text,
+        isSelf: segment.isLocal,
+        timestamp: existing?.timestamp ?? store.nextTimestamp(),
+        ...existing?.sourceUrl && { sourceUrl: existing.sourceUrl }
+      });
+      if (pendingSourceUrl) {
+        let newestId;
+        let newest;
+        for (const [id, msg] of transcripts) {
+          if (!newest || msg.timestamp >= newest.timestamp) {
+            newest = msg;
+            newestId = id;
+          }
+        }
+        if (newest && newestId !== void 0 && !newest.isSelf && !newest.sourceUrl) {
+          transcripts.set(newestId, { ...newest, sourceUrl: pendingSourceUrl });
+        }
+        pendingSourceUrl = "";
+      }
+      handle.commit();
+    },
+    setPendingSourceUrl(url) {
+      pendingSourceUrl = url;
+    },
+    clearPendingSourceUrl() {
+      pendingSourceUrl = "";
+    },
+    reset() {
+      entries = [];
+      transcripts.clear();
+      pendingSourceUrl = "";
+      handle.commit();
+    }
+  };
+  return store;
+}
+
+// ../core/dist/constants.js
+var CHAT_WIDGET_GRACE_MS = TIMING.chatWidgetGraceMs;
+var CHAT_WIDGET_AFTER_TEXT_MS = TIMING.chatWidgetAfterTextMs;
+var MIN_TYPING_INDICATOR_MS = TIMING.minTypingIndicatorMs;
+
+// ../core/dist/stores/typing-store.js
+function createTypingStore(clock) {
+  let shownAt = null;
+  let isTyping = false;
+  const build = () => ({ isTyping });
+  const handle = createStore(build);
+  const set = (next) => {
+    if (isTyping === next)
+      return;
+    isTyping = next;
+    handle.commit();
+  };
+  return {
+    getSnapshot: handle.getSnapshot,
+    subscribe: handle.subscribe,
+    dispose: handle.dispose,
+    showOnUserSend() {
+      if (shownAt === null)
+        shownAt = clock.now();
+      set(true);
+    },
+    clear() {
+      shownAt = null;
+      set(false);
+    },
+    waitMinDuration() {
+      if (shownAt === null)
+        return Promise.resolve();
+      const remaining = MIN_TYPING_INDICATOR_MS - (clock.now() - shownAt);
+      if (remaining <= 0)
+        return Promise.resolve();
+      return new Promise((resolve) => clock.setTimeout(resolve, remaining));
+    }
+  };
+}
+
+// ../core/dist/stores/component-store.js
+function createComponentStore(clock, commitComponent) {
+  let pendingChatWidgets = [];
+  let graceTimer = null;
+  const pendingResponses = /* @__PURE__ */ new Map();
+  const completedFlowIds = /* @__PURE__ */ new Set();
+  let extensions = [];
+  const build = () => ({ completedFlowIds: new Set(completedFlowIds) });
+  const handle = createStore(build);
+  const store = {
+    getSnapshot: handle.getSnapshot,
+    subscribe: handle.subscribe,
+    dispose: handle.dispose,
+    add(component, mode) {
+      if (mode !== "text") {
+        commitComponent(component);
+        return;
+      }
+      pendingChatWidgets.push(component);
+      if (!graceTimer) {
+        graceTimer = clock.setTimeout(() => store.flush(), CHAT_WIDGET_GRACE_MS);
+      }
+    },
+    onAgentTextLanded() {
+      if (pendingChatWidgets.length > 0) {
+        clock.setTimeout(() => store.flush(), CHAT_WIDGET_AFTER_TEXT_MS);
+      }
+    },
+    flush() {
+      if (graceTimer) {
+        clock.clearTimeout(graceTimer);
+        graceTimer = null;
+      }
+      const queued = pendingChatWidgets;
+      pendingChatWidgets = [];
+      queued.forEach((component) => commitComponent(component));
+    },
+    // ─── Response tracking ─────────────────────────────────────────────────────
+    trackPendingResponse(componentId, pending) {
+      pendingResponses.set(componentId, pending);
+    },
+    takePendingResponse(componentId) {
+      const pending = pendingResponses.get(componentId);
+      if (pending)
+        pendingResponses.delete(componentId);
+      return pending;
+    },
+    markFlowComplete(componentId) {
+      completedFlowIds.add(componentId);
+      handle.commit();
+    },
+    // ─── Extensions ────────────────────────────────────────────────────────────
+    registerExtension(extension) {
+      extensions.push(extension);
+      return () => {
+        extensions = extensions.filter((e) => e !== extension);
+      };
+    },
+    runExtensions(componentName, parsed) {
+      return extensions.some((extension) => extension(componentName, parsed));
+    },
+    // ─── Lifecycle ─────────────────────────────────────────────────────────────
+    reset() {
+      if (graceTimer) {
+        clock.clearTimeout(graceTimer);
+        graceTimer = null;
+      }
+      pendingChatWidgets = [];
+      pendingResponses.clear();
+      completedFlowIds.clear();
+      handle.commit();
+    }
+  };
+  return store;
+}
+
+// ../core/dist/stores/slash-command-store.js
+function createSlashCommandStore(configCommands = []) {
+  let runtimeCommands = [];
+  const build = () => {
+    const seen = new Set(configCommands.map((c) => c.command));
+    const merged = [...configCommands];
+    for (const cmd of runtimeCommands) {
+      if (!seen.has(cmd.command))
+        merged.push(cmd);
+    }
+    return { commands: merged };
+  };
+  const handle = createStore(build);
+  return {
+    getSnapshot: handle.getSnapshot,
+    subscribe: handle.subscribe,
+    dispose: handle.dispose,
+    setRuntimeCommands(commands) {
+      runtimeCommands = commands;
+      handle.commit();
+    },
+    reset() {
+      runtimeCommands = [];
+      handle.commit();
+    }
+  };
+}
+
+// ../core/dist/controller.js
+function createRinggWidgetController(config, ports) {
+  const theme = mergeWidgetTheme(config.theme);
+  const eventBus = ports.eventBus ?? createCallbackEventBus();
+  const clock = ports.clock ?? createSystemClock();
+  const notification = ports.notification ?? silentNotificationPlayer;
+  const onDomAction = ports.onDomAction;
+  const transport = ports.transport;
+  const api = createRinggApiClient({
+    urlResolver: ports.urlResolver,
+    mode: config.mode ?? WIDGET_DEFAULTS.mode,
+    xApiKey: config.xApiKey,
+    authorization: config.authorization
+  });
+  const shell = createShellStore(eventBus, config.defaultTab ?? WIDGET_DEFAULTS.defaultTab, config.defaultExpanded ?? WIDGET_DEFAULTS.defaultExpanded);
+  const session = createSessionStore(api, transport, ports.micPermission ?? grantedMicPermission);
+  const messages = createMessageStore(clock);
+  const typing = createTypingStore(clock);
+  const slashCommands = createSlashCommandStore(config.enabledSlashCommands);
+  const components = createComponentStore(clock, (component) => commitComponent(component));
+  const unsubscribers = [];
+  let conversationEndedDispatched = false;
+  const eventLogsEnabled = config.eventLogs?.enabled === true;
+  const eventLogsShowIds = config.eventLogs?.showIds === true;
+  const pushSystemLog = (entry) => {
+    if (!eventLogsEnabled)
+      return;
+    const meta = eventLogsShowIds && entry.id ? entry.meta ? `${entry.id} \xB7 ${entry.meta}` : entry.id : entry.meta;
+    messages.addSystemLog({ label: entry.label, meta, level: entry.level });
+  };
+  function resetConversation() {
+    messages.reset();
+    components.reset();
+  }
+  function commitComponent(component) {
+    messages.addComponent(component);
+    eventBus.emit("ringg:calendar_booking", { status: "shown", componentId: component.component_id });
+    typing.clear();
+    if (!shell.isOpen)
+      notification.play();
+    shell.open();
+  }
+  async function handleAgentTextStream(stream) {
+    if (shell.getSnapshot().callMode !== "text" || !session.isSessionLive)
+      return;
+    try {
+      const message = await stream.readAll();
+      if (!stream.isAgent) {
+        messages.addChatMessage({ message, isSelf: true, name: "You" });
+        messages.clearPendingSourceUrl();
+        return;
+      }
+      await typing.waitMinDuration();
+      if (!shell.isOpen)
+        notification.play();
+      shell.open();
+      messages.addChatMessage({ message, isSelf: false, name: "Agent" });
+      typing.clear();
+      components.onAgentTextLanded();
+    } catch {
+      if (stream.isAgent)
+        typing.clear();
+    }
+  }
+  async function handleBlocksStream(stream) {
+    try {
+      const raw = await stream.readAll();
+      typing.clear();
+      const parsed = JSON.parse(raw);
+      if (parsed.component_type !== "render_component_blocks" || !Array.isArray(parsed.component_config?.blocks))
+        return;
+      components.add({
+        component_type: "blocks",
+        component_id: `blocks_${clock.now()}`,
+        data: parsed.component_config
+      }, shell.getSnapshot().callMode);
+    } catch {
+    }
+  }
+  async function handleDynamicData(invocation) {
+    typing.clear();
+    let parsed;
+    try {
+      parsed = JSON.parse(invocation.payload);
+    } catch {
+      throw new Error("Invalid send_dynamic_data payload");
+    }
+    const componentType = parsed.component_type;
+    if (!componentType) {
+      return JSON.stringify({ status: "error", message: "No component_type provided" });
+    }
+    if (componentType === "execute_dom_action") {
+      const cfg = parsed.component_config ?? parsed.component_data ?? {};
+      const action = {
+        id: cfg.id ?? cfg.action_id ?? "",
+        kind: cfg.kind ?? "trigger_event",
+        event_name: cfg.event_name,
+        default_payload: cfg.default_payload ?? cfg.detail
+      };
+      onDomAction?.(action, pushSystemLog);
+      return JSON.stringify({ status: "received" });
+    }
+    const componentName = componentType.replace("render_component_", "");
+    if (components.runExtensions(componentName, parsed)) {
+      return JSON.stringify({ status: "received" });
+    }
+    const component = transformRpcToComponent(componentName, parsed);
+    if (!component) {
+      return JSON.stringify({ status: "error", message: `Unknown component type: ${componentName}` });
+    }
+    components.trackPendingResponse(component.component_id, {
+      name: componentName,
+      originalConfig: parsed.component_config ?? parsed.component_data
+    });
+    components.add(component, shell.getSnapshot().callMode);
+    return JSON.stringify({ status: "received", component_id: component.component_id });
+  }
+  async function handleRenderComponent(invocation) {
+    typing.clear();
+    let parsed;
+    try {
+      parsed = JSON.parse(invocation.payload);
+    } catch {
+      throw new Error("Invalid component payload");
+    }
+    if (parsed.component_type && parsed.component_id) {
+      components.add(parsed, shell.getSnapshot().callMode);
+    }
+    return JSON.stringify({ status: "received" });
+  }
+  function wireTransport() {
+    transport.registerRpcMethod("send_dynamic_data", (invocation) => handleDynamicData(invocation));
+    transport.registerRpcMethod("render_component", (invocation) => handleRenderComponent(invocation));
+    transport.registerRpcMethod("send_source_urls", async (invocation) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(invocation.payload);
+      } catch {
+        throw new Error("Invalid payload for send_source_urls");
+      }
+      if (Array.isArray(parsed.source_urls))
+        messages.setPendingSourceUrl(parsed.source_urls.join(", "));
+      else if (parsed.source_url)
+        messages.setPendingSourceUrl(String(parsed.source_url));
+      return JSON.stringify({ status: "received" });
+    });
+    transport.registerTextStreamHandler("lk.transcription", (stream) => {
+      void handleAgentTextStream(stream);
+    });
+    transport.registerTextStreamHandler("ringg.blocks", (stream) => {
+      void handleBlocksStream(stream);
+    });
+    unsubscribers.push(transport.onChatMessage((message) => {
+      if (message.isSelf)
+        return;
+      if (shell.getSnapshot().callMode !== "text" || !session.isSessionLive)
+        return;
+      messages.addChatMessage({ message: message.message, isSelf: false, name: message.senderName });
+      if (message.isAgent)
+        typing.clear();
+    }), transport.onTranscription((segment) => {
+      const { callMode } = shell.getSnapshot();
+      if (callMode !== "audio" || session.getSnapshot().connectionState !== "connected")
+        return;
+      messages.upsertTranscription(segment);
+    }), transport.onSessionEnded(() => {
+      if (session.isSessionLive)
+        void controller.endCall();
+    }));
+  }
+  const controller = {
+    config,
+    theme,
+    eventBus,
+    shell,
+    session,
+    messages,
+    typing,
+    components,
+    slashCommands,
+    // ─── Widget shell ──────────────────────────────────────────────────────────
+    openWidget() {
+      shell.open();
+      if (!session.isSessionLive)
+        session.prewarm();
+    },
+    minimizeWidget() {
+      shell.minimize();
+    },
+    handleTriggerClick() {
+      if (config.defaultExpanded)
+        return;
+      const { isLoading, connectionState } = session.getSnapshot();
+      if (config.bypassStartScreen && !isLoading && connectionState === "disconnected" && !session.isSessionLive) {
+        controller.openWidget();
+        void controller.startCall(shell.getSnapshot().callMode);
+      } else if (shell.isOpen) {
+        shell.minimize();
+      } else {
+        controller.openWidget();
+      }
+    },
+    // ─── Call lifecycle ────────────────────────────────────────────────────────
+    async startCall(mediaType) {
+      shell.setCallMode(mediaType);
+      resetConversation();
+      const result = await session.start({
+        agentId: config.agentId,
+        variables: config.variables ?? {},
+        mediaType
+      });
+      if (!result) {
+        typing.clear();
+        return;
+      }
+      shell.setCurrentCallId(result.callId);
+      slashCommands.setRuntimeCommands(result.slashCommands);
+      if (mediaType === "text")
+        typing.showOnUserSend();
+      conversationEndedDispatched = false;
+      eventBus.emit("ringg:conversation_status", { status: "started", mode: mediaType, callId: result.callId });
+    },
+    async endCall() {
+      const { currentCallId, callMode } = shell.getSnapshot();
+      if (currentCallId && !conversationEndedDispatched) {
+        conversationEndedDispatched = true;
+        eventBus.emit("ringg:conversation_status", { status: "ended", mode: callMode, callId: currentCallId });
+      }
+      slashCommands.reset();
+      typing.clear();
+      components.reset();
+      await session.end();
+      if (config.bypassFeedbackScreen) {
+        resetConversation();
+        shell.close();
+      } else {
+        shell.showFeedback();
+        shell.open();
+      }
+    },
+    // ─── Chat ──────────────────────────────────────────────────────────────────
+    async sendMessage(text) {
+      messages.addChatMessage({ message: text, isSelf: true });
+      typing.showOnUserSend();
+      await transport.sendChatMessage(text);
+    },
+    // ─── Components ────────────────────────────────────────────────────────────
+    async sendComponentResponse(componentId, responseData) {
+      const pending = components.takePendingResponse(componentId);
+      if (!pending)
+        return;
+      const { method, payload } = formatComponentResponse(pending.name, componentId, responseData, pending.originalConfig);
+      await transport.performRpcToAgent(method, payload);
+      eventBus.emit("ringg:component_acknowledgement", {
+        componentName: pending.name,
+        componentId,
+        status: "responded"
+      });
+    },
+    async sendBlocksAction(toolId, componentId, action) {
+      const { method, payload } = formatBlocksAction(toolId, componentId, action);
+      try {
+        await transport.performRpcToAgent(method, payload);
+      } catch {
+      }
+    },
+    callComponentApi(method, endpoint, payload) {
+      return api.callComponentApi(method, endpoint, payload);
+    },
+    async sendDynamicData(payload) {
+      const { method, payload: rpcPayload } = formatDynamicData(payload);
+      await transport.performRpcToAgent(method, rpcPayload);
+    },
+    addLocalComponent(component) {
+      messages.addComponent(component);
+    },
+    displaySelection(componentId, label) {
+      messages.addLocalSelection(componentId, label);
+    },
+    markFlowComplete(componentId) {
+      components.markFlowComplete(componentId);
+      eventBus.emit("ringg:calendar_booking", { status: "confirmed", componentId, message: "Flow completed" });
+    },
+    registerDynamicDataExtension(extension) {
+      return components.registerExtension(extension);
+    },
+    // ─── Slash commands ────────────────────────────────────────────────────────
+    async sendSlashCommand(command) {
+      if (components.runExtensions("slash_command", { command: command.command, tool_type: command.tool_type }))
+        return;
+      const { method, payload } = formatSlashCommand(command.command);
+      await transport.performRpcToAgent(method, payload);
+    },
+    // ─── Feedback ──────────────────────────────────────────────────────────────
+    async submitFeedback(rating, comment) {
+      const { currentCallId } = shell.getSnapshot();
+      if (currentCallId) {
+        try {
+          await api.submitFeedback(currentCallId, { rating, comment });
+          eventBus.emit("ringg:feedback_status", { status: "submitted", callId: currentCallId, rating });
+        } catch {
+        }
+      }
+      resetConversation();
+      shell.close();
+    },
+    skipFeedback() {
+      const { currentCallId } = shell.getSnapshot();
+      if (currentCallId) {
+        eventBus.emit("ringg:feedback_status", { status: "skipped", callId: currentCallId });
+      }
+      resetConversation();
+      shell.close();
+    },
+    // ─── Teardown ──────────────────────────────────────────────────────────────
+    destroy() {
+      unsubscribers.forEach((unsubscribe) => unsubscribe());
+      transport.unregisterRpcMethod("send_dynamic_data");
+      transport.unregisterRpcMethod("render_component");
+      transport.unregisterRpcMethod("send_source_urls");
+      transport.unregisterTextStreamHandler("lk.transcription");
+      transport.unregisterTextStreamHandler("ringg.blocks");
+      void transport.disconnect();
+      [shell, session, messages, typing, components, slashCommands].forEach((store) => store.dispose());
+      eventBus.off();
+    }
+  };
+  wireTransport();
+  return controller;
+}
+
+// ../core/dist/react/hooks.js
+var import_react = require("react");
+function useStoreSnapshot(store) {
+  return (0, import_react.useSyncExternalStore)(store.subscribe, store.getSnapshot, store.getSnapshot);
+}
+var useRinggMessages = (controller) => useStoreSnapshot(controller.messages);
+var useRinggTyping = (controller) => useStoreSnapshot(controller.typing);
+var useRinggSession = (controller) => useStoreSnapshot(controller.session);
+var useRinggShell = (controller) => useStoreSnapshot(controller.shell);
+var useRinggComponents = (controller) => useStoreSnapshot(controller.components);
+var useRinggSlashCommands = (controller) => useStoreSnapshot(controller.slashCommands);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCallbackEventBus,
+  createRinggWidgetController,
+  useRinggComponents,
+  useRinggMessages,
+  useRinggSession,
+  useRinggShell,
+  useRinggSlashCommands,
+  useRinggTyping,
+  useStoreSnapshot
+});
+//# sourceMappingURL=index.js.map