@genn-inc/cluebase-frontend-sdk 0.0.6 → 0.0.9

package/dist/exporter/sdk-core-delivery.d.ts

@@ -0,0 +1,226 @@
+import type { DiagnosticCode } from "./diagnostics.js";
+export type ConsentState = "unknown" | "granted" | "denied";
+export type CollectionPermit = {
+    readonly generation: string;
+    readonly gate_id: string;
+    readonly permitted_at_start: boolean;
+    readonly capture_open_at_start: boolean;
+};
+export type TransportConfigInput = {
+    readonly surface: "frontend";
+    readonly endpoint: string;
+    readonly project_key: string;
+    readonly sdk_request?: string;
+    readonly sdk_version?: string;
+    readonly source_schema_version?: string;
+};
+export type QueueLimitsInput = {
+    readonly max_payload_bytes: number;
+    readonly max_buffer_bytes: number;
+    readonly max_buffer_events?: number;
+};
+export type DriverOptions = {
+    readonly transport: TransportConfigInput;
+    readonly queue_limits: QueueLimitsInput;
+    readonly request_timeout_ms?: number;
+};
+export type QueuedEvent = {
+    readonly event_key: string;
+    readonly byte_length: number;
+    readonly permit: CollectionPermit;
+    readonly diagnostic_canonical_bytes?: string;
+};
+export type RestoredEvent = {
+    readonly event_key: string;
+    readonly byte_length: number;
+    readonly diagnostic_canonical_bytes?: string;
+};
+export type DiagnosticEntry = {
+    readonly code: DiagnosticCode;
+    readonly count?: number;
+    readonly event_fingerprint?: string;
+    readonly batch_fingerprint?: string;
+    readonly http_status?: number;
+    readonly attempt?: number;
+};
+export type HostDiagnostic = {
+    readonly code: DiagnosticCode;
+    readonly count?: number;
+    readonly event_canonical_bytes?: string;
+    readonly batch_canonical_bytes?: string;
+};
+export type EnqueueReport = {
+    readonly retained: boolean;
+    readonly overflowed_event_keys: readonly string[];
+    readonly diagnostics: readonly DiagnosticEntry[];
+};
+export type FenceReport = {
+    readonly target_ordinal: number;
+    readonly oversized_event_keys: readonly string[];
+    readonly frame_admits_no_event: boolean;
+    readonly diagnostics: readonly DiagnosticEntry[];
+};
+export type RestoreReport = {
+    readonly adopted: boolean;
+    readonly event_keys: readonly string[];
+    readonly batch_id?: number;
+};
+export type ReleaseReport = {
+    readonly events: readonly QueuedEvent[];
+};
+export type QueueDepthReport = {
+    readonly draft_count: number;
+    readonly draft_body_bytes: number;
+    readonly pending_bytes: number;
+};
+export type ConsentReport = {
+    readonly consent: ConsentState;
+    readonly purged_event_keys: readonly string[];
+    readonly diagnostics: readonly DiagnosticEntry[];
+};
+export type TransportHeader = {
+    readonly name: string;
+    readonly value: string;
+};
+export type TransportRequest = {
+    readonly attempt_id: number;
+    readonly target: "ingest_batch" | "browser_token";
+    readonly method: string;
+    readonly url: string;
+    readonly headers: readonly TransportHeader[];
+    readonly body: string;
+    readonly timeout_ms: number;
+    readonly max_response_body_bytes: number;
+    readonly follow_redirects: boolean;
+    readonly keepalive: boolean;
+    readonly omit_credentials: boolean;
+    readonly suppress_instrumentation: boolean;
+};
+export type TransportAbortCause = "consent_revoked" | "deadline" | "shutdown";
+export type TransportOutcome = {
+    readonly kind: "response";
+    readonly status: number;
+    readonly body: string;
+    readonly body_over_limit?: boolean;
+} | {
+    readonly kind: "timeout";
+} | {
+    readonly kind: "network_error";
+} | {
+    readonly kind: "aborted";
+    readonly cause: TransportAbortCause;
+};
+export type DeliveryStep = {
+    readonly kind: "idle";
+} | {
+    readonly kind: "send";
+    readonly attempt_id: number;
+    readonly batch_id: number;
+    readonly attempt: number;
+    readonly event_keys: readonly string[];
+    readonly timeout_ms: number;
+} | {
+    readonly kind: "wait_retry";
+    readonly resume_at_ms: number;
+    readonly delay_ms: number;
+} | {
+    readonly kind: "blocked";
+    readonly reason: "awaiting_result" | "consent_revoked" | "deadline_exceeded" | "retries_exhausted";
+};
+export type DeliveryProgress = {
+    readonly kind: "ignored";
+} | {
+    readonly kind: "settled";
+    readonly batch_id: number;
+    readonly settled_event_keys: readonly string[];
+    readonly dropped_event_keys: readonly string[];
+} | {
+    readonly kind: "split_scheduled";
+    readonly batch_id: number;
+} | {
+    readonly kind: "dropped_oversized";
+    readonly batch_id: number;
+    readonly event_key: string;
+} | {
+    readonly kind: "retry_scheduled";
+    readonly batch_id: number;
+    readonly delay_ms: number;
+    readonly resume_at_ms: number;
+} | {
+    readonly kind: "retries_exhausted";
+    readonly batch_id: number;
+} | {
+    readonly kind: "consent_revoked";
+};
+export type DroppedEventDetail = {
+    readonly event_index: number;
+    readonly reason: string;
+    readonly source_event_payload_fingerprint: string | null;
+};
+export type IngestVerdict = {
+    readonly accepted: boolean;
+    readonly observation_ingest_batch_id?: string;
+    readonly status?: string;
+    readonly reason?: string;
+    readonly retry_strategy?: string;
+    readonly submitted_event_count?: number;
+    readonly accepted_event_count?: number;
+    readonly dropped_event_count?: number;
+    readonly dropped_events?: readonly DroppedEventDetail[];
+    readonly duplicate?: boolean;
+    readonly error?: string;
+    readonly limits?: Readonly<Record<string, number>>;
+};
+export type DeliveryDecision = {
+    readonly outcome: string;
+    readonly action: "none" | "retry_same_batch" | "split_batch";
+    readonly result: IngestVerdict;
+    readonly response_contract: "valid" | "invalid" | "not_applicable";
+    readonly diagnostic_codes: readonly DiagnosticCode[];
+    readonly http_status?: number | null;
+    readonly used_status_fallback?: boolean;
+    readonly dropped_indexes?: readonly number[];
+    readonly privacy_policy?: unknown;
+    readonly sdk_encryption?: unknown;
+    readonly directive_unreadable?: boolean;
+};
+export type DeliveryReport = {
+    readonly progress: DeliveryProgress;
+    readonly decision?: DeliveryDecision;
+    readonly diagnostics: readonly DiagnosticEntry[];
+};
+export type ResponseEvaluation = {
+    readonly kind: "decision";
+    readonly decision: DeliveryDecision;
+} | {
+    readonly kind: "consent_revoked";
+};
+export declare const openConsent: (consent: ConsentState) => number;
+export declare const readConsentState: (consentHandle: number) => ConsentState;
+export declare const setConsent: (consentHandle: number, consent: ConsentState) => ConsentReport;
+export declare const openDriver: (options: DriverOptions, consentHandle: number) => number;
+export declare const closeDriver: (handle: number) => boolean;
+export declare const capturePermit: (handle: number) => CollectionPermit;
+export declare const permitsCapture: (handle: number, permit: CollectionPermit) => boolean;
+export declare const rebindPermit: (handle: number, permit: CollectionPermit) => CollectionPermit;
+export declare const enqueueEvent: (handle: number, event: QueuedEvent) => EnqueueReport;
+export declare const adoptRestoredBatch: (handle: number, ordinal: number, events: readonly RestoredEvent[]) => RestoreReport;
+export declare const releaseDrafts: (handle: number) => ReleaseReport;
+export declare const queueDepth: (handle: number, envelopeOverheadBytes: number) => QueueDepthReport;
+export declare const fenceQueue: (handle: number, envelopeOverheadBytes: number) => FenceReport;
+export declare const planNextStep: (handle: number, nowMs: number, deadlineMs?: number) => DeliveryStep;
+export declare const attemptRequest: (handle: number, input: {
+    readonly attemptId: number;
+    readonly body: string;
+    readonly timeoutMs: number;
+    readonly batchCanonicalBytes?: string;
+}) => TransportRequest;
+export declare const applyTransportResult: (handle: number, attemptId: number, outcome: TransportOutcome, nowMs: number) => DeliveryReport;
+export declare const evaluateResponse: (outcome: TransportOutcome, localSubmittedEventCount: number) => ResponseEvaluation;
+export declare const setBrowserToken: (handle: number, token: string | null) => boolean;
+export declare const beginClose: (handle: number) => void;
+export declare const pendingEventCount: (handle: number) => number;
+export declare const diagnosticsSnapshot: (handle: number) => Readonly<Record<string, unknown>>;
+export declare const recordHostDiagnostic: (handle: number, diagnostic: HostDiagnostic) => void;
+export declare const eventFingerprint: (handle: number, canonicalBytes: string) => string;
+export declare const batchFingerprint: (handle: number, canonicalBytes: string) => string;

