@clue-ai/browser-sdk 0.0.1

package/dist/context/trace.d.ts

@@ -0,0 +1,32 @@
+export type TraceContextSnapshot = {
+    traceId: string;
+    activeSpanId: string | null;
+};
+export type RequestTraceContext = {
+    traceId: string;
+    parentSpanId: string | null;
+    requestId: string;
+    requestSpanId: string;
+    interactionId: string | null;
+};
+export declare class TraceManager {
+    private traceId;
+    private activeSpanId;
+    private activeInteractionId;
+    private activeInteractionExpiresAtMs;
+    constructor();
+    reset(): void;
+    getSnapshot(): TraceContextSnapshot;
+    startRootSpan(): {
+        traceId: string;
+        spanId: string;
+    };
+    setActiveSpan(spanId: string | null): void;
+    startInteraction(input: {
+        interactionId?: string | null;
+        nowMs?: number;
+        propagationWindowMs: number;
+    }): string;
+    getActiveInteractionId(nowMs?: number): string | null;
+    createRequestContext(requestId?: string): RequestTraceContext;
+}

package/dist/context/trace.js

@@ -0,0 +1,65 @@
+import { generateEventId, generateInteractionId, generateRequestId, generateRequestSpanId, } from "../normalize/event-id";
+const generateTraceId = () => {
+    return `trace_${generateEventId()}`;
+};
+const generateSpanId = () => {
+    return `span_${generateEventId()}`;
+};
+export class TraceManager {
+    constructor() {
+        this.traceId = generateTraceId();
+        this.activeSpanId = null;
+        this.activeInteractionId = null;
+        this.activeInteractionExpiresAtMs = null;
+    }
+    reset() {
+        this.traceId = generateTraceId();
+        this.activeSpanId = null;
+        this.activeInteractionId = null;
+        this.activeInteractionExpiresAtMs = null;
+    }
+    getSnapshot() {
+        return {
+            traceId: this.traceId,
+            activeSpanId: this.activeSpanId,
+        };
+    }
+    startRootSpan() {
+        const spanId = generateSpanId();
+        this.activeSpanId = spanId;
+        return {
+            traceId: this.traceId,
+            spanId,
+        };
+    }
+    setActiveSpan(spanId) {
+        this.activeSpanId = spanId;
+    }
+    startInteraction(input) {
+        const nowMs = input.nowMs ?? Date.now();
+        const interactionId = input.interactionId ?? generateInteractionId();
+        this.activeInteractionId = interactionId;
+        this.activeInteractionExpiresAtMs = nowMs + input.propagationWindowMs;
+        return interactionId;
+    }
+    getActiveInteractionId(nowMs = Date.now()) {
+        if (!this.activeInteractionId || this.activeInteractionExpiresAtMs === null) {
+            return null;
+        }
+        if (nowMs > this.activeInteractionExpiresAtMs) {
+            this.activeInteractionId = null;
+            this.activeInteractionExpiresAtMs = null;
+            return null;
+        }
+        return this.activeInteractionId;
+    }
+    createRequestContext(requestId) {
+        return {
+            traceId: this.traceId,
+            parentSpanId: this.activeSpanId,
+            requestId: requestId ?? generateRequestId(),
+            requestSpanId: generateRequestSpanId(),
+            interactionId: this.getActiveInteractionId(),
+        };
+    }
+}

package/dist/core/config.d.ts

@@ -0,0 +1,4 @@
+import type { ClueInitOptions, ResolvedClueConfig } from "./types";
+export declare const resolveConfig: (options: ClueInitOptions) => ResolvedClueConfig;
+export declare const validateConfig: (config: ResolvedClueConfig) => string[];
+export declare const isConfigValid: (config: ResolvedClueConfig) => boolean;

package/dist/core/config.js

