@experiaapp/webchat-react-native 2.0.1

package/lib/core/WebchatClient.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebchatClient = createWebchatClient;
+const types_1 = require("./types");
+const logger_1 = require("./logger");
+function createWebchatClient(opts) {
+    var _a, _b;
+    const listeners = {};
+    let socket = null;
+    let sessionTimer = null;
+    const timeoutMs = (_a = opts.sessionTimeoutMs) !== null && _a !== void 0 ? _a : 10000;
+    const maxRetries = (_b = opts.maxSessionRetries) !== null && _b !== void 0 ? _b : 3;
+    // B7 retry bookkeeping (per connect lifecycle).
+    let retryCount = 0;
+    // C4/de-dupe: 'connected' fires once per connected period — not on every
+    // socket 'connect' event (socket.io can re-fire 'connect' within a single
+    // connection). Reset on 'disconnect' so a genuine reconnect re-emits it.
+    let connectedEmitted = false;
+    const emit = (event, data) => { var _a; return ((_a = listeners[event]) !== null && _a !== void 0 ? _a : []).forEach((l) => l(data)); };
+    function clearSessionTimer() {
+        if (sessionTimer) {
+            clearTimeout(sessionTimer);
+            sessionTimer = null;
+        }
+    }
+    // C2: registered ONCE when the socket is created (not per reconnect)
+    function wireSessionConfirm(s) {
+        s.on("session_confirm", (status) => {
+            var _a, _b;
+            clearSessionTimer();
+            retryCount = 0; // recovered — reset the backoff ladder
+            // The LIVE backend sends `session_confirm` as a BARE STRING that IS the session
+            // id (web parity: redux/auth/actions.ts passes the payload straight through as
+            // `newSessionId`). Reading `status.session_id` off a string yields undefined, so
+            // the id was lost — user_uttered then went out with session_id:"" and every
+            // reconnect re-requested a brand-new session. Extract robustly: a string is the
+            // id; otherwise fall back to the object forms ({session_id}/{sessionId}) older
+            // servers/tests use.
+            const id = typeof status === "string"
+                ? status
+                : (_b = (_a = status === null || status === void 0 ? void 0 : status.session_id) !== null && _a !== void 0 ? _a : status === null || status === void 0 ? void 0 : status.sessionId) !== null && _b !== void 0 ? _b : "";
+            emit("status", "session-confirmed");
+            emit("session", id);
+        });
+    }
+    // B7: exponential backoff (capped). delay = timeoutMs * 2^retryCount.
+    function scheduleSessionTimeout() {
+        clearSessionTimer();
+        const delay = timeoutMs * Math.pow(2, retryCount);
+        sessionTimer = setTimeout(() => {
+            sessionTimer = null;
+            if (retryCount < maxRetries) {
+                retryCount += 1;
+                logger_1.logger.warn(`session_request retry ${retryCount}/${maxRetries}`);
+                // re-emit session_request (recovers when a later session_confirm lands)
+                requestSession();
+            }
+            else {
+                logger_1.logger.warn("session_request gave up after max retries");
+                emit("status", "session-failed");
+                emit("error", new types_1.WebChatError("session-timeout", "no session_confirm", true));
+            }
+        }, delay);
+    }
+    // B8: resume by stored id (provided by the host/persistence layer)
+    function requestSession() {
+        var _a, _b;
+        if (!socket)
+            return;
+        socket.emit("session_request", { session_id: (_b = (_a = opts.getStoredSessionId) === null || _a === void 0 ? void 0 : _a.call(opts)) !== null && _b !== void 0 ? _b : "" });
+        emit("status", "session-pending");
+        scheduleSessionTimeout();
+    }
+    return {
+        on(event, cb) { var _a; ((_a = listeners[event]) !== null && _a !== void 0 ? _a : (listeners[event] = [])).push(cb); },
+        connect() {
+            var _a;
+            retryCount = 0;
+            connectedEmitted = false;
+            socket = opts.socketFactory();
+            wireSessionConfirm(socket); // once per socket instance (C2)
+            socket.on("bot_uttered", (data) => emit("message", data));
+            // Inbound feedback confirmation (web parity): the server reflects a like/dislike
+            // toggle back on "activityAck" with { messageKey, type }. Re-emit it so the
+            // provider can map type -> userReaction and dispatch a REACT.
+            socket.on("activityAck", (data) => emit("activityAck", data));
+            socket.on("connect", () => {
+                // de-dupe: one 'connected' per session lifecycle, not per reconnect
+                // 'connect' (socket.io auto-reconnect re-fires this repeatedly).
+                if (!connectedEmitted) {
+                    connectedEmitted = true;
+                    emit("status", "connected");
+                }
+                requestSession();
+            });
+            socket.on("disconnect", () => {
+                clearSessionTimer();
+                // Reset the de-dupe latch so the NEXT genuine (re)connect re-emits
+                // 'connected'. Consumers (provider B10 queue flush) rely on a fresh
+                // 'connected' per connected period; the latch only suppresses socket.io
+                // firing 'connect' repeatedly within a single uninterrupted connection.
+                connectedEmitted = false;
+                emit("status", "reconnecting");
+            });
+            // C4/#14/#15: surface transport-level failures as a typed connection error
+            // plus a 'disconnected' status (distinct from 'reconnecting').
+            const onConnError = (err) => {
+                emit("status", "disconnected");
+                emit("error", new types_1.WebChatError("connection", "socket connection error", true, err));
+            };
+            socket.on("connect_error", onConnError);
+            socket.on("error", onConnError);
+            (_a = socket.connect) === null || _a === void 0 ? void 0 : _a.call(socket);
+        },
+        sendMessage(payload) {
+            socket === null || socket === void 0 ? void 0 : socket.emit("user_uttered", payload);
+        },
+        /**
+         * Emit a feedback activity (web parity): `socket.emit("activity", { messageKey, type })`.
+         * `type` is the backend verb the provider computes from the toggle —
+         * "like" | "unlike" | "dislike" | "undislike". The matching inbound reflection
+         * arrives on "activityAck" (re-emitted as the client's "activityAck" event).
+         */
+        emitActivity(payload) {
+            socket === null || socket === void 0 ? void 0 : socket.emit("activity", payload);
+        },
+        disconnect() {
+            clearSessionTimer();
+            socket === null || socket === void 0 ? void 0 : socket.disconnect();
+        },
+    };
+}