package/dist/exporter/sdk-core-delivery.js

@@ -0,0 +1,97 @@
+import { deliveryCommandJson } from "./sdk-core-wasm.js";
+const call = (request) => JSON.parse(deliveryCommandJson(JSON.stringify(request)));
+export const openConsent = (consent) => call({ command: "open_consent", consent })
+    .consent;
+export const readConsentState = (consentHandle) => call({
+    handle: consentHandle,
+    command: "consent_state",
+}).consent;
+export const setConsent = (consentHandle, consent) => call({
+    handle: consentHandle,
+    command: "set_consent",
+    consent,
+});
+export const openDriver = (options, consentHandle) => call({
+    command: "open",
+    options,
+    consent: consentHandle,
+}).handle;
+export const closeDriver = (handle) => call({ handle, command: "close" }).closed;
+export const capturePermit = (handle) => call({ handle, command: "capture_permit" });
+export const permitsCapture = (handle, permit) => call({
+    handle,
+    command: "permits_capture",
+    permit,
+}).permitted;
+export const rebindPermit = (handle, permit) => call({ handle, command: "rebind_permit", permit });
+export const enqueueEvent = (handle, event) => call({ handle, command: "enqueue", event });
+export const adoptRestoredBatch = (handle, ordinal, events) => call({
+    handle,
+    command: "adopt_restored_batch",
+    ordinal,
+    events,
+});
+export const releaseDrafts = (handle) => call({ handle, command: "release_drafts" });
+export const queueDepth = (handle, envelopeOverheadBytes) => call({
+    handle,
+    command: "queue_depth",
+    envelope_overhead_bytes: envelopeOverheadBytes,
+});
+export const fenceQueue = (handle, envelopeOverheadBytes) => call({
+    handle,
+    command: "fence",
+    envelope_overhead_bytes: envelopeOverheadBytes,
+});
+export const planNextStep = (handle, nowMs, deadlineMs) => call({
+    handle,
+    command: "plan_next_step",
+    now_ms: nowMs,
+    ...(deadlineMs === undefined ? {} : { deadline_ms: deadlineMs }),
+});
+export const attemptRequest = (handle, input) => call({
+    handle,
+    command: "attempt_request",
+    attempt_id: input.attemptId,
+    body: input.body,
+    timeout_ms: input.timeoutMs,
+    ...(input.batchCanonicalBytes === undefined
+        ? {}
+        : { batch_canonical_bytes: input.batchCanonicalBytes }),
+});
+export const applyTransportResult = (handle, attemptId, outcome, nowMs) => call({
+    handle,
+    command: "apply_result",
+    result: { attempt_id: attemptId, outcome },
+    now_ms: nowMs,
+});
+export const evaluateResponse = (outcome, localSubmittedEventCount) => call({
+    command: "evaluate_response",
+    outcome,
+    local_submitted_event_count: localSubmittedEventCount,
+    surface: "frontend",
+});
+export const setBrowserToken = (handle, token) => call({ handle, command: "set_browser_token", token });
+export const beginClose = (handle) => {
+    call({ handle, command: "begin_close" });
+};
+export const pendingEventCount = (handle) => call({
+    handle,
+    command: "pending_event_count",
+}).pending_event_count;
+export const diagnosticsSnapshot = (handle) => call({
+    handle,
+    command: "diagnostics_snapshot",
+});
+export const recordHostDiagnostic = (handle, diagnostic) => {
+    call({ handle, command: "record_diagnostic", diagnostic });
+};
+export const eventFingerprint = (handle, canonicalBytes) => call({
+    handle,
+    command: "event_fingerprint",
+    canonical_bytes: canonicalBytes,
+}).fingerprint;
+export const batchFingerprint = (handle, canonicalBytes) => call({
+    handle,
+    command: "batch_fingerprint",
+    canonical_bytes: canonicalBytes,
+}).fingerprint;

