@genn-inc/cluebase-frontend-sdk 0.0.1

package/dist/exporter/parameter-snapshot.js

@@ -0,0 +1,215 @@
+import { hasParameterSnapshotLeafShape } from "../_generated/parameter-snapshot-leaf.js";
+import { FORBIDDEN_PARAMETER_VALUE, MASKED_VALUE, MAX_SANITIZE_DEPTH, TRUNCATED_PARAMETER_VALUE, } from "../provider/constants.js";
+import { PARAMETER_CAPTURE_MODE } from "../provider/contracts.js";
+import { isDeniedKey } from "./sanitize.js";
+const SNAPSHOT_UNAVAILABLE_KEY = "_cluebase_snapshot_unavailable";
+const normalizeParameterLookupPath = (path) => {
+    return path.replace(/\[\d+\]/g, "[]");
+};
+const isParameterInputObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const inferLeafType = (value) => {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    if (typeof value === "object") {
+        return "object";
+    }
+    switch (typeof value) {
+        case "string":
+            return "string";
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        default:
+            return "string";
+    }
+};
+const measureSerializedBytes = (value) => {
+    try {
+        return new TextEncoder().encode(JSON.stringify(value)).length;
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * 値をそのまま載せてよいのは、**顧客が画面で名指しした項目だけ**。
+ *
+ * 載せるのは文字・数・真偽に限ります。入れ子は葉に来ないので、それ以外の形が
+ * ここへ来たら伏せた側へ倒します。
+ */
+const releasedLeafValue = (value) => value === null ||
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean"
+    ? value
+    : MASKED_VALUE;
+const buildLeaf = (value, captureMode, 
+// 顧客がこの項目を名指ししたか。**既定は false = 伏せる。**
+released = false) => {
+    const leafType = inferLeafType(value);
+    const originalSizeBytes = captureMode === PARAMETER_CAPTURE_MODE.forbidden
+        ? undefined
+        : measureSerializedBytes(value);
+    return {
+        type: leafType,
+        value: captureMode === PARAMETER_CAPTURE_MODE.forbidden
+            ? FORBIDDEN_PARAMETER_VALUE
+            : released
+                ? releasedLeafValue(value)
+                : MASKED_VALUE,
+        capture_mode: captureMode,
+        ...(typeof originalSizeBytes === "number"
+            ? { original_size_bytes: originalSizeBytes }
+            : {}),
+    };
+};
+export const buildUnavailableParameterSnapshot = () => ({
+    [SNAPSHOT_UNAVAILABLE_KEY]: buildLeaf("snapshot_unavailable", PARAMETER_CAPTURE_MODE.maskedFingerprint),
+});
+/**
+ * その節は葉か、降りる枝か。
+ *
+ * **見分ける手順をここに書きません。** ここには鍵の有無だけを見る版が書かれており、
+ * 受付側は型まで見ていました。`{ type: 123, capture_mode: null, value: 1 }` が
+ * **送る側にとって葉、受け取る側にとって枝**という状態で、受け取った側は中へ降りて
+ * `type` / `value` / `capture_mode` を項目名として扱っていました。降りる側の 1 つは
+ * 伏せる判定です。
+ *
+ * 手順は正本（`packages/cluebase-schema/.../observation-classification.schema.ts`）から
+ * 生成され、受付側も同じものを受け取ります。共有の部品は顧客の手元で解決できない
+ * ので取り込めず、**生成して同梱する**のがこの repo の作法です
+ * （`_generated/ingest-privacy-tables.ts` と同じ）。
+ */
+const isParameterSnapshotLeaf = (value) => hasParameterSnapshotLeafShape(value);
+export const truncateParameterSnapshotValue = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((entry) => truncateParameterSnapshotValue(entry));
+    }
+    if (isParameterSnapshotLeaf(value)) {
+        const originalSizeBytes = typeof value.original_size_bytes === "number"
+            ? value.original_size_bytes
+            : undefined;
+        return {
+            type: value.type,
+            value: TRUNCATED_PARAMETER_VALUE,
+            capture_mode: PARAMETER_CAPTURE_MODE.truncated,
+            truncated_reason: "max_event_bytes",
+            ...(typeof originalSizeBytes === "number"
+                ? { original_size_bytes: originalSizeBytes }
+                : {}),
+        };
+    }
+    const truncated = {};
+    for (const [key, child] of Object.entries(value)) {
+        truncated[key] = truncateParameterSnapshotValue(child);
+    }
+    return truncated;
+};
+const buildAllowedPathLookup = (allowedPaths) => {
+    const lookup = new Map();
+    for (const entry of allowedPaths) {
+        const trimmed = entry.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const normalized = normalizeParameterLookupPath(trimmed);
+        if (!lookup.has(normalized)) {
+            lookup.set(normalized, trimmed);
+        }
+    }
+    return lookup;
+};
+export const buildParameterSnapshotBundle = (value, options) => {
+    const allowedPathLookup = buildAllowedPathLookup(options.allowedPaths);
+    const seen = new WeakSet();
+    const rootPathPrefix = options.pathPrefix?.trim() ?? "";
+    const walk = (current, path, depth) => {
+        if (depth > MAX_SANITIZE_DEPTH) {
+            return {
+                snapshot: buildLeaf(null, PARAMETER_CAPTURE_MODE.maskedFingerprint),
+                allowedValueKeys: [],
+            };
+        }
+        if (current === undefined ||
+            typeof current === "function" ||
+            typeof current === "symbol") {
+            return {
+                snapshot: undefined,
+                allowedValueKeys: [],
+            };
+        }
+        if (Array.isArray(current)) {
+            if (current.length === 0) {
+                return {
+                    snapshot: [],
+                    allowedValueKeys: [],
+                };
+            }
+            const representative = walk(current[0], `${path}[]`, depth + 1);
+            if (representative.snapshot === undefined) {
+                return {
+                    snapshot: [],
+                    allowedValueKeys: representative.allowedValueKeys,
+                };
+            }
+            return {
+                snapshot: [representative.snapshot],
+                allowedValueKeys: representative.allowedValueKeys,
+            };
+        }
+        if (isParameterInputObject(current)) {
+            const objectValue = current;
+            if (seen.has(objectValue)) {
+                return {
+                    snapshot: buildLeaf(null, PARAMETER_CAPTURE_MODE.maskedFingerprint),
+                    allowedValueKeys: [],
+                };
+            }
+            seen.add(objectValue);
+            const snapshot = {};
+            const allowedValueKeys = [];
+            for (const [key, child] of Object.entries(objectValue)) {
+                const childPath = path ? `${path}.${key}` : key;
+                if (isDeniedKey(key, options.deniedKeys)) {
+                    snapshot[key] = buildLeaf(child, PARAMETER_CAPTURE_MODE.forbidden);
+                    continue;
+                }
+                const childBundle = walk(child, childPath, depth + 1);
+                if (childBundle.snapshot === undefined) {
+                    continue;
+                }
+                snapshot[key] = childBundle.snapshot;
+                allowedValueKeys.push(...childBundle.allowedValueKeys);
+            }
+            seen.delete(objectValue);
+            return {
+                snapshot,
+                allowedValueKeys,
+            };
+        }
+        const matchedAllowedPath = path
+            ? (allowedPathLookup.get(normalizeParameterLookupPath(path)) ?? null)
+            : null;
+        const captureMode = PARAMETER_CAPTURE_MODE.maskedFingerprint;
+        return {
+            // 名指しされた項目だけ値を持つ。名指ししていない項目は伏せたまま。
+            snapshot: buildLeaf(current, captureMode, matchedAllowedPath !== null),
+            allowedValueKeys: matchedAllowedPath ? [matchedAllowedPath] : [],
+        };
+    };
+    const rootBundle = walk(value, rootPathPrefix, 0);
+    const snapshot = rootBundle.snapshot &&
+        typeof rootBundle.snapshot === "object" &&
+        !Array.isArray(rootBundle.snapshot)
+        ? rootBundle.snapshot
+        : {};
+    return {
+        snapshot,
+        allowedValueKeys: [...new Set(rootBundle.allowedValueKeys)].sort(),
+    };
+};

