@getcredify/credify-insurance-widget 1.40.0 → 1.41.0

package/dist/internal/IframeWidgetController.d.ts

@@ -0,0 +1,6 @@
+/**
+ * IframeWidgetController handles the widget in iframe mode.
+ * It communicates with the parent window via postMessage API.
+ */
+export default function IframeWidgetController(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=IframeWidgetController.d.ts.map

package/dist/internal/WidgetController.d.ts

@@ -0,0 +1,6 @@
+import type { Product } from '@getcredify/credify-insurance-ui-kit/core';
+export default function WidgetController({ isOpen, product }: {
+    isOpen: boolean;
+    product?: Product;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=WidgetController.d.ts.map

package/dist/internal/configureKit.d.ts

@@ -0,0 +1,4 @@
+export declare const configureKit: () => void;
+/** Test seam — lets a suite reconfigure with its own doubles. */
+export declare const resetKitConfiguration: () => void;
+//# sourceMappingURL=configureKit.d.ts.map

package/dist/internal/ensureFont.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureFont(): void;
+//# sourceMappingURL=ensureFont.d.ts.map

package/dist/mock/config.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Resolves whether the widget should run in MOCK mode for the current page load.
+ *
+ * Mirrors the live-support config pattern (see ../utils/support/config.ts): the
+ * key is baked at build time via the Vite `define` global `__CREDIFY_MOCK__`
+ * (from the VITE_MOCK_KEY env var). Mock mode activates only when the page URL
+ * carries `?mock=<key>` AND the value matches the baked key exactly.
+ *
+ * This is a developer/QA affordance for walking the full quote flow with no real
+ * API calls — useful for design and flow verification. Because no key is baked
+ * into normal production builds (VITE_MOCK_KEY is unset), mock mode can never be
+ * triggered there: the guard short-circuits and the live API layer is untouched.
+ *
+ * Security note: a key shipped in client JS is discoverable by anyone who reads
+ * the bundle, so this is an *unguessable* gate, not a secret. That is acceptable
+ * here because mock mode is consequence-free — it issues zero backend requests
+ * and only affects the browser session that supplied the matching key.
+ */
+export declare const isMockBuild: () => boolean;
+/** URL query param that carries the mock key, e.g. `?mock=<key>`. */
+export declare const MOCK_QUERY_PARAM = "mock";
+/** The mock key baked into this build, or `undefined` when none was configured. */
+export declare function getMockKey(): string | undefined;
+/**
+ * Returns true when this page load should run in mock mode: a key is baked into
+ * the build and the current URL's `?mock=` value matches it exactly. Safe to call
+ * in any environment — returns false when `window` is unavailable.
+ */
+export declare function isMockEnabled(): boolean;
+//# sourceMappingURL=config.d.ts.map

package/dist/mock/installMockFetch.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Install the mock fetch interceptor when mock mode is active for this page load.
+ * Safe and idempotent: returns immediately when mock mode is off or already set up.
+ */
+export declare function maybeInstallMockFetch(): void;
+//# sourceMappingURL=installMockFetch.d.ts.map

package/dist/mockJump-CL8w249w-KvYoZQMN.js

@@ -0,0 +1,19 @@
+import { f as o } from "./widget-BEY4lY4B.js";
+(function() {
+  if (typeof t > "u")
+    var t = { env: {} };
+})();
+var r = /^#step-(\d+)$/, i = (t) => {
+  let e = r.exec(t.trim());
+  if (!e) return null;
+  let n = Number.parseInt(e[1] ?? "", 10);
+  return n >= 1 ? n - 1 : null;
+}, l = () => !o() || typeof window > "u" ? null : i(window.location.hash), w = (t) => {
+  if (!o() || typeof window > "u") return;
+  let e = `#step-${t + 1}`;
+  window.location.hash !== e && window.history.replaceState(window.history.state, "", e);
+};
+export {
+  l as mockStepFromUrl,
+  w as writeMockStepHash
+};

package/dist/utils/api.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Where the API lives.
+ *
+ * All that survives of a 344-line client: the ui-kit owns the transport, the
+ * session and every endpoint now, and takes this as injected configuration (see
+ * internal/configureKit.ts).
+ *
+ * Read from the build environment rather than written here, because this file
+ * used to be edited to point at a local backend and the commented-out
+ * production line was one `git add` away from shipping. CI would not have
+ * caught it: a build that talks to `localhost:3000` looks perfectly healthy
+ * until it reaches a customer's browser.
+ *
+ * Local development sets `VITE_API_BASE_URL=http://localhost:3000` in `.env`.
+ * A build with no override gets production, and `scripts/check-api-url.mjs`
+ * refuses to publish anything that is not https.
+ *
+ * The kit itself has no default at all — `getApiConfig()` throws when
+ * cspell:disable-next-line
+ * unconfigured — because a silent fallback would send a real quote to the wrong
+ * host.
+ */
+export declare const BASE_URL: string;
+//# sourceMappingURL=api.d.ts.map

package/dist/utils/events.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Public event emitter for the Credify Insurance Widget.
+ *
+ * Replaces the old GTM dataLayer integration: instead of pushing analytics
+ * events to `window.dataLayer`, the widget now emits typed events that host
+ * pages subscribe to via `CredifyInsuranceWidget.on(event, callback)`. Hosts
+ * can forward these to whatever analytics tool they use (GTM, Segment, etc.).
+ *
+ * The emitter is a module-level singleton so internal `emit*` call sites and
+ * the public `on`/`off` API share one registry within the host page's realm.
+ * In iframe mode the events are bridged to the parent window over postMessage
+ * (see internal/IframeWidgetController.tsx), since the iframe runs in a
+ * separate JS realm where this singleton is not reachable from the host.
+ */
+/** Payload shared by the per-stage events. */
+export interface StageEventData {
+    stageKey: string;
+    stageTitle: string;
+    stepIndex: number;
+    totalSteps: number;
+}
+/**
+ * Correlation metadata delivered as the second argument to every listener,
+ * regardless of the event's own payload. Lets hosts stitch the funnel
+ * (widgetOpened → stageViewed → … → ratesViewed) to a single quote.
+ *
+ * `quoteId` is read from storage at emit time, so it is `null` for events that
+ * fire before a quote exists (e.g. the first `widgetOpened`/`stageViewed`) and
+ * the real id thereafter.
+ */
+export interface WidgetEventMeta {
+    /** The quote this event belongs to, or `null` before one has been created. */
+    quoteId: string | null;
+    /** Epoch milliseconds at which the event was emitted. */
+    timestamp: number;
+}
+/**
+ * Map of every public widget event to its callback payload. `void` means the
+ * event carries no data; its listeners are invoked with no argument.
+ */
+export interface WidgetEventMap {
+    /** The widget overlay was opened. */
+    widgetOpened: void;
+    /** The widget overlay was closed (Escape, close button, or programmatic). */
+    widgetClosed: void;
+    /** A form stage became visible to the user. */
+    stageViewed: StageEventData;
+    /** A form stage was successfully completed (Next/submit). */
+    stageCompleted: StageEventData;
+    /** All stages were completed and rate generation started. */
+    flowCompleted: void;
+    /** The rates screen is being shown. */
+    ratesViewed: {
+        rateCount: number;
+    };
+    /** The user navigated back from the rates screen. */
+    ratesBack: void;
+    /**
+     * Quote submission failed and the user was shown an error/timeout state.
+     * Drives proactive live support; also forwarded to hosts for analytics.
+     */
+    submissionFailed: {
+        reason: 'submission' | 'timeout' | 'network';
+    };
+    /**
+     * A product-analytics event from the quote flow itself, forwarded verbatim.
+     *
+     * Additive on purpose: the flow reports things like `quote_flow_start` and
+     * `quote_step_completed`, and rather than minting a public widget event for
+     * each — freezing the flow's vocabulary into this package's API — they arrive
+     * here as a name and a payload. Existing listeners are unaffected.
+     */
+    telemetry: {
+        event: string;
+        properties?: Record<string, unknown>;
+    };
+}
+export type WidgetEventName = keyof WidgetEventMap;
+/**
+ * Runtime list of every event name — the single source of truth used to bridge
+ * events over postMessage in iframe mode. Declared `satisfies` so the compiler
+ * fails if it ever drifts from {@link WidgetEventMap}.
+ */
+export declare const WIDGET_EVENT_NAMES: readonly ["widgetOpened", "widgetClosed", "stageViewed", "stageCompleted", "flowCompleted", "ratesViewed", "ratesBack", "submissionFailed", "telemetry"];
+export type WidgetEventListener<E extends WidgetEventName> = (data: WidgetEventMap[E], meta: WidgetEventMeta) => void;
+/**
+ * `emit` accepts a payload argument only for events whose payload is not
+ * `void`, so `emit('widgetOpened')` and `emit('ratesViewed', { rateCount })`
+ * are both correctly typed.
+ */
+type EmitArgs<E extends WidgetEventName> = WidgetEventMap[E] extends void ? [] : [WidgetEventMap[E]];
+/** Subscribe to a widget event. Re-registering the same callback is a no-op. */
+export declare function on<E extends WidgetEventName>(event: E, callback: WidgetEventListener<E>): void;
+/** Unsubscribe a previously registered callback. Safe to call if absent. */
+export declare function off<E extends WidgetEventName>(event: E, callback: WidgetEventListener<E>): void;
+/** Subscribe to the next occurrence of an event, then auto-unsubscribe. */
+export declare function once<E extends WidgetEventName>(event: E, callback: WidgetEventListener<E>): void;
+/**
+ * Emit an event to all subscribers. Each listener is invoked in isolation: a
+ * throwing host callback is reported to Sentry and never breaks the widget or
+ * prevents the remaining listeners from running.
+ */
+export declare function emit<E extends WidgetEventName>(event: E, ...args: EmitArgs<E>): void;
+/** Remove every listener for every event. Used when the widget is destroyed. */
+export declare function clear(): void;
+/** The widget overlay was opened. */
+export declare function emitWidgetOpened(): void;
+/** The widget overlay was closed. */
+export declare function emitWidgetClosed(): void;
+/** A form stage became visible to the user. */
+export declare function emitStageViewed(payload: StageEventData): void;
+/** A form stage was successfully completed. */
+export declare function emitStageCompleted(payload: StageEventData): void;
+/** All stages were completed and rate generation started. */
+export declare function emitFlowCompleted(): void;
+/** The rates screen is being shown. */
+export declare function emitRatesViewed(payload: {
+    rateCount: number;
+}): void;
+/** The user navigated back from the rates screen. */
+export declare function emitRatesBack(): void;
+/** Quote submission failed (worker failure, timeout, or repeated network errors). */
+export declare function emitTelemetry(event: string, properties?: Record<string, unknown>): void;
+export declare function emitSubmissionFailed(payload: WidgetEventMap['submissionFailed']): void;
+export {};
+//# sourceMappingURL=events.d.ts.map

package/dist/utils/har/recorder.d.ts

@@ -0,0 +1,32 @@
+/**
+ * In-memory HAR recorder.
+ *
+ * Wraps the global `fetch` exactly once and records a bounded, FIFO ring buffer
+ * of HAR 1.2 entries for requests to our own API (`baseUrl`) only — never the
+ * host page's traffic (the widget is embedded on third-party sites).
+ *
+ * Recording is best-effort and fire-and-forget: it never blocks, delays, or
+ * throws into the application's fetch path. Bodies are read from a clone so the
+ * caller's response stays intact. Redaction happens later, at attach time
+ * (see ../sentry/reportQuoteFailure.ts -> redactHar), so the buffer holds raw
+ * data in memory only and never leaves the browser unredacted.
+ */
+import type { HarLog } from './types';
+interface RecorderOptions {
+    baseUrl: string;
+    maxEntries?: number;
+    maxBodyBytes?: number;
+}
+/**
+ * Install the recorder. Idempotent and safe to call when `fetch` is unavailable
+ * (e.g. SSR) — returns false in that case and records nothing.
+ */
+export declare function installHarRecorder(options: RecorderOptions): boolean;
+/** Snapshot the current buffer as a HAR 1.2 log. */
+export declare function getHarLog(): HarLog;
+/** Number of entries currently buffered. */
+export declare function harEntryCount(): number;
+/** Test-only: restore the original fetch and clear all recorder state. */
+export declare function __resetHarRecorder(): void;
+export {};
+//# sourceMappingURL=recorder.d.ts.map

package/dist/utils/har/types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Minimal HAR 1.2 type definitions for the fields the widget records.
+ * Only the subset we populate is modeled; the shape stays compatible with the
+ * full HAR spec so the output opens directly in Chrome DevTools.
+ * See: http://www.softwareishard.com/blog/har-12-spec/
+ */
+export interface HarHeader {
+    name: string;
+    value: string;
+}
+export interface HarQueryParam {
+    name: string;
+    value: string;
+}
+export interface HarPostData {
+    mimeType: string;
+    text: string;
+}
+export interface HarRequest {
+    method: string;
+    url: string;
+    httpVersion: string;
+    headers: HarHeader[];
+    queryString: HarQueryParam[];
+    cookies: never[];
+    headersSize: number;
+    bodySize: number;
+    postData?: HarPostData;
+}
+export interface HarContent {
+    size: number;
+    mimeType: string;
+    text?: string;
+}
+export interface HarResponse {
+    status: number;
+    statusText: string;
+    httpVersion: string;
+    headers: HarHeader[];
+    cookies: never[];
+    content: HarContent;
+    redirectURL: string;
+    headersSize: number;
+    bodySize: number;
+    /** Non-spec marker we add when the underlying fetch rejected (network error). */
+    _error?: string;
+}
+export interface HarEntry {
+    startedDateTime: string;
+    time: number;
+    request: HarRequest;
+    response: HarResponse;
+    cache: Record<string, never>;
+    timings: {
+        send: number;
+        wait: number;
+        receive: number;
+    };
+}
+export interface HarLog {
+    log: {
+        version: '1.2';
+        creator: {
+            name: string;
+            version: string;
+        };
+        entries: HarEntry[];
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/utils/product.d.ts

@@ -0,0 +1,30 @@
+import type { Product } from '@getcredify/credify-insurance-ui-kit/core';
+/** Parses one value; returns undefined for anything unrecognised. */
+export declare function parseProduct(raw: string | null | undefined): Product | undefined;
+/**
+ * Reads the product from the host page URL (`?credify_product=auto`) and strips
+ * it via history.replaceState, the same way the resume token and test flag are
+ * handled — a partner's address bar is theirs, and a link that has been used
+ * should not keep re-announcing itself in everything the visitor copies.
+ *
+ * Persisted to sessionStorage because the stripping means a reload no longer
+ * carries the param: without it a refresh three stages in would fall back to
+ * the default product while the stored quote is still the one the link asked
+ * for. Only `hasProductFromUrl()` is deliberately not restored — see below.
+ *
+ * Call once at init, before rendering, alongside captureResumeTokenFromUrl().
+ */
+export declare function captureProductFromUrl(): void;
+/** The product a URL asked for, if any. Host `init({ product })` is the fallback. */
+export declare function getUrlProduct(): Product | undefined;
+/**
+ * Whether this page view arrived carrying the param — the signal to open the
+ * widget straight into that flow rather than wait for the host's button.
+ *
+ * Not restored from sessionStorage on purpose: landing directly is what the
+ * link asked for on the visit that carried it. A visitor who closed the modal
+ * and then reloaded gets the page, not the modal reopening over it — while
+ * `getUrlProduct()` still remembers which flow to resume.
+ */
+export declare function hasProductFromUrl(): boolean;
+//# sourceMappingURL=product.d.ts.map

package/dist/utils/resumeLink.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The widget's view of the emailed resume link (`?credify_rt=<token>`).
+ *
+ * The token store lives in the kit, deliberately: the widget has to capture
+ * before first render (it auto-opens on a resume link, and the param must be
+ * off the URL before the host page copies or logs it), but the redemption and
+ * the quote it restores belong to the flow. Two stores meant the widget took
+ * the token off the URL and the flow then found neither token nor param, so
+ * every widget resume link silently started a fresh quote.
+ *
+ * These wrappers exist only to bind the widget's Sentry reporter to the kit's
+ * capture.
+ */
+import { consumeResumeToken, hasResumeToken } from '@getcredify/credify-insurance-ui-kit/api';
+/**
+ * Reads the resume token from the host page URL and immediately strips it via
+ * history.replaceState. Call once at widget init, before any rendering.
+ */
+export declare function captureResumeTokenFromUrl(): void;
+export { consumeResumeToken, hasResumeToken };
+/**
+ * Whether the shell must hold before deciding whether to ask for a product.
+ *
+ * The lookup that decides is asynchronous — a resume link has to be redeemed,
+ * a stored quote has to be read — so without seeding the hold from this, the
+ * first frame paints the chooser and swaps it out a moment later. That asks a
+ * customer who followed a resume link which product they want, and is the
+ * difference between "resuming" and "starting again" as far as they can tell.
+ *
+ * Both checks are synchronous, so the answer is available before the first
+ * paint. A host that answered at init is excluded deliberately: the effect that
+ * clears the hold returns early on `product`, so holding would never end.
+ */
+export declare const hasResumableSession: (product?: string) => boolean;
+//# sourceMappingURL=resumeLink.d.ts.map

package/dist/utils/sentry/devEnvironment.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Dev-mode detection that survives every build target the widget ships.
+ *
+ * `import.meta.env.DEV` is Vite-only: it does not exist in the UMD bundle a
+ * partner loads from a script tag, nor under Jest. Mirrors the ui-kit's
+ * `isDevEnvironment`, which the widget cannot import from `core` without
+ * pulling the quote engine into modules that only need a boolean.
+ */
+export declare const isDevEnvironment: () => boolean;
+//# sourceMappingURL=devEnvironment.d.ts.map

package/dist/utils/sentry/init.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Browser Sentry initialisation for the widget.
+ *
+ * Mirrors the backend init (packages/sentry/src/init.ts): same scrubbing hooks,
+ * `sendDefaultPii: false`, idempotent, and a no-op when no DSN is configured
+ * (local dev / tests stay silent).
+ *
+ * Adds three browser-specific pieces:
+ *   - the HAR recorder, started before anything can fail,
+ *   - Session Replay, lazy-loaded from the Sentry CDN and recording only on
+ *     error. Replay captures DOM/console/network-metadata; request/response
+ *     bodies live in the redacted HAR attachment instead (Replay's envelope
+ *     bypasses `beforeSend`, so we cannot scrub bodies it would capture), and
+ *   - noise filtering for scripts the widget does not own, since the widget
+ *     runs on partner pages and inside in-app browsers that inject their own.
+ */
+export interface WidgetSentryOptions {
+    dsn?: string;
+    environment?: string;
+    release?: string;
+    /** Explicitly disable even when a DSN is present. */
+    enabled?: boolean;
+    tracesSampleRate?: number;
+}
+/**
+ * Initialise Sentry for the widget. Returns true when Sentry was activated.
+ * Idempotent: subsequent calls are no-ops.
+ */
+export declare function initWidgetSentry(options?: WidgetSentryOptions): boolean;
+export declare function isWidgetSentryInitialized(): boolean;
+/** Test-only: reset the init guard between tests. */
+export declare function __resetWidgetSentry(): void;
+//# sourceMappingURL=init.d.ts.map

package/dist/utils/sentry/redact.d.ts

@@ -0,0 +1,50 @@
+/**
+ * PII scrubber for the browser widget.
+ *
+ * SOURCE OF TRUTH: this mirrors packages/sentry/src/scrubber.ts (the backend
+ * Lambda scrubber). The pattern lists below MUST be kept in sync with that file
+ * so frontend and backend redact the same fields. We copy rather than import
+ * because that package targets `@sentry/aws-serverless` (Node) and cannot be
+ * bundled into the browser widget. A future shared package could dedupe this.
+ *
+ * Used in two places:
+ *   - Sentry `beforeSend` / `beforeBreadcrumb` hooks (scrubEvent)
+ *   - HAR attachment redaction before upload (redactHar)
+ */
+import type { HarLog } from '../har/types';
+export declare function isSensitiveKey(key: string): boolean;
+export declare function scrubString(value: string): string;
+/**
+ * Recursively redact PII from any JSON-compatible value.
+ * - Sensitive keys -> replaced with [REDACTED]
+ * - Sensitive value patterns (SSN, VIN, JWT, bearer tokens) -> replaced inline
+ * - Cycles, depth limits, and non-plain objects are handled defensively
+ */
+export declare function scrub<T>(input: T, depth?: number, seen?: WeakSet<object>): T;
+export interface ScrubbableEvent {
+    request?: {
+        data?: unknown;
+        cookies?: unknown;
+        headers?: Record<string, unknown>;
+    };
+    extra?: Record<string, unknown>;
+    contexts?: Record<string, unknown>;
+    tags?: Record<string, unknown>;
+    breadcrumbs?: Array<{
+        data?: unknown;
+        message?: string;
+    }>;
+    message?: string;
+    user?: Record<string, unknown>;
+}
+/**
+ * Sentry beforeSend / beforeBreadcrumb hook.
+ * Mutates the event in place for keys we recognize, returns the event.
+ */
+export declare function scrubEvent<E extends ScrubbableEvent>(event: E): E;
+/**
+ * Redact a HAR log before it leaves the browser. Operates on a deep clone so
+ * the in-memory recorder buffer is never mutated.
+ */
+export declare function redactHar(har: HarLog): HarLog;
+//# sourceMappingURL=redact.d.ts.map

package/dist/utils/sentry/reportQuoteFailure.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Report a quote failure to Sentry with the redacted network trace attached.
+ *
+ * Called from the widget's failure sites (Widget.tsx). Captures the exception,
+ * tags it for filtering, and attaches a redacted HAR of the widget's API
+ * traffic so the failure can be analysed in Chrome DevTools — automating the
+ * manual "export a HAR and debug" workflow.
+ *
+ * No-ops cleanly when Sentry is not initialised, and is wrapped so it can never
+ * throw into the application path.
+ */
+export interface QuoteFailureContext {
+    /** Which product was being quoted ('Home' | 'Auto' | 'Bundle'). */
+    product?: string;
+    /** Current stage key (e.g. 'Driver', 'Vehicle'). */
+    stage?: string;
+    /** Quote id, when known. */
+    quoteId?: string;
+    /** Where in the flow the failure surfaced (e.g. 'rates_polling', 'consent_submit', 'api_request'). */
+    phase?: string;
+    /** API endpoint path for transport failures (e.g. '/get-rates'). */
+    endpoint?: string;
+    /** HTTP status code (0 for network errors). */
+    statusCode?: number;
+    /** Carrier-side classification of a rating failure (e.g. 'BOLT_VALIDATION'). */
+    failureCode?: string | null;
+    /** Fallback message when `error` is not an Error instance. */
+    message?: string;
+}
+export declare function reportQuoteFailure(error: unknown, ctx?: QuoteFailureContext): void;
+//# sourceMappingURL=reportQuoteFailure.d.ts.map

package/dist/utils/sentry/reportSideEffectFailure.d.ts

@@ -0,0 +1,2 @@
+export declare function reportSideEffectFailure(source: string, error: unknown): void;
+//# sourceMappingURL=reportSideEffectFailure.d.ts.map

package/dist/utils/storage.d.ts

@@ -0,0 +1,8 @@
+export declare function saveQuoteId(quoteId: string): void;
+export declare function loadQuoteId(): string | null;
+export declare function clearQuoteId(): void;
+export declare function saveAuthToken(token: string): void;
+export declare function loadAuthToken(): string | null;
+export declare function clearAuthToken(): void;
+export declare function clearAllQuoteData(): void;
+//# sourceMappingURL=storage.d.ts.map

package/dist/utils/support/bland.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Bland web-chat integration (live chat with "Sarah", the 24/7 intake agent).
+ *
+ * Bland exposes no imperative open API: the Messenger renders a launcher button
+ * inside a shadow root, and the only way to open it is to click that button. We
+ * poll for it and dispatch a synthetic click, matching how the marketing site
+ * drives the same widget.
+ *
+ * Host-first by design. A host page may already run Bland (getcredify.com does),
+ * in which case its `blandSettings` and its loaded SDK are the single source of
+ * truth: we drive the existing launcher and never write the global, inject a
+ * second loader, or tear the session down. The widget only owns Bland on pages
+ * that have none — third-party embeds, the standalone app, and the iframe build.
+ */
+export declare const BLAND_LOADER_SRC = "https://widget.bland.ai/loader.js";
+interface BlandSettings {
+    widget_id: string;
+    request_data?: Record<string, unknown>;
+}
+declare global {
+    interface Window {
+        blandSettings?: BlandSettings;
+    }
+}
+/**
+ * Whether the host page already provides Bland. Checked against all three
+ * observable traces because the widget can initialise at any point in the
+ * host's own load sequence: the settings global (set before the loader runs),
+ * the script tag, and the mounted launcher host.
+ */
+export declare function hostBlandPresent(): boolean;
+/**
+ * Ensure Bland is loading. No-op when the host already owns it — `blandSettings`
+ * is assigned only when absent, so a host's agent id and request data always win.
+ */
+export declare function loadBland(widgetId: string, requestData?: Record<string, unknown>): void;
+/**
+ * Open the Messenger, loading the SDK first when the widget owns it.
+ * Resolves false when the launcher never appears, so callers can fall back.
+ */
+export declare function openBland(widgetId: string, requestData?: Record<string, unknown>): Promise<boolean>;
+/**
+ * Tear down only a widget-owned Messenger. Bland ships no shutdown API, so we
+ * remove the mounted host; a host page's session is always left untouched.
+ */
+export declare function shutdownBland(): void;
+/** Test seam: reset ownership without touching a host-owned session. */
+export declare function __resetBland(): void;
+export {};
+//# sourceMappingURL=bland.d.ts.map

package/dist/utils/support/cobrowse.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Cobrowse.io integration (agent screen sharing).
+ *
+ * Privacy-first by default: every form input is redacted, so PII (DOB, license,
+ * VIN, SSN, address…) is never transmitted — agents see layout, labels, and
+ * validation errors only. The prospect explicitly starts the session and reads
+ * the generated 6-digit code to the agent, so sharing is always consented and
+ * agent-initiated control still prompts for confirmation.
+ *
+ * The 6-digit code flow works on the Cobrowse trial tier. Swap it for
+ * backend-issued JWT session auth when upgrading to premium — that change is
+ * isolated to this module.
+ */
+interface CobrowseGlobal {
+    license?: string;
+    redactedViews?: string[];
+    customData?: Record<string, unknown>;
+    confirmSession?: () => Promise<boolean>;
+    client?: () => Promise<unknown>;
+    start?: (options?: unknown) => void;
+    stop?: () => void;
+    createSessionCode?: () => Promise<string>;
+}
+declare global {
+    interface Window {
+        CobrowseIO?: CobrowseGlobal;
+    }
+}
+/**
+ * Start a cobrowse session and return a 6-digit code for the prospect to share
+ * with the agent. Returns null if the SDK is unavailable or codes are disabled.
+ */
+export declare function startCobrowse(license: string): Promise<string | null>;
+/** End any active session and reset (used on widget destroy). */
+export declare function stopCobrowse(): void;
+export {};
+//# sourceMappingURL=cobrowse.d.ts.map