package/dist/exporter/sdk-core-wasm.d.ts

@@ -2,4 +2,27 @@ import init from "../wasm/pkg-web/cluebase_sdk_core_wasm.js";
 export type SdkCoreWasmInitInput = Parameters<typeof init>[0];
 export declare const initSdkCoreWasm: (input?: SdkCoreWasmInitInput) => Promise<void>;
 export declare const isSdkCoreWasmReady: () => boolean;
-export declare const spanToSdkSignalJson: (spanJson: string, optionsJson: string) => string;
+export declare const spanToObservationSourceEventJson: (spanJson: string, optionsJson: string) => string;
+export declare const deliveryCommandJson: (requestJson: string) => string;
+export type ParameterCaptureDecision = "plain" | "encrypt" | "mask";
+export type ParameterValueFact = {
+    readonly type: "boolean";
+} | {
+    readonly type: "number";
+    readonly number: number;
+} | {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "other";
+};
+export type ParameterCaptureRequestEntry = {
+    readonly key: string;
+    readonly value: ParameterValueFact;
+};
+export declare const decideParameterCaptures: (entries: readonly ParameterCaptureRequestEntry[]) => readonly ParameterCaptureDecision[];
+export type IngestEndpointDescription = {
+    readonly ingestBatchUrl: string;
+    readonly browserTokenUrl: string;
+};
+export declare const describeIngestEndpoint: (endpoint: string) => Promise<IngestEndpointDescription>;