package/dist/exporter/path-template.d.ts

@@ -0,0 +1 @@
+export declare const toPathTemplate: (pathname: string) => string;

package/dist/exporter/path-template.js

@@ -0,0 +1,67 @@
+const UUID_SEGMENT = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const HEX_SEGMENT = /^[0-9a-f]{16,}$/i;
+const NUMBER_SEGMENT = /^\d+$/;
+const TOKEN_SEGMENT = /^[A-Za-z0-9_-]{24,}$/;
+const BROKEN_PLACEHOLDER_SEGMENTS = new Set(["undefined", "null", "nan"]);
+const RESOURCE_PARENT_SEGMENTS = new Set([
+    "accounts",
+    "companies",
+    "customers",
+    "epics",
+    "members",
+    "organizations",
+    "projects",
+    "sessions",
+    "spaces",
+    "tasks",
+    "teams",
+    "users",
+    "w",
+    "workspaces",
+]);
+const STATIC_RESOURCE_CHILD_SEGMENTS = new Set([
+    "batch",
+    "bulk",
+    "count",
+    "create",
+    "current",
+    "list",
+    "me",
+    "new",
+    "search",
+    "settings",
+]);
+const shouldTemplateSegment = (segment, previousSegment) => {
+    const normalized = segment.toLowerCase();
+    if (BROKEN_PLACEHOLDER_SEGMENTS.has(normalized))
+        return true;
+    if (NUMBER_SEGMENT.test(segment))
+        return true;
+    if (UUID_SEGMENT.test(segment))
+        return true;
+    if (HEX_SEGMENT.test(segment))
+        return true;
+    if (TOKEN_SEGMENT.test(segment))
+        return true;
+    if (previousSegment &&
+        RESOURCE_PARENT_SEGMENTS.has(previousSegment.toLowerCase()) &&
+        !STATIC_RESOURCE_CHILD_SEGMENTS.has(normalized)) {
+        return true;
+    }
+    return false;
+};
+export const toPathTemplate = (pathname) => {
+    if (!pathname || pathname === "/") {
+        return "/";
+    }
+    const normalizedPath = pathname.startsWith("/") ? pathname : `/${pathname}`;
+    const [pathOnly] = normalizedPath.split("?");
+    const rawSegments = pathOnly.split("/").filter((segment) => segment.length > 0);
+    const segments = rawSegments.map((segment, index) => shouldTemplateSegment(segment, rawSegments[index - 1] ?? null)
+        ? ":id"
+        : segment);
+    if (segments.length === 0) {
+        return "/";
+    }
+    return `/${segments.join("/")}`;
+};