@@ -0,0 +1,199 @@
+import { ALWAYS_DENIED_KEYS, DEFAULT_CONFIG, MAX_DIAGNOSTIC_TTL_MS, } from "./constants";
+import { SDK_COLLECTION_MODE } from "./contracts";
+const normalizeKeyList = (keys) => {
+    if (!keys || keys.length === 0) {
+        return [];
+    }
+    return [
+        ...new Set(keys.map((key) => key.trim().toLowerCase()).filter(Boolean)),
+    ];
+};
+const normalizePathList = (paths) => {
+    if (!paths || paths.length === 0) {
+        return [];
+    }
+    return [...new Set(paths.map((path) => path.trim()).filter(Boolean))];
+};
+const clampRate = (value, fallback) => {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        return fallback;
+    }
+    if (value < 0) {
+        return 0;
+    }
+    if (value > 1) {
+        return 1;
+    }
+    return value;
+};
+const positiveIntOrFallback = (value, fallback) => {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return fallback;
+    }
+    return Math.floor(value);
+};
+const normalizeCollectionMode = (value) => {
+    if (value === SDK_COLLECTION_MODE.diagnostic) {
+        return SDK_COLLECTION_MODE.diagnostic;
+    }
+    return SDK_COLLECTION_MODE.standard;
+};
+const normalizeDiagnosticScope = (value) => {
+    if (!value) {
+        return {};
+    }
+    const entries = Object.entries(value)
+        .map(([key, scopeValue]) => [key.trim(), scopeValue])
+        .filter(([key]) => key.length > 0)
+        .filter(([, scopeValue]) => {
+        return (scopeValue === null ||
+            typeof scopeValue === "string" ||
+            typeof scopeValue === "number" ||
+            typeof scopeValue === "boolean");
+    })
+        .slice(0, 20);
+    return Object.fromEntries(entries);
+};
+const normalizeDiagnosticConfig = (value) => {
+    const ttlMs = Math.min(positiveIntOrFallback(value?.ttlMs, DEFAULT_CONFIG.collection.diagnostic.ttlMs), MAX_DIAGNOSTIC_TTL_MS);
+    const budgetWindowMs = positiveIntOrFallback(value?.budgetWindowMs, DEFAULT_CONFIG.collection.diagnostic.budgetWindowMs);
+    const maxEventsPerWindow = positiveIntOrFallback(value?.maxEventsPerWindow, DEFAULT_CONFIG.collection.diagnostic.maxEventsPerWindow);
+    return {
+        enabledCollectors: normalizeKeyList(value?.enabledCollectors),
+        scope: normalizeDiagnosticScope(value?.scope),
+        ttlMs,
+        expiresAt: value?.expiresAt?.trim() || null,
+        budgetWindowMs,
+        maxEventsPerWindow,
+        sampleRate: clampRate(value?.sampleRate, DEFAULT_CONFIG.collection.diagnostic.sampleRate),
+        reason: value?.reason?.trim() || null,
+        enabledBy: value?.enabledBy?.trim() || null,
+    };
+};
+const normalizeConfiguredEndpoint = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return "";
+    }
+    try {
+        const parsed = new URL(trimmed);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            return "";
+        }
+        return parsed.toString();
+    }
+    catch {
+        return "";
+    }
+};
+export const resolveConfig = (options) => {
+    const originalEndpoint = normalizeConfiguredEndpoint(options.endpoint);
+    const localSetupCheckEndpoint = normalizeConfiguredEndpoint(options.localSetupCheck?.endpoint ?? "");
+    const serviceKey = options.serviceKey?.trim() ||
+        options.producerId?.trim() ||
+        DEFAULT_CONFIG.serviceKey;
+    const customDenied = normalizeKeyList(options.privacy?.deniedKeys);
+    const allowedValuePaths = normalizePathList(options.privacy?.allowedValuePaths);
+    const deniedKeys = [...new Set([...ALWAYS_DENIED_KEYS, ...customDenied])];
+    const tracePropagationOrigins = [
+        ...new Set((options.network?.tracePropagationOrigins ?? [])
+            .map((origin) => origin.trim())
+            .filter(Boolean)),
+    ];
+    const important4xxPathPrefixes = [
+        ...new Set((options.network?.important4xxPathPrefixes ?? [])
+            .map((prefix) => prefix.trim())
+            .filter(Boolean)
+            .map((prefix) => (prefix.startsWith("/") ? prefix : `/${prefix}`))),
+    ];
+    return {
+        endpoint: localSetupCheckEndpoint || originalEndpoint,
+        originalEndpoint,
+        localSetupCheckEndpoint: localSetupCheckEndpoint || null,
+        projectKey: options.projectKey?.trim() ?? "",
+        environment: options.environment?.trim() ?? "",
+        serviceKey,
+        producerId: options.producerId?.trim() || serviceKey,
+        browserTokenProvider: options.browserTokenProvider ?? null,
+        transportProfile: options.transportProfile ?? DEFAULT_CONFIG.transportProfile,
+        autocapture: options.autocapture ?? DEFAULT_CONFIG.autocapture,
+        captureNetwork: options.captureNetwork ?? DEFAULT_CONFIG.captureNetwork,
+        captureErrors: options.captureErrors ?? DEFAULT_CONFIG.captureErrors,
+        captureFrustration: options.captureFrustration ?? DEFAULT_CONFIG.captureFrustration,
+        capturePerformance: options.capturePerformance ?? DEFAULT_CONFIG.capturePerformance,
+        network: {
+            tracePropagationOrigins,
+            important4xxPathPrefixes,
+            interactionPropagationWindowMs: positiveIntOrFallback(options.network?.interactionPropagationWindowMs, DEFAULT_CONFIG.network.interactionPropagationWindowMs),
+        },
+        batch: {
+            enabled: options.batch?.enabled ?? DEFAULT_CONFIG.batch.enabled,
+            maxSize: typeof options.batch?.maxSize === "number" && options.batch.maxSize > 0
+                ? Math.floor(options.batch.maxSize)
+                : DEFAULT_CONFIG.batch.maxSize,
+            flushIntervalMs: typeof options.batch?.flushIntervalMs === "number" &&
+                options.batch.flushIntervalMs > 0
+                ? Math.floor(options.batch.flushIntervalMs)
+                : DEFAULT_CONFIG.batch.flushIntervalMs,
+            maxEventBytes: typeof options.batch?.maxEventBytes === "number" &&
+                options.batch.maxEventBytes > 0
+                ? Math.floor(options.batch.maxEventBytes)
+                : DEFAULT_CONFIG.batch.maxEventBytes,
+            maxPayloadBytes: typeof options.batch?.maxPayloadBytes === "number" &&
+                options.batch.maxPayloadBytes > 0
+                ? Math.floor(options.batch.maxPayloadBytes)
+                : DEFAULT_CONFIG.batch.maxPayloadBytes,
+        },
+        privacy: {
+            deniedKeys,
+            allowedValuePaths,
+        },
+        sampling: {
+            sessionSampleRate: clampRate(options.sampling?.sessionSampleRate, DEFAULT_CONFIG.sampling.sessionSampleRate),
+        },
+        collection: {
+            mode: normalizeCollectionMode(options.collection?.mode),
+            diagnostic: normalizeDiagnosticConfig(options.collection?.diagnostic),
+        },
+        release: {
+            frontendRelease: options.release?.frontendRelease?.trim() ||
+                DEFAULT_CONFIG.release.frontendRelease,
+        },
+        featureFlagsProvider: options.featureFlagsProvider,
+        experimentVariantProvider: options.experimentVariantProvider,
+    };
+};
+export const validateConfig = (config) => {
+    const issues = [];
+    if (!config.endpoint) {
+        issues.push("endpoint is required");
+    }
+    if (!config.projectKey) {
+        issues.push("projectKey is required");
+    }
+    if (!config.environment) {
+        issues.push("environment is required");
+    }
+    if (!config.producerId) {
+        issues.push("producerId is required");
+    }
+    if (!config.serviceKey) {
+        issues.push("serviceKey is required");
+    }
+    if (config.batch.flushIntervalMs < 100) {
+        issues.push("batch.flushIntervalMs must be >= 100ms");
+    }
+    if (config.batch.maxSize < 1) {
+        issues.push("batch.maxSize must be >= 1");
+    }
+    if (config.batch.maxEventBytes < 512) {
+        issues.push("batch.maxEventBytes must be >= 512 bytes");
+    }
+    if (config.batch.maxPayloadBytes < config.batch.maxEventBytes) {
+        issues.push("batch.maxPayloadBytes must be >= batch.maxEventBytes");
+    }
+    return issues;
+};
+export const isConfigValid = (config) => {
+    return validateConfig(config).length === 0;
+};