package/dist/exporter/sdk-core-wasm.js

@@ -1,4 +1,4 @@
-import init, { spanToSdkSignalJson as wasmSpanToSdkSignalJson, } from "../wasm/pkg-web/cluebase_sdk_core_wasm.js";
+import init, { deliveryCommandJson as wasmDeliveryCommandJson, parameterCaptureDecisionsJson as wasmParameterCaptureDecisionsJson, spanToObservationSourceEventJson as wasmSpanToObservationSourceEventJson, } from "../wasm/pkg-web/cluebase_sdk_core_wasm.js";
 let readyPromise = null;
 let ready = false;
 export const initSdkCoreWasm = (input) => {
@@ -10,9 +10,37 @@ export const initSdkCoreWasm = (input) => {
     return readyPromise;
 };
 export const isSdkCoreWasmReady = () => ready;
-export const spanToSdkSignalJson = (spanJson, optionsJson) => {
+const requireReady = () => {
     if (!ready) {
         throw new Error("cluebase sdk core wasm is not initialized; call initSdkCoreWasm() first");
     }
-    return wasmSpanToSdkSignalJson(spanJson, optionsJson);
+};
+export const spanToObservationSourceEventJson = (spanJson, optionsJson) => {
+    requireReady();
+    return wasmSpanToObservationSourceEventJson(spanJson, optionsJson);
+};
+export const deliveryCommandJson = (requestJson) => {
+    requireReady();
+    return wasmDeliveryCommandJson(requestJson);
+};
+export const decideParameterCaptures = (entries) => {
+    if (entries.length === 0)
+        return [];
+    requireReady();
+    const reply = JSON.parse(wasmParameterCaptureDecisionsJson(JSON.stringify({ entries })));
+    return reply.decisions;
+};
+export const describeIngestEndpoint = async (endpoint) => {
+    if (!isSdkCoreWasmReady()) {
+        await initSdkCoreWasm();
+    }
+    const described = JSON.parse(deliveryCommandJson(JSON.stringify({
+        command: "describe_endpoint",
+        endpoint,
+        surface: "frontend",
+    })));
+    return {
+        ingestBatchUrl: described.ingest_batch_url,
+        browserTokenUrl: described.browser_token_url,
+    };
 };

package/dist/exporter/source-event.d.ts

@@ -1,6 +1,7 @@
 import type { CanonicalJsonValue, CluebasePrivacySummary, CluebaseSubjectProfile, SdkCollectionMode } from "../provider/types.js";
 export declare const SDK_SOURCE_SIGNAL_EVENT_NAME = "sdk_source_signal_observed";
 export declare const SDK_SOURCE_SIGNAL_EVENT_TYPE = "sdk_source_signal";
+export declare const SOURCE_SCHEMA_VERSION = 1;
 export type BrowserSdkSignalContext = {
     producer_id: string | null;
     anonymous_id: string | null;
@@ -99,4 +100,5 @@ export type BrowserSourceSignalEvent = {
     sdk_signal: BrowserSdkSignal;
 };
 export type BrowserSourceEvent = BrowserSourceSignalEvent;
+export declare const withSourceEvidence: (event: BrowserSourceEvent) => BrowserSourceEvent;
 export declare function isBrowserSourceSignalEvent(event: unknown): event is BrowserSourceSignalEvent;

package/dist/exporter/source-event.js

@@ -1,5 +1,22 @@
+import { DEFAULT_FRONTEND_SOURCE_IDENTIFIER } from "../provider/constants.js";
 export const SDK_SOURCE_SIGNAL_EVENT_NAME = "sdk_source_signal_observed";
 export const SDK_SOURCE_SIGNAL_EVENT_TYPE = "sdk_source_signal";
+export const SOURCE_SCHEMA_VERSION = 1;
+export const withSourceEvidence = (event) => ({
+    ...event,
+    source_event_id: event.source_event_id ?? event.event_id,
+    source_schema_version: String(SOURCE_SCHEMA_VERSION),
+    source_event_type: SDK_SOURCE_SIGNAL_EVENT_TYPE,
+    source_event_kind: SDK_SOURCE_SIGNAL_EVENT_TYPE,
+    event_name: SDK_SOURCE_SIGNAL_EVENT_NAME,
+    event_category: "context",
+    producer_id: DEFAULT_FRONTEND_SOURCE_IDENTIFIER,
+    service_name: event.service_name ?? DEFAULT_FRONTEND_SOURCE_IDENTIFIER,
+    privacy_state: event.privacy_state ?? "masked",
+    privacy_level: event.privacy_level ?? "default_masked",
+    masking_state: event.masking_state ?? "masked",
+    allowed_value_keys: event.allowed_value_keys ?? [],
+});
 const isReadableObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 export function isBrowserSourceSignalEvent(event) {
     if (!isReadableObject(event)) {

package/dist/exporter/span-to-source-signal.d.ts

@@ -1,6 +1,6 @@
 import type { ReadableSpan } from "@opentelemetry/sdk-trace-base";
 import type { CluebaseContext } from "../provider/types.js";
-import { type BrowserSourceSignalEvent } from "./source-event.js";
+import type { BrowserSourceSignalEvent } from "./source-event.js";
 export interface SpanToSourceSignalOptions {
     context: CluebaseContext;
     deniedKeys?: readonly string[];

package/dist/exporter/span-to-source-signal.js

@@ -1,55 +1,6 @@
-import { CLUEBASE_CORRELATION_ATTRIBUTE_KEYS } from "../_generated/correlation-attribute-keys.js";
-import { nanosToIso, parentSpanId } from "../_generated/otel-span-conversion.js";
-import { ALWAYS_DENIED_KEYS, EVENT_SOURCE, EVENT_VERSION, SOURCE_SCHEMA_VERSION, } from "../provider/constants.js";
-import { generateEventId } from "./event-id.js";
-import { isDeniedKey } from "./sanitize.js";
-import { initSdkCoreWasm, isSdkCoreWasmReady, spanToSdkSignalJson, } from "./sdk-core-wasm.js";
-import { SDK_SOURCE_SIGNAL_EVENT_NAME, SDK_SOURCE_SIGNAL_EVENT_TYPE, } from "./source-event.js";
-function withCoreMasking(summary, masking) {
-    const maskedValueCount = masking?.masked_value_count ?? 0;
-    const maskedFields = masking?.masked_fields ?? [];
-    if (!summary) {
-        if (maskedValueCount === 0 && maskedFields.length === 0)
-            return undefined;
-        return {
-            level: "masked",
-            masked_value_count: maskedValueCount,
-            dropped_field_count: 0,
-            masked_fields: [...maskedFields].sort(),
-            rule_set_version: null,
-        };
-    }
-    return {
-        ...summary,
-        masked_value_count: summary.masked_value_count + maskedValueCount,
-        masked_fields: [
-            ...new Set([...summary.masked_fields, ...maskedFields]),
-        ].sort(),
-    };
-}
-function rawAttrString(attributes, key) {
-    const value = attributes?.[key];
-    return typeof value === "string" && value.trim().length > 0
-        ? value.trim()
-        : null;
-}
-function preFilterDeniedAttributes(attributes, deniedKeys) {
-    const filtered = {};
-    for (const [key, value] of Object.entries(attributes ?? {})) {
-        if (!CLUEBASE_CORRELATION_ATTRIBUTE_KEYS.has(key) &&
-            isDeniedKey(key, deniedKeys)) {
-            continue;
-        }
-        filtered[key] = value;
-    }
-    return filtered;
-}
-function seedFallbackAttribute(attributesForCore, attributeKey, candidateKeys, fallback) {
-    const alreadyPresent = candidateKeys.some((candidateKey) => rawAttrString(attributesForCore, candidateKey) !== null);
-    if (alreadyPresent || !fallback)
-        return;
-    attributesForCore[attributeKey] = fallback;
-}
+import { parentSpanId } from "../_generated/otel-span-conversion.js";
+import { EVENT_SOURCE } from "../provider/constants.js";
+import { initSdkCoreWasm, isSdkCoreWasmReady, spanToObservationSourceEventJson, } from "./sdk-core-wasm.js";
 function resourceAttributesInput(resource) {
     const input = resource;
     try {
@@ -59,19 +10,13 @@ function resourceAttributesInput(resource) {
         return {};
     }
 }
-const FIXED_CORE_DENIED_KEYS = Object.freeze([...new Set(ALWAYS_DENIED_KEYS)].sort());
-function coreDeniedKeys(deniedKeys) {
-    if (deniedKeys.length === 0)
-        return FIXED_CORE_DENIED_KEYS;
-    return [...new Set([...FIXED_CORE_DENIED_KEYS, ...deniedKeys])].sort();
-}
 function instrumentationScopeName(span) {
     const instrumentation = span;
     return (instrumentation.instrumentationScope?.name ??
         instrumentation.instrumentationLibrary?.name ??
         null);
 }
-function contextRecord(context, overrides) {
+function contextRecord(context) {
     return {
         producer_id: context.producer_id,
         anonymous_id: context.anonymous_id,
@@ -80,11 +25,11 @@ function contextRecord(context, overrides) {
         user_profile: context.user_profile,
         session_id: context.session_id,
         tab_id: context.tab_id,
-        trace_id: overrides.trace_id,
-        request_id: overrides.request_id,
-        request_span_id: overrides.request_span_id,
-        action_id: overrides.action_id,
-        interaction_id: overrides.interaction_id,
+        trace_id: context.trace_id,
+        request_id: context.request_id,
+        request_span_id: context.request_span_id,
+        action_id: context.action_id,
+        interaction_id: context.interaction_id,
         correlation_id: context.correlation_id,
         sdk_collection_mode: context.sdk_collection_mode,
         frontend_release: context.frontend_release,
@@ -119,100 +64,35 @@ export async function spanToSourceSignalEvent(span, options) {
         await initSdkCoreWasm();
     }
     const context = options.context;
-    const deniedKeys = options.deniedKeys ?? [];
     const spanContext = span.spanContext();
-    const spanId = spanContext.spanId || null;
-    const parentId = parentSpanId(span, span.attributes);
-    const traceId = rawAttrString(span.attributes, "cluebase.trace_id") ??
-        spanContext.traceId ??
-        undefined;
-    const attributesForCore = preFilterDeniedAttributes(span.attributes, deniedKeys);
-    seedFallbackAttribute(attributesForCore, "cluebase.request_span_id", ["cluebase.request_span_id"], spanId ?? context.request_span_id);
-    seedFallbackAttribute(attributesForCore, "cluebase.request_id", ["cluebase.request.id", "cluebase.request_id"], context.request_id);
-    seedFallbackAttribute(attributesForCore, "cluebase.action_id", ["cluebase.action.id", "cluebase.action_id"], context.action_id ?? undefined);
-    seedFallbackAttribute(attributesForCore, "cluebase.interaction_id", ["cluebase.interaction.id", "cluebase.interaction_id"], context.interaction_id);
     const corePayload = {
         name: span.name,
         kind: typeof span.kind === "number" ? span.kind : undefined,
-        trace_id: traceId,
-        span_id: spanId ?? undefined,
-        parent_span_id: parentId ?? undefined,
+        trace_id: spanContext.traceId,
+        span_id: spanContext.spanId,
+        parent_span_id: parentSpanId(span, span.attributes),
         start_time: span.startTime,
         end_time: span.endTime,
         status: span.status
             ? { code: span.status.code ?? undefined, message: span.status.message }
             : undefined,
-        attributes: attributesForCore,
+        attributes: span.attributes,
         events: (span.events ?? []).map((event) => ({
             name: event.name,
-            attributes: preFilterDeniedAttributes(event.attributes, deniedKeys),
+            attributes: event.attributes ?? {},
         })),
         resource_attributes: resourceAttributesInput(span.resource),
-        instrumentation_scope_name: instrumentationScopeName(span) ?? undefined,
+        instrumentation_scope_name: instrumentationScopeName(span),
     };
     const coreOptions = {
-        denied_keys: coreDeniedKeys(deniedKeys),
+        denied_keys: options.deniedKeys ?? [],
         surface: "frontend",
-    };
-    const core = JSON.parse(spanToSdkSignalJson(JSON.stringify(corePayload), JSON.stringify(coreOptions)));
-    const resolvedTraceId = core.trace_id ?? traceId ?? "";
-    const eventId = generateEventId();
-    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,
+        sdk_collection_mode: context.sdk_collection_mode,
         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: nanosToIso(core.start_time_unix_nano),
-        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: withCoreMasking(context.privacy_summary, core.privacy_masking),
-        trace_id: resolvedTraceId,
-        span_id: core.span_id,
-        parent_span_id: core.parent_span_id,
-        request_id: core.request_id,
-        request_span_id: core.request_span_id,
-        action_id: core.action_id,
-        interaction_id: core.interaction_id,
         frontend_release: context.frontend_release,
-        backend_release: null,
-        properties: {},
-        metrics: {},
-        sdk_signal: {
-            surface: "frontend",
-            kind: "span",
-            name: span.name,
-            span_kind: core.span_kind,
-            trace_id: resolvedTraceId,
-            span_id: core.span_id,
-            parent_span_id: core.parent_span_id,
-            start_time_unix_nano: core.start_time_unix_nano,
-            end_time_unix_nano: core.end_time_unix_nano,
-            status_code: core.status_code ?? null,
-            status_message: core.status_message,
-            instrumentation_scope_name: core.instrumentation_scope_name,
-            attributes: core.attributes,
-            events: core.events,
-            resource: core.resource,
-            raw_resource: core.raw_resource,
-            context: contextRecord(context, {
-                trace_id: resolvedTraceId,
-                request_id: core.request_id,
-                request_span_id: core.request_span_id,
-                action_id: core.action_id,
-                interaction_id: core.interaction_id,
-            }),
-        },
+        context: contextRecord(context),
+        context_privacy_summaries: [context.privacy_summary],
     };
+    return JSON.parse(spanToObservationSourceEventJson(JSON.stringify(corePayload), JSON.stringify(coreOptions)));
 }

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 import type { InternalMetricsSnapshot } from "./internal/metrics.js";
-import type { CluebaseConsentState, CluebaseGroupTraits, CluebaseGroupType, CluebaseInitOptions, CluebaseSubjectTraits, CluebaseTrackMetrics, CluebaseTrackProperties } from "./provider/types.js";
+import type { CluebaseConsentState, CluebaseGroupTraits, CluebaseGroupType, CluebaseInitOptions, CluebaseLinkInput, CluebaseSubjectTraits, CluebaseTrackMetrics, CluebaseTrackProperties } from "./provider/types.js";
 declare const cluebase: {
     init(options: CluebaseInitOptions): void;
     identify(userId: string, traits?: CluebaseSubjectTraits): void;
     group(groupType: CluebaseGroupType, groupKey: string, traits?: CluebaseGroupTraits): void;
+    link(input: CluebaseLinkInput): void;
     linkExternalAccount(namespace: string, externalId: string): void;
-    logout(): void;
     reset(): void;
     track(eventName: string, properties?: CluebaseTrackProperties, metrics?: CluebaseTrackMetrics): void;
     setConsent(consent: CluebaseConsentState): void;
@@ -18,5 +18,5 @@ declare const cluebase: {
 export { EXPORT_RESULT_FAILED, EXPORT_RESULT_SUCCESS, ObservationSourceEventExporter, type ObservationSourceEventExporterOptions, } from "./exporter/observation-source-event-exporter.js";
 export { attachNextRouterIntegration } from "./integrations/next-router.js";
 export { attachReactRouterIntegration } from "./integrations/react-router.js";
-export type { CluebaseConsentState, CluebaseGroupTraits, CluebaseGroupType, CluebaseInitOptions, CluebaseSubjectTraits, CluebaseTrackMetrics, CluebaseTrackProperties, InternalMetricsSnapshot, };
+export type { CluebaseConsentState, CluebaseGroupTraits, CluebaseGroupType, CluebaseInitOptions, CluebaseLinkInput, CluebaseSubjectTraits, CluebaseTrackMetrics, CluebaseTrackProperties, InternalMetricsSnapshot, };
 export default cluebase;