package/dist/exporter/raw-event-to-source-signal.d.ts

@@ -0,0 +1,12 @@
+import type { CluebaseContext, RawCapturedEvent } from "../provider/types.js";
+import { type FrontendResourceInput } from "./frontend-resource.js";
+import { type BrowserSourceSignalEvent } from "./source-event.js";
+export declare const RAW_FRONTEND_SOURCE_SIGNAL_KIND = "frontend_raw_event";
+type Options = {
+    context: CluebaseContext;
+    resource?: FrontendResourceInput;
+    deniedKeys?: readonly string[];
+    onMaskingError?: () => void;
+};
+export declare function rawEventToSourceSignalEvent(raw: RawCapturedEvent, options: Options): BrowserSourceSignalEvent;
+export {};

package/dist/exporter/raw-event-to-source-signal.js

@@ -0,0 +1,297 @@
+// 相関のために残す属性名は、正本から生成した部品を読みます。ここには手で書かれて
+// おり、もう 1 か所の写しと 15 語食い違い、`cluebase.session_id` `mcp.session.id` が
+// 欠けていて**落ちていました**（`session` を含むため落とす側に当たる）。
+import { CLUEBASE_CORRELATION_ATTRIBUTE_KEYS } from "../_generated/correlation-attribute-keys.js";
+import { cluebaseAuthoredPropertyAttribute } from "../instrumentation/cluebase-authored-attributes.js";
+import { EVENT_SOURCE, EVENT_VERSION, SOURCE_SCHEMA_VERSION, } from "../provider/constants.js";
+import { generateEventId, generateInteractionId, generateRequestId, generateRequestSpanId, generateTraceId, } from "./event-id.js";
+import { isDeniedKey } from "./sanitize.js";
+import { toFrontendSourceResource, } from "./frontend-resource.js";
+import { SDK_SOURCE_SIGNAL_EVENT_NAME, SDK_SOURCE_SIGNAL_EVENT_TYPE, } from "./source-event.js";
+export const RAW_FRONTEND_SOURCE_SIGNAL_KIND = "frontend_raw_event";
+const PUBLIC_CUSTOM_EVENT_NAME_PATTERN = /^[A-Za-z0-9_.:-]{1,128}$/;
+const isDynamicPayloadObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function toJsonValue(value, deniedKeys = [], onMaskingError) {
+    if (value === null)
+        return null;
+    if (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return typeof value === "number" && !Number.isFinite(value) ? null : value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => toJsonValue(entry, deniedKeys, onMaskingError));
+    }
+    if (isDynamicPayloadObject(value)) {
+        const record = {};
+        let entries;
+        try {
+            entries = Object.entries(value);
+        }
+        catch {
+            onMaskingError?.();
+            return record;
+        }
+        for (const [key, entry] of entries) {
+            if (!CLUEBASE_CORRELATION_ATTRIBUTE_KEYS.has(key) &&
+                isDeniedKey(key, deniedKeys)) {
+                continue;
+            }
+            record[key] = toJsonValue(entry, deniedKeys, onMaskingError);
+        }
+        return record;
+    }
+    if (typeof value === "bigint")
+        return value.toString();
+    return null;
+}
+function toJsonRecord(value, deniedKeys = [], onMaskingError) {
+    const record = {};
+    let entries;
+    try {
+        entries = Object.entries(value);
+    }
+    catch {
+        onMaskingError?.();
+        return record;
+    }
+    for (const [key, entry] of entries) {
+        if (!CLUEBASE_CORRELATION_ATTRIBUTE_KEYS.has(key) &&
+            isDeniedKey(key, deniedKeys)) {
+            continue;
+        }
+        record[key] = toJsonValue(entry, deniedKeys, onMaskingError);
+    }
+    return record;
+}
+function isJsonRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function dropNonFiniteMetrics(payload) {
+    const metrics = payload.metrics;
+    if (!isJsonRecord(metrics)) {
+        return;
+    }
+    const sanitized = {};
+    for (const [key, value] of Object.entries(metrics)) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            sanitized[key] = value;
+        }
+    }
+    payload.metrics = sanitized;
+}
+function stringPayload(payload, key) {
+    const value = payload[key];
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : null;
+}
+function trustedCustomOrigin(payload) {
+    const origin = stringPayload(payload, "customEventOrigin");
+    return origin === "explicit_track" || origin === "official_sdk_lifecycle"
+        ? origin
+        : null;
+}
+const isRequestRawEvent = (eventName) => eventName === "request_started" ||
+    eventName === "request_finished" ||
+    eventName === "request_failed";
+const numberPayload = (payload, key) => {
+    const value = payload[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+};
+function contextRecord(context, overrides = {}) {
+    return {
+        producer_id: context.producer_id,
+        anonymous_id: context.anonymous_id,
+        user_id: context.user_id,
+        organization_id: context.organization_id ?? null,
+        user_profile: context.user_profile,
+        session_id: overrides.session_id ?? context.session_id,
+        tab_id: context.tab_id,
+        trace_id: overrides.trace_id ?? context.trace_id,
+        request_id: overrides.request_id ?? context.request_id,
+        request_span_id: overrides.request_span_id ?? context.request_span_id,
+        interaction_id: overrides.interaction_id ?? context.interaction_id,
+        correlation_id: context.correlation_id,
+        sdk_collection_mode: context.sdk_collection_mode,
+        frontend_release: context.frontend_release,
+        locale: context.locale,
+        country: context.country,
+        device_type: context.device_type,
+        browser: context.browser,
+        os: context.os,
+        referrer: context.referrer,
+        browser_family: context.browser_family ?? null,
+        browser_major_version: context.browser_major_version ?? null,
+        browser_engine: context.browser_engine ?? null,
+        os_family: context.os_family ?? null,
+        os_major_version: context.os_major_version ?? null,
+        timezone: context.timezone ?? null,
+        pointer_type_candidate: context.pointer_type_candidate ?? null,
+        touch_capable: context.touch_capable ?? null,
+        cookies_enabled: context.cookies_enabled ?? null,
+        local_storage_available: context.local_storage_available ?? null,
+        session_storage_available: context.session_storage_available ?? null,
+        service_worker_supported: context.service_worker_supported ?? null,
+        webgl_supported: context.webgl_supported ?? null,
+        reduced_motion: context.reduced_motion ?? null,
+        color_scheme: context.color_scheme ?? null,
+        subject_traits: context.subject_traits,
+        organization_traits: context.organization_traits,
+        context_traits: context.context_traits,
+    };
+}
+export function rawEventToSourceSignalEvent(raw, options) {
+    const context = options.context;
+    const eventId = generateEventId();
+    const occurredAtMs = raw.occurredAtMs ?? Date.now();
+    const occurredAt = new Date(occurredAtMs).toISOString();
+    const payload = toJsonRecord(raw.payload, options.deniedKeys, options.onMaskingError);
+    dropNonFiniteMetrics(payload);
+    const requestId = stringPayload(raw.payload, "requestId") ??
+        context.request_id ??
+        generateRequestId();
+    const requestSpanId = stringPayload(raw.payload, "requestSpanId") ??
+        context.request_span_id ??
+        generateRequestSpanId();
+    const traceId = stringPayload(raw.payload, "traceId") ??
+        context.trace_id ??
+        generateTraceId();
+    const interactionId = stringPayload(raw.payload, "interactionId") ??
+        context.interaction_id ??
+        generateInteractionId();
+    const sessionId = stringPayload(raw.payload, "sessionId") ?? context.session_id;
+    const occurrenceKind = stringPayload(raw.payload, "occurrenceKind");
+    const originFrontendInteractionId = stringPayload(raw.payload, "originFrontendInteractionId");
+    const attributes = {
+        "cluebase.raw_event.kind": RAW_FRONTEND_SOURCE_SIGNAL_KIND,
+        "cluebase.raw_event.type": raw.type,
+        "cluebase.raw_event.payload": payload,
+        "cluebase.event_source": EVENT_SOURCE,
+    };
+    const customEventOrigin = raw.type === "custom_emitted" ? trustedCustomOrigin(raw.payload) : null;
+    const customEventName = raw.type === "custom_emitted" && customEventOrigin
+        ? stringPayload(raw.payload, "eventName")
+        : null;
+    if (customEventName &&
+        PUBLIC_CUSTOM_EVENT_NAME_PATTERN.test(customEventName)) {
+        attributes["cluebase.custom_event_name"] = customEventName;
+    }
+    if (customEventOrigin) {
+        attributes["cluebase.custom_event_origin"] = customEventOrigin;
+    }
+    if (traceId)
+        attributes["cluebase.trace_id"] = traceId;
+    if (requestId)
+        attributes["cluebase.request.id"] = requestId;
+    if (requestSpanId)
+        attributes["cluebase.request_span_id"] = requestSpanId;
+    if (interactionId)
+        attributes["cluebase.interaction.id"] = interactionId;
+    if (occurrenceKind)
+        attributes["cluebase.occurrence.kind"] = occurrenceKind;
+    if (originFrontendInteractionId) {
+        attributes["cluebase.origin_frontend_interaction.id"] =
+            originFrontendInteractionId;
+    }
+    if (sessionId)
+        attributes["cluebase.session.id"] = sessionId;
+    if (isRequestRawEvent(raw.type)) {
+        const method = stringPayload(raw.payload, "method");
+        const url = stringPayload(raw.payload, "url") ??
+            stringPayload(raw.payload, "requestUrl");
+        const path = stringPayload(raw.payload, "path");
+        const pathTemplate = stringPayload(raw.payload, "pathTemplate") ??
+            stringPayload(raw.payload, "route");
+        const targetService = stringPayload(raw.payload, "targetService");
+        const pageUrl = stringPayload(raw.payload, "pageUrl");
+        const viewId = stringPayload(raw.payload, "viewId");
+        const failureType = stringPayload(raw.payload, "failureType");
+        const outcomeClass = stringPayload(raw.payload, "outcomeClass");
+        const statusCode = numberPayload(raw.payload, "statusCode") ??
+            numberPayload(raw.payload, "status_code");
+        if (method) {
+            attributes["http.method"] = method;
+            attributes["http.request.method"] = method;
+        }
+        if (url) {
+            attributes["http.url"] = url;
+            attributes["url.full"] = url;
+        }
+        if (path)
+            attributes["cluebase.path"] = path;
+        if (pathTemplate) {
+            attributes["http.route"] = pathTemplate;
+            attributes["cluebase.path_template"] = pathTemplate;
+        }
+        if (targetService)
+            attributes["cluebase.target_service"] = targetService;
+        if (pageUrl)
+            attributes["cluebase.page.url"] = pageUrl;
+        if (viewId)
+            attributes["cluebase.view.id"] = viewId;
+        if (failureType) {
+            attributes[cluebaseAuthoredPropertyAttribute("failure_type")] = failureType;
+        }
+        if (outcomeClass)
+            attributes["cluebase.outcome_class"] = outcomeClass;
+        if (statusCode !== null) {
+            attributes["http.status_code"] = statusCode;
+            attributes["http.response.status_code"] = statusCode;
+        }
+    }
+    return {
+        event_id: eventId,
+        source_event_id: eventId,
+        source_schema_version: SOURCE_SCHEMA_VERSION,
+        source_event_type: SDK_SOURCE_SIGNAL_EVENT_TYPE,
+        source_event_kind: SDK_SOURCE_SIGNAL_EVENT_TYPE,
+        producer_id: context.producer_id,
+        service_name: EVENT_SOURCE,
+        event_name: SDK_SOURCE_SIGNAL_EVENT_NAME,
+        event_category: "context",
+        event_source: EVENT_SOURCE,
+        event_version: EVENT_VERSION,
+        occurred_at: occurredAt,
+        ingested_at: new Date().toISOString(),
+        status: "observed",
+        sdk_collection_mode: context.sdk_collection_mode,
+        privacy_state: "masked",
+        privacy_level: "default_masked",
+        masking_state: "masked",
+        allowed_value_keys: [],
+        privacy_summary: context.privacy_summary,
+        trace_id: traceId,
+        request_id: requestId,
+        request_span_id: requestSpanId,
+        interaction_id: interactionId,
+        frontend_release: context.frontend_release,
+        backend_release: null,
+        properties: {},
+        metrics: {},
+        sdk_signal: {
+            surface: "frontend",
+            kind: "span",
+            name: raw.type,
+            span_kind: "INTERNAL",
+            trace_id: traceId,
+            span_id: eventId,
+            parent_span_id: null,
+            start_time_unix_nano: `${BigInt(occurredAtMs) * 1000000n}`,
+            end_time_unix_nano: `${BigInt(occurredAtMs) * 1000000n}`,
+            status_code: null,
+            status_message: null,
+            instrumentation_scope_name: "@genn-inc/cluebase-frontend-sdk",
+            attributes,
+            events: [],
+            resource: toFrontendSourceResource(options.resource, options.deniedKeys),
+            context: contextRecord(context, {
+                session_id: sessionId,
+                trace_id: traceId,
+                request_id: requestId,
+                request_span_id: requestSpanId,
+                interaction_id: interactionId,
+            }),
+        },
+    };
+}

package/dist/exporter/retry.d.ts

@@ -0,0 +1,8 @@
+export { RETRY_CONFIG } from "../provider/constants.js";
+export type RetryPolicy = {
+    maxAttempts: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    maxAdditiveJitterMs: number;
+};
+export declare const computeRetryDelay: (attempt: number, policy: RetryPolicy) => number;

package/dist/exporter/retry.js

@@ -0,0 +1,8 @@
+export { RETRY_CONFIG } from "../provider/constants.js";
+export const computeRetryDelay = (attempt, policy) => {
+    const exponent = Math.max(0, attempt - 1);
+    const raw = policy.baseDelayMs * 2 ** exponent;
+    const capped = Math.min(raw, policy.maxDelayMs);
+    const jitter = Math.floor(Math.random() * Math.min(policy.maxAdditiveJitterMs, capped));
+    return capped + jitter;
+};

package/dist/exporter/sanitize.d.ts

@@ -0,0 +1,30 @@
+import { detectIdentityPII } from "../_generated/identity-pii-policy.js";
+export type SanitizationAccumulator = {
+    maskedValueCount: number;
+    droppedFieldCount: number;
+    maskedFields: Set<string>;
+};
+export declare const isDeniedKey: (key: string, deniedKeys?: readonly string[]) => boolean;
+export declare const sanitizeHeaders: (headers: Record<string, string>, deniedKeys?: string[]) => Record<string, string>;
+export declare const sanitizeObject: (value: unknown, deniedKeys?: string[], summary?: SanitizationAccumulator, pathPrefix?: string) => unknown;
+export declare const parseUrlForNetwork: (rawUrl: string) => {
+    host: string;
+    pathTemplate: string;
+    path: string;
+    query: Record<string, string | string[]>;
+    urlMaskedQuery: string;
+};
+export declare const maybeParseJson: (value: unknown) => unknown;
+export { detectIdentityPII };
+/**
+ * Synchronous deterministic SHA-256 hash for identity values that look
+ * like PII. The identity sanitization path must remain synchronous
+ * because `identify(userId)` is sync-only by SDK contract.
+ *
+ * Output format: `cluebase_pii_hashed:<32-hex>`.
+ *
+ * The algorithm name, the digest length and the prefix are read from the
+ * generated policy, not written here, so the three SDKs produce the same
+ * token for the same input by construction rather than by assertion.
+ */
+export declare const hashIdentityValue: (value: string) => string;