package/dist/core/constants.d.ts

@@ -0,0 +1,43 @@
+import type { ClueConsentState, ResolvedClueConfig } from "./types";
+export declare const SDK_NAME = "@clue-ai/browser-sdk";
+export declare const SDK_VERSION = "0.0.1";
+export declare const EVENT_SOURCE: "browser_sdk";
+export declare const EVENT_VERSION = 1;
+export declare const SOURCE_SCHEMA_VERSION = "1";
+export declare const SURFACE_TYPE: "web";
+export declare const MASKED_VALUE = "***masked***";
+export declare const FORBIDDEN_PARAMETER_VALUE = "__forbidden__";
+export declare const TRUNCATED_PARAMETER_VALUE = "__truncated__";
+export declare const DEFAULT_CONSENT: ClueConsentState;
+export declare const DEFAULT_SESSION_TIMEOUT_MS: number;
+export declare const DEFAULT_INTERACTION_PROPAGATION_WINDOW_MS = 5000;
+export declare const DEFAULT_MAX_EVENT_PAYLOAD_BYTES: number;
+export declare const DEFAULT_MAX_BATCH_PAYLOAD_BYTES: number;
+export declare const DEFAULT_MAX_BATCH_QUEUE_BYTES: number;
+export declare const DEFAULT_DIAGNOSTIC_TTL_MS = 600000;
+export declare const MAX_DIAGNOSTIC_TTL_MS = 1800000;
+export declare const DEFAULT_DIAGNOSTIC_BUDGET_WINDOW_MS = 60000;
+export declare const DEFAULT_DIAGNOSTIC_MAX_EVENTS_PER_WINDOW = 100;
+export declare const STORAGE_KEYS: {
+    readonly anonymousId: "clue:anon_id";
+    readonly userId: "clue:user_id";
+    readonly userTraits: "clue:user_traits";
+    readonly accountId: "clue:account_id";
+    readonly organizationId: "clue:organization_id";
+    readonly accountTraits: "clue:account_traits";
+    readonly workspaceId: "clue:workspace_id";
+    readonly tabId: "clue:tab_id";
+    readonly sessionId: "clue:session_id";
+    readonly sessionStartedAt: "clue:session_started_at";
+    readonly sessionLastActivityAt: "clue:session_last_activity_at";
+};
+export declare const ALWAYS_DENIED_KEYS: readonly ["authorization", "cookie", "set-cookie", "password", "passwd", "secret", "token", "session", "session_token", "refresh_token", "api_key", "apikey", "private_key"];
+export declare const MAX_SCHEMA_DEPTH = 6;
+export declare const MAX_SCHEMA_KEYS = 512;
+export declare const MAX_SANITIZE_DEPTH = 20;
+export declare const DEFAULT_CONFIG: ResolvedClueConfig;
+export declare const RETRY_CONFIG: {
+    readonly maxAttempts: 3;
+    readonly baseDelayMs: 300;
+    readonly maxDelayMs: 5000;
+};