package/lib/core/configClient.d.ts

@@ -0,0 +1,42 @@
+import { Config } from "./types";
+/** Minimal fetch surface — matches the global `fetch` (and node/undici). */
+export type FetchLike = (input: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json(): Promise<unknown>;
+}>;
+/** Server config never carries the connection trio — that comes from the host. */
+export type ServerConfig = Partial<Omit<Config, "channelId" | "configUrl" | "connectionUrl">>;
+/**
+ * SDK defaults — the lowest-precedence layer. Connection fields are intentionally
+ * absent (the host must supply them); behaviour flags default to the web widget's
+ * baseline.
+ */
+export declare const DEFAULT_CONFIG: ServerConfig;
+/**
+ * Fetch the server-side config for a channel (web parity).
+ *
+ * Hits `https://${configUrl}/api/webchat/options?channelID=${channelId}` and
+ * defensively double-parses the body (the web ships a stringified JSON body, but
+ * a plain object is tolerated too). The payload is then mapped onto the flat
+ * {@link ServerConfig} shape via {@link mapPayload}.
+ *
+ * @param configUrl  config host (scheme optional — `https://` is prepended).
+ * @param channelId  tenant channel id (sent as the `channelID` query param).
+ * @param fetchImpl  injected fetch (defaults to the ambient global).
+ * @throws WebChatError('config-fetch', …, recoverable=true) on network/non-2xx/parse
+ *         failure — recoverable so the host can retry.
+ */
+export declare function fetchConfig(configUrl: string, channelId: string, fetchImpl?: FetchLike): Promise<ServerConfig>;
+/**
+ * Merge config layers with precedence prop > server > default (S5/S8).
+ *
+ * `publicStyle` is merged shallowly across layers (so a server can set a brand
+ * colour and the host can override just the font without dropping the colour).
+ * The connection trio (channelId/configUrl/connectionUrl) comes only from the
+ * host prop — it is required there and not overridable by the server.
+ */
+export declare function mergeConfig(propConfig: Config, serverConfig?: ServerConfig | null): Config;

package/lib/core/configClient.js