package/dist/core/constants.js

@@ -0,0 +1,109 @@
+export const SDK_NAME = "@clue-ai/browser-sdk";
+export const SDK_VERSION = "0.0.1";
+export const EVENT_SOURCE = "browser_sdk";
+export const EVENT_VERSION = 1;
+export const SOURCE_SCHEMA_VERSION = "1";
+export const SURFACE_TYPE = "web";
+export const MASKED_VALUE = "***masked***";
+export const FORBIDDEN_PARAMETER_VALUE = "__forbidden__";
+export const TRUNCATED_PARAMETER_VALUE = "__truncated__";
+export const DEFAULT_CONSENT = "unknown";
+export const DEFAULT_SESSION_TIMEOUT_MS = 30 * 60 * 1000;
+export const DEFAULT_INTERACTION_PROPAGATION_WINDOW_MS = 5000;
+export const DEFAULT_MAX_EVENT_PAYLOAD_BYTES = 48 * 1024;
+export const DEFAULT_MAX_BATCH_PAYLOAD_BYTES = 60 * 1024;
+export const DEFAULT_MAX_BATCH_QUEUE_BYTES = 300 * 1024;
+export const DEFAULT_DIAGNOSTIC_TTL_MS = 600000;
+export const MAX_DIAGNOSTIC_TTL_MS = 1800000;
+export const DEFAULT_DIAGNOSTIC_BUDGET_WINDOW_MS = 60000;
+export const DEFAULT_DIAGNOSTIC_MAX_EVENTS_PER_WINDOW = 100;
+export const STORAGE_KEYS = {
+    anonymousId: "clue:anon_id",
+    userId: "clue:user_id",
+    userTraits: "clue:user_traits",
+    accountId: "clue:account_id",
+    organizationId: "clue:organization_id",
+    accountTraits: "clue:account_traits",
+    workspaceId: "clue:workspace_id",
+    tabId: "clue:tab_id",
+    sessionId: "clue:session_id",
+    sessionStartedAt: "clue:session_started_at",
+    sessionLastActivityAt: "clue:session_last_activity_at",
+};
+export const ALWAYS_DENIED_KEYS = [
+    "authorization",
+    "cookie",
+    "set-cookie",
+    "password",
+    "passwd",
+    "secret",
+    "token",
+    "session",
+    "session_token",
+    "refresh_token",
+    "api_key",
+    "apikey",
+    "private_key",
+];
+export const MAX_SCHEMA_DEPTH = 6;
+export const MAX_SCHEMA_KEYS = 512;
+export const MAX_SANITIZE_DEPTH = 20;
+export const DEFAULT_CONFIG = {
+    endpoint: "",
+    originalEndpoint: "",
+    localSetupCheckEndpoint: null,
+    projectKey: "",
+    environment: "",
+    serviceKey: "frontend",
+    producerId: "frontend",
+    browserTokenProvider: null,
+    transportProfile: "standard",
+    autocapture: true,
+    captureNetwork: true,
+    captureErrors: true,
+    captureFrustration: true,
+    capturePerformance: true,
+    network: {
+        tracePropagationOrigins: [],
+        important4xxPathPrefixes: [],
+        interactionPropagationWindowMs: DEFAULT_INTERACTION_PROPAGATION_WINDOW_MS,
+    },
+    batch: {
+        enabled: true,
+        maxSize: 50,
+        flushIntervalMs: 180000,
+        maxEventBytes: DEFAULT_MAX_EVENT_PAYLOAD_BYTES,
+        maxPayloadBytes: DEFAULT_MAX_BATCH_PAYLOAD_BYTES,
+    },
+    privacy: {
+        deniedKeys: [...ALWAYS_DENIED_KEYS],
+        allowedValuePaths: [],
+    },
+    sampling: {
+        sessionSampleRate: 1,
+    },
+    collection: {
+        mode: "standard",
+        diagnostic: {
+            enabledCollectors: [],
+            scope: {},
+            ttlMs: DEFAULT_DIAGNOSTIC_TTL_MS,
+            expiresAt: null,
+            budgetWindowMs: DEFAULT_DIAGNOSTIC_BUDGET_WINDOW_MS,
+            maxEventsPerWindow: DEFAULT_DIAGNOSTIC_MAX_EVENTS_PER_WINDOW,
+            sampleRate: 1,
+            reason: null,
+            enabledBy: null,
+        },
+    },
+    release: {
+        frontendRelease: null,
+    },
+    featureFlagsProvider: undefined,
+    experimentVariantProvider: undefined,
+};
+export const RETRY_CONFIG = {
+    maxAttempts: 3,
+    baseDelayMs: 300,
+    maxDelayMs: 5000,
+};

package/dist/core/contracts.d.ts

@@ -0,0 +1,58 @@
+export declare const FRONTEND_EVENT_CATEGORY: {
+    readonly session: "session";
+    readonly navigation: "navigation";
+    readonly action: "action";
+    readonly interaction: "interaction";
+    readonly request: "request";
+    readonly error: "error";
+    readonly performance: "performance";
+    readonly support: "support";
+    readonly custom: "custom";
+};
+export type FrontendEventCategory = (typeof FRONTEND_EVENT_CATEGORY)[keyof typeof FRONTEND_EVENT_CATEGORY];
+export declare const FRONTEND_EVENT_STATUS: {
+    readonly observed: "observed";
+    readonly finished: "finished";
+    readonly failed: "failed";
+};
+export type FrontendEventStatus = (typeof FRONTEND_EVENT_STATUS)[keyof typeof FRONTEND_EVENT_STATUS];
+export declare const SDK_COLLECTION_MODE: {
+    readonly standard: "standard";
+    readonly diagnostic: "diagnostic";
+};
+export type SdkCollectionMode = (typeof SDK_COLLECTION_MODE)[keyof typeof SDK_COLLECTION_MODE];
+export declare const FRONTEND_EVENT_NAME: {
+    readonly sessionStarted: "session_started";
+    readonly sessionEnded: "session_ended";
+    readonly pageView: "page_view";
+    readonly pageLeave: "page_leave";
+    readonly routeChange: "route_change";
+    readonly elementClicked: "element_clicked";
+    readonly formSubmitted: "form_submitted";
+    readonly inputCommitted: "input_committed";
+    readonly toggleChanged: "toggle_changed";
+    readonly selectionCommitted: "selection_committed";
+    readonly fileSelected: "file_selected";
+    readonly dragDropCompleted: "drag_drop_completed";
+    readonly requestFinished: "request_finished";
+    readonly requestFailed: "request_failed";
+    readonly frontendError: "frontend_error";
+    readonly unhandledRejection: "unhandled_rejection";
+    readonly performanceSummaryObserved: "performance_summary_observed";
+    readonly browserReportSummaryObserved: "browser_report_summary_observed";
+    readonly uiLifecycleSummaryObserved: "ui_lifecycle_summary_observed";
+    readonly streamLifecycleSummaryObserved: "stream_lifecycle_summary_observed";
+    readonly sdkDiagnosticObserved: "sdk_diagnostic_observed";
+    readonly deadClickDetected: "dead_click_detected";
+    readonly errorClickDetected: "error_click_detected";
+    readonly rageClickDetected: "rage_click_detected";
+    readonly customEmitted: "custom_emitted";
+};
+export type FrontendEventName = (typeof FRONTEND_EVENT_NAME)[keyof typeof FRONTEND_EVENT_NAME];
+export declare const PARAMETER_CAPTURE_MODE: {
+    readonly allowedPlaintext: "allowed_plaintext";
+    readonly maskedFingerprint: "masked_fingerprint";
+    readonly forbidden: "forbidden";
+    readonly truncated: "truncated";
+};
+export type ParameterCaptureMode = (typeof PARAMETER_CAPTURE_MODE)[keyof typeof PARAMETER_CAPTURE_MODE];