@@ -0,0 +1,302 @@
+"use strict";
+// src/core/configClient.ts
+//
+// Config fetch + merge (audit #2 / S5 / S8). Framework-agnostic: `fetch` is
+// injectable so the core never depends on a browser/RN global and tests run
+// offline. Two pure-ish functions:
+//
+//   fetchConfig(configUrl, channelId, fetchImpl?) -> Partial<Config>  (server view)
+//   mergeConfig(propConfig, serverConfig)         -> Config            (prop > server > default)
+//
+// Precedence (S5/S8): a value provided by the host prop wins over the server,
+// which wins over the SDK default. `undefined` prop/server fields fall through
+// to the next layer (so a host can omit a field and inherit the server value).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+exports.fetchConfig = fetchConfig;
+exports.mergeConfig = mergeConfig;
+const types_1 = require("./types");
+const logger_1 = require("./logger");
+/**
+ * SDK defaults — the lowest-precedence layer. Connection fields are intentionally
+ * absent (the host must supply them); behaviour flags default to the web widget's
+ * baseline.
+ */
+exports.DEFAULT_CONFIG = {
+    interfaceTheme: "experia",
+    language: "en",
+    autoConnection: false,
+    enableConnection: true,
+    openOnLoad: false,
+    sendWelcomeMessage: true,
+    disabledInput: false,
+    // Default-ON (web parity: defualtConfig.makeVideoCall === true). A host prop or
+    // server config can opt out with makeVideoCall:false — both are honored because the
+    // button gates on the RESOLVED config (prop > server > default), see WebChat.tsx.
+    makeVideoCall: true,
+    uploadMedia: true,
+    uploadAudio: true,
+    // Tier A web-parity defaults (web defualtConfig.ts):
+    uploadImage: true,
+    uploadDocuments: true,
+    uploadVideo: true,
+    emoji: false, // web defaultConfig.emoji === false
+    showButtonChat: true,
+    showMessageDate: true,
+    // Tier B-3a chrome-feature defaults (web defualtConfig.ts):
+    displayTypingIndication: false, // web defaultConfig.displayTypingIndication === false
+    showPoweredBy: true,
+    showAvatar: true,
+    autoJoinVideoCall: false,
+    statusIndicatorPosition: "top-right",
+    // Tier C web-shell keys (CONFIG-PARITY-AUDIT.md Tier C). storage selects the
+    // persistence backend (web parity default "localStorage" -> persistent store);
+    // hideWhenNotConnected defaults FALSE in the SDK (opt-in) so the open-to-connect
+    // flow is never broken even though web defaults it true; embedded defaults false
+    // (floating); fullScreenHeight defaults true (full-height, today's flex:1);
+    // typeWidget defaults "default" (the only shell the SDK models).
+    storage: "localStorage",
+    hideWhenNotConnected: false,
+    embedded: false,
+    fullScreenHeight: true,
+    typeWidget: "default",
+    ttlMs: 24 * 60 * 60 * 1000, // 24h sliding TTL
+};
+function resolveFetch(injected) {
+    if (injected)
+        return injected;
+    const g = globalThis.fetch;
+    if (g)
+        return g;
+    throw new types_1.WebChatError("config-fetch", "no fetch implementation available", false);
+}
+/**
+ * Build the web-parity options endpoint. The web fetches
+ * `https://${configUrl}/api/webchat/options?channelID=${channelId}` — so we
+ * prepend `https://` when `configUrl` carries no scheme, strip a trailing slash,
+ * and append the documented path + query.
+ */
+function buildOptionsUrl(configUrl, channelId) {
+    const withScheme = /^[a-z]+:\/\//i.test(configUrl) ? configUrl : `https://${configUrl}`;
+    const base = withScheme.replace(/\/$/, "");
+    return `${base}/api/webchat/options?channelID=${encodeURIComponent(channelId)}`;
+}
+/**
+ * Map the web options payload onto the SDK's flat {@link ServerConfig} shape.
+ *
+ * Behaviour flags live under `payload.config.*` and styles under `payload.theme.*`
+ * (web parity). We read those nested locations first, then fall back to the same
+ * key at the top level — so a server that single-encodes a flat object (or a test
+ * fixture) still maps. Missing fields are simply omitted.
+ */
+function mapPayload(payload) {
+    var _a, _b;
+    const p = payload !== null && payload !== void 0 ? payload : {};
+    const cfg = (_a = p.config) !== null && _a !== void 0 ? _a : {};
+    const theme = (_b = p.theme) !== null && _b !== void 0 ? _b : {};
+    const out = {};
+    // flag <- payload.config.flag ?? payload.flag (nested preferred, flat tolerated).
+    const flag = (k) => (cfg[k] !== undefined ? cfg[k] : p[k]);
+    const style = (k) => (theme[k] !== undefined ? theme[k] : p[k]);
+    if (p.interfaceTheme !== undefined)
+        out.interfaceTheme = p.interfaceTheme;
+    if (flag("language") !== undefined)
+        out.language = flag("language");
+    if (flag("autoConnection") !== undefined)
+        out.autoConnection = flag("autoConnection");
+    if (flag("openOnLoad") !== undefined)
+        out.openOnLoad = flag("openOnLoad");
+    if (flag("sendWelcomeMessage") !== undefined)
+        out.sendWelcomeMessage = flag("sendWelcomeMessage");
+    if (flag("disabledInput") !== undefined)
+        out.disabledInput = flag("disabledInput");
+    if (flag("makeVideoCall") !== undefined)
+        out.makeVideoCall = flag("makeVideoCall");
+    if (flag("autoJoinVideoCall") !== undefined)
+        out.autoJoinVideoCall = flag("autoJoinVideoCall");
+    if (flag("uploadMedia") !== undefined)
+        out.uploadMedia = flag("uploadMedia");
+    if (flag("uploadAudio") !== undefined)
+        out.uploadAudio = flag("uploadAudio");
+    if (flag("uploadImage") !== undefined)
+        out.uploadImage = flag("uploadImage");
+    if (flag("uploadDocuments") !== undefined)
+        out.uploadDocuments = flag("uploadDocuments");
+    if (flag("uploadVideo") !== undefined)
+        out.uploadVideo = flag("uploadVideo");
+    if (flag("emoji") !== undefined)
+        out.emoji = flag("emoji");
+    if (flag("showCloseButton") !== undefined)
+        out.showCloseButton = flag("showCloseButton");
+    if (flag("showButtonChat") !== undefined)
+        out.showButtonChat = flag("showButtonChat");
+    if (flag("showMessageDate") !== undefined)
+        out.showMessageDate = flag("showMessageDate");
+    if (flag("displayTypingIndication") !== undefined)
+        out.displayTypingIndication = flag("displayTypingIndication");
+    if (flag("showPoweredBy") !== undefined)
+        out.showPoweredBy = flag("showPoweredBy");
+    if (flag("showAvatar") !== undefined)
+        out.showAvatar = flag("showAvatar");
+    if (flag("avatar") !== undefined)
+        out.avatar = flag("avatar");
+    if (flag("closeImage") !== undefined)
+        out.closeImage = flag("closeImage");
+    if (flag("openLauncherImage") !== undefined)
+        out.openLauncherImage = flag("openLauncherImage");
+    if (flag("closeLauncherImage") !== undefined)
+        out.closeLauncherImage = flag("closeLauncherImage");
+    if (flag("title") !== undefined)
+        out.title = flag("title");
+    if (flag("subTitle") !== undefined)
+        out.subTitle = flag("subTitle");
+    if (flag("connectingText") !== undefined)
+        out.connectingText = flag("connectingText");
+    if (flag("inputTextFieldHint") !== undefined)
+        out.inputTextFieldHint = flag("inputTextFieldHint");
+    if (flag("statusIndicatorPosition") !== undefined)
+        out.statusIndicatorPosition = flag("statusIndicatorPosition");
+    if (flag("prechatForm") !== undefined)
+        out.prechatForm = flag("prechatForm");
+    // Tier C web-shell keys — mapped so the server value reaches the SDK. `storage`
+    // selects the persistence backend; `hideWhenNotConnected`/`embedded`/`fullScreenHeight`
+    // adjust surface/launcher layout + visibility; `typeWidget` is accepted but only
+    // "default" is modeled (non-default falls back to default at the consumer).
+    if (flag("storage") !== undefined)
+        out.storage = flag("storage");
+    if (flag("hideWhenNotConnected") !== undefined)
+        out.hideWhenNotConnected = flag("hideWhenNotConnected");
+    if (flag("embedded") !== undefined)
+        out.embedded = flag("embedded");
+    if (flag("fullScreenHeight") !== undefined)
+        out.fullScreenHeight = flag("fullScreenHeight");
+    if (flag("typeWidget") !== undefined)
+        out.typeWidget = flag("typeWidget");
+    if (style("publicStyle") !== undefined)
+        out.publicStyle = style("publicStyle");
+    if (style("chatSectionStyle") !== undefined)
+        out.chatSectionStyle = style("chatSectionStyle");
+    if (style("headerSectionStyle") !== undefined)
+        out.headerSectionStyle = style("headerSectionStyle");
+    if (style("sendSectionStyle") !== undefined)
+        out.sendSectionStyle = style("sendSectionStyle");
+    if (style("wedgitSectionStyle") !== undefined)
+        out.wedgitSectionStyle = style("wedgitSectionStyle");
+    return out;
+}
+/**
+ * Fetch the server-side config for a channel (web parity).
+ *
+ * Hits `https://${configUrl}/api/webchat/options?channelID=${channelId}` and
+ * defensively double-parses the body (the web ships a stringified JSON body, but
+ * a plain object is tolerated too). The payload is then mapped onto the flat
+ * {@link ServerConfig} shape via {@link mapPayload}.
+ *
+ * @param configUrl  config host (scheme optional — `https://` is prepended).
+ * @param channelId  tenant channel id (sent as the `channelID` query param).
+ * @param fetchImpl  injected fetch (defaults to the ambient global).
+ * @throws WebChatError('config-fetch', …, recoverable=true) on network/non-2xx/parse
+ *         failure — recoverable so the host can retry.
+ */
+async function fetchConfig(configUrl, channelId, fetchImpl) {
+    const doFetch = resolveFetch(fetchImpl);
+    const url = buildOptionsUrl(configUrl, channelId);
+    let res;
+    try {
+        res = await doFetch(url, {
+            method: "GET",
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    catch (cause) {
+        logger_1.logger.warn("config fetch failed (network)");
+        throw new types_1.WebChatError("config-fetch", "config fetch failed", true, cause);
+    }
+    if (!res.ok) {
+        logger_1.logger.warn("config fetch failed (status)", res.status);
+        throw new types_1.WebChatError("config-fetch", `config fetch failed: ${res.status}`, true);
+    }
+    try {
+        // Defensive double-parse: the web body is a JSON-encoded string, but a server
+        // returning a plain object is tolerated (parse only when we got a string).
+        const raw = await res.json();
+        const payload = (typeof raw === "string" ? JSON.parse(raw) : raw);
+        return mapPayload(payload);
+    }
+    catch (cause) {
+        logger_1.logger.warn("config parse failed");
+        throw new types_1.WebChatError("config-fetch", "config parse failed", true, cause);
+    }
+}
+/** Pick only the keys whose value is not `undefined` (so they actually override). */
+function defined(o) {
+    if (!o)
+        return {};
+    const out = {};
+    for (const k of Object.keys(o)) {
+        if (o[k] !== undefined)
+            out[k] = o[k];
+    }
+    return out;
+}
+/**
+ * Merge config layers with precedence prop > server > default (S5/S8).
+ *
+ * `publicStyle` is merged shallowly across layers (so a server can set a brand
+ * colour and the host can override just the font without dropping the colour).
+ * The connection trio (channelId/configUrl/connectionUrl) comes only from the
+ * host prop — it is required there and not overridable by the server.
+ */
+function mergeConfig(propConfig, serverConfig) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const server = defined(serverConfig !== null && serverConfig !== void 0 ? serverConfig : {});
+    const prop = defined(propConfig);
+    const publicStyle = {
+        ...exports.DEFAULT_CONFIG.publicStyle,
+        ...((_a = server.publicStyle) !== null && _a !== void 0 ? _a : {}),
+        ...((_b = prop.publicStyle) !== null && _b !== void 0 ? _b : {}),
+    };
+    // chatSectionStyle is merged shallowly across layers too (so a server can set
+    // bubble colours and the host can override just one without dropping the rest).
+    const chatSectionStyle = {
+        ...exports.DEFAULT_CONFIG.chatSectionStyle,
+        ...((_c = server.chatSectionStyle) !== null && _c !== void 0 ? _c : {}),
+        ...((_d = prop.chatSectionStyle) !== null && _d !== void 0 ? _d : {}),
+    };
+    // header/send section styles merge shallowly across layers, like publicStyle.
+    const headerSectionStyle = {
+        ...exports.DEFAULT_CONFIG.headerSectionStyle,
+        ...((_e = server.headerSectionStyle) !== null && _e !== void 0 ? _e : {}),
+        ...((_f = prop.headerSectionStyle) !== null && _f !== void 0 ? _f : {}),
+    };
+    const sendSectionStyle = {
+        ...exports.DEFAULT_CONFIG.sendSectionStyle,
+        ...((_g = server.sendSectionStyle) !== null && _g !== void 0 ? _g : {}),
+        ...((_h = prop.sendSectionStyle) !== null && _h !== void 0 ? _h : {}),
+    };
+    const wedgitSectionStyle = {
+        ...exports.DEFAULT_CONFIG.wedgitSectionStyle,
+        ...((_j = server.wedgitSectionStyle) !== null && _j !== void 0 ? _j : {}),
+        ...((_k = prop.wedgitSectionStyle) !== null && _k !== void 0 ? _k : {}),
+    };
+    const merged = {
+        ...exports.DEFAULT_CONFIG,
+        ...server,
+        ...prop,
+        // connection trio is authoritative from the prop
+        channelId: propConfig.channelId,
+        configUrl: propConfig.configUrl,
+        connectionUrl: propConfig.connectionUrl,
+    };
+    if (Object.keys(publicStyle).length > 0)
+        merged.publicStyle = publicStyle;
+    if (Object.keys(chatSectionStyle).length > 0)
+        merged.chatSectionStyle = chatSectionStyle;
+    if (Object.keys(headerSectionStyle).length > 0)
+        merged.headerSectionStyle = headerSectionStyle;
+    if (Object.keys(sendSectionStyle).length > 0)
+        merged.sendSectionStyle = sendSectionStyle;
+    if (Object.keys(wedgitSectionStyle).length > 0)
+        merged.wedgitSectionStyle = wedgitSectionStyle;
+    return merged;
+}

package/lib/core/greet.d.ts

@@ -0,0 +1,11 @@
+export declare function buildGreet(prechat: Record<string, string>): {
+    message: "/chitchat.greet";
+    prechatFormSubmission?: undefined;
+} | {
+    message: string;
+    prechatFormSubmission: Record<string, string>;
+};
+export declare const shouldGreet: (o: {
+    sessionId: string;
+    greetedSessions: Set<string>;
+}) => boolean;

package/lib/core/greet.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldGreet = void 0;
+exports.buildGreet = buildGreet;
+// src/core/greet.ts
+function buildGreet(prechat) {
+    const keys = Object.keys(prechat);
+    if (keys.length === 0)
+        return { message: "/chitchat.greet" };
+    const lines = keys.map((k) => `${k}: ${prechat[k]}`).join("\n");
+    return {
+        message: `/chitchat.greet\nForm Response :\n${lines}`,
+        prechatFormSubmission: prechat,
+    };
+}
+const shouldGreet = (o) => !!o.sessionId && !o.greetedSessions.has(o.sessionId);
+exports.shouldGreet = shouldGreet;

package/lib/core/ice.d.ts

@@ -0,0 +1,31 @@
+/** Shape of a single ICE server entry (RTCIceServer-compatible). */
+export interface IceServer {
+    urls: string;
+    username?: string;
+    credential?: string;
+}
+/** RTCConfiguration-shaped object consumed by `createPeerConnection`. */
+export interface PcConfig {
+    iceServers: IceServer[];
+}
+/**
+ * Web-parity TURN credentials. Exported so the adapter/tests can assert parity
+ * with the web widget without duplicating the literals.
+ */
+export declare const TURN_URL = "turn:141.147.138.24:3478";
+export declare const TURN_USERNAME = "root";
+export declare const TURN_CREDENTIAL = "1234567";
+export declare const STUN_URL = "stun:stun.l.google.com:19302";
+/**
+ * The web-parity `pc_config`. Order matches the web widget: STUN first, TURN second.
+ * Returns a fresh object/array each call so callers can't mutate the shared config.
+ */
+export declare function iceServers(): PcConfig;
+/** ICE candidate types the web widget forwards over the signaling channel. */
+export type CandidateType = "host" | "prflx" | "relay" | "srflx" | string;
+/**
+ * Host-candidate policy (C7) — mirror the web widget: forward only
+ * `prflx`/`relay`/`srflx` candidates; drop `host` candidates. There is no
+ * same-LAN host fallback today (revisit only if a tenant requires it).
+ */
+export declare function isForwardableCandidate(type: CandidateType | null | undefined): boolean;

package/lib/core/ice.js

@@ -0,0 +1,48 @@
+"use strict";
+// src/core/ice.ts
+// Static ICE / pc_config — WEB PARITY (B12 resolved to parity, no ephemeral creds).
+//
+// Mirrors the chatbot web UI `pc_config` exactly (see web `VideoCall.tsx`):
+//   - STUN  stun:stun.l.google.com:19302
+//   - TURN  turn:141.147.138.24:3478  (username "root", credential "1234567")
+//
+// Distribution is a private registry, so exposing these static creds mirrors the
+// web widget's exposure. There is NO fetch endpoint and NO ephemeral-credential
+// flow — the call uses the same hard-coded servers the web widget ships with.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STUN_URL = exports.TURN_CREDENTIAL = exports.TURN_USERNAME = exports.TURN_URL = void 0;
+exports.iceServers = iceServers;
+exports.isForwardableCandidate = isForwardableCandidate;
+/**
+ * Web-parity TURN credentials. Exported so the adapter/tests can assert parity
+ * with the web widget without duplicating the literals.
+ */
+exports.TURN_URL = "turn:141.147.138.24:3478";
+exports.TURN_USERNAME = "root";
+exports.TURN_CREDENTIAL = "1234567";
+exports.STUN_URL = "stun:stun.l.google.com:19302";
+/**
+ * The web-parity `pc_config`. Order matches the web widget: STUN first, TURN second.
+ * Returns a fresh object/array each call so callers can't mutate the shared config.
+ */
+function iceServers() {
+    return {
+        iceServers: [
+            { urls: exports.STUN_URL },
+            {
+                urls: exports.TURN_URL,
+                username: exports.TURN_USERNAME,
+                credential: exports.TURN_CREDENTIAL,
+            },
+        ],
+    };
+}
+const FORWARDABLE = new Set(["prflx", "relay", "srflx"]);
+/**
+ * Host-candidate policy (C7) — mirror the web widget: forward only
+ * `prflx`/`relay`/`srflx` candidates; drop `host` candidates. There is no
+ * same-LAN host fallback today (revisit only if a tenant requires it).
+ */
+function isForwardableCandidate(type) {
+    return type != null && FORWARDABLE.has(type);
+}

package/lib/core/linkify.d.ts

@@ -0,0 +1,11 @@
+export type Token = {
+    type: "text";
+    value: string;
+} | {
+    type: "link";
+    value: string;
+    href: string;
+};
+export declare function linkify(text: string): Token[];
+/** schemes safe to hand to Linking.openURL without confirmation */
+export declare const isSafeHref: (href: string) => boolean;

package/lib/core/linkify.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSafeHref = void 0;
+exports.linkify = linkify;
+const URL_RE = /(https:\/\/[^\s]+)|([\w.+-]+@[\w-]+\.[\w.-]+)|(tel:\+?[\d-]+)/g;
+function linkify(text) {
+    var _a;
+    const tokens = [];
+    let last = 0;
+    for (const m of text.matchAll(URL_RE)) {
+        const idx = (_a = m.index) !== null && _a !== void 0 ? _a : 0;
+        if (idx > last)
+            tokens.push({ type: "text", value: text.slice(last, idx) });
+        const raw = m[0];
+        const href = raw.startsWith("https://") ? raw : raw.startsWith("tel:") ? raw : `mailto:${raw}`;
+        tokens.push({ type: "link", value: raw, href });
+        last = idx + raw.length;
+    }
+    if (last < text.length)
+        tokens.push({ type: "text", value: text.slice(last) });
+    return tokens.length ? tokens : [{ type: "text", value: text }];
+}
+/** schemes safe to hand to Linking.openURL without confirmation */
+const isSafeHref = (href) => /^https:\/\//.test(href);
+exports.isSafeHref = isSafeHref;

package/lib/core/logger.d.ts

@@ -0,0 +1,17 @@
+export interface Logger {
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+/**
+ * Build a logger. In release (`__DEV__` !== true) every method is a no-op so no
+ * core diagnostics reach production logs. In dev they forward to the matching
+ * `console` method behind a stable prefix.
+ *
+ * @param sink injectable console-like sink (tests assert calls without spying on
+ *             the global console).
+ */
+export declare function createLogger(sink?: Partial<Console>): Logger;
+/** Process-wide default logger (dev-gated). */
+export declare const logger: Logger;