package/dist/core/contracts.js

@@ -0,0 +1,53 @@
+export const FRONTEND_EVENT_CATEGORY = {
+    session: "session",
+    navigation: "navigation",
+    action: "action",
+    interaction: "interaction",
+    request: "request",
+    error: "error",
+    performance: "performance",
+    support: "support",
+    custom: "custom",
+};
+export const FRONTEND_EVENT_STATUS = {
+    observed: "observed",
+    finished: "finished",
+    failed: "failed",
+};
+export const SDK_COLLECTION_MODE = {
+    standard: "standard",
+    diagnostic: "diagnostic",
+};
+export const FRONTEND_EVENT_NAME = {
+    sessionStarted: "session_started",
+    sessionEnded: "session_ended",
+    pageView: "page_view",
+    pageLeave: "page_leave",
+    routeChange: "route_change",
+    elementClicked: "element_clicked",
+    formSubmitted: "form_submitted",
+    inputCommitted: "input_committed",
+    toggleChanged: "toggle_changed",
+    selectionCommitted: "selection_committed",
+    fileSelected: "file_selected",
+    dragDropCompleted: "drag_drop_completed",
+    requestFinished: "request_finished",
+    requestFailed: "request_failed",
+    frontendError: "frontend_error",
+    unhandledRejection: "unhandled_rejection",
+    performanceSummaryObserved: "performance_summary_observed",
+    browserReportSummaryObserved: "browser_report_summary_observed",
+    uiLifecycleSummaryObserved: "ui_lifecycle_summary_observed",
+    streamLifecycleSummaryObserved: "stream_lifecycle_summary_observed",
+    sdkDiagnosticObserved: "sdk_diagnostic_observed",
+    deadClickDetected: "dead_click_detected",
+    errorClickDetected: "error_click_detected",
+    rageClickDetected: "rage_click_detected",
+    customEmitted: "custom_emitted",
+};
+export const PARAMETER_CAPTURE_MODE = {
+    allowedPlaintext: "allowed_plaintext",
+    maskedFingerprint: "masked_fingerprint",
+    forbidden: "forbidden",
+    truncated: "truncated",
+};

package/dist/core/sdk.d.ts

@@ -0,0 +1,2 @@
+import type { ClueBrowserSdk } from "./types";
+export declare const createClueBrowserSdk: () => ClueBrowserSdk;