@genn-inc/cluebase-frontend-sdk 0.0.3 → 0.0.8

package/dist/exporter/diagnostics.js

@@ -1,31 +1,7 @@
 import { hmac } from "@noble/hashes/hmac";
 import { sha256 } from "@noble/hashes/sha256";
 import { bytesToHex, randomBytes, utf8ToBytes } from "@noble/hashes/utils";
-const CODES = [
-    "batch_split",
-    "consent_persistence_failed",
-    "consent_purge",
-    "consent_purge_failed",
-    "consent_state_unavailable",
-    "durable_outbox_unavailable",
-    "duplicate_drop_details_unavailable",
-    "event_oversize",
-    "intentional_drop",
-    "invalid_response",
-    "legacy_pre_revocation_event_blocked",
-    "legacy_bridge_capacity_reached",
-    "legacy_writer_detected",
-    "non_canonical_success_status",
-    "outbox_key_collision",
-    "outbox_record_corrupt",
-    "protocol_redirect",
-    "queue_overflow",
-    "retry_exhausted",
-    "retry_scheduled",
-    "shutdown_failure",
-    "terminal_rejection",
-    "unknown_status",
-];
+import { DIAGNOSTIC_CODES as CODES, } from "../_generated/diagnostic-codes.js";
 const CODE_SET = new Set(CODES);
 const STRATEGIES = new Set([
     "split_batch",
@@ -51,6 +27,7 @@ const SAFE_REASONS = new Set([
     "raw_ingest_ack_unknown",
     "raw_ingest_produce_failed",
     "raw_ingest_receipt_metadata_failed",
+    "raw_ingest_receipt_unprocessable",
     "route_throttled",
     "stale_browser_token",
     "unresolved_project_or_environment",
@@ -131,7 +108,9 @@ const normalize = (input) => {
     if (input.reason && SAFE_REASONS.has(input.reason))
         entry.reason = input.reason;
     const attempt = input.attempt;
-    if (typeof attempt === "number" && Number.isSafeInteger(attempt) && attempt > 0) {
+    if (typeof attempt === "number" &&
+        Number.isSafeInteger(attempt) &&
+        attempt > 0) {
         entry.attempt = attempt;
     }
     const count = input.count;

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

@@ -1,6 +1,7 @@
 export declare const generateMonotonicId: (prefix?: string) => string;
 export declare const generateTraceId: () => string;
 export declare const generateEventId: () => string;
+export declare const generateBatchId: () => string;
 export declare const generateAnonymousId: () => string;
 export declare const generateSessionId: () => string;
 export declare const generateTabId: () => string;

package/dist/exporter/event-id.js

@@ -20,9 +20,7 @@ const nextMonotonicParts = () => {
         typeof globalThis.performance.now === "function"
         ? Math.floor(globalThis.performance.now() * 1000)
         : Date.now();
-    const monotonicTime = performanceNow > lastMonotonicTime
-        ? performanceNow
-        : lastMonotonicTime + 1;
+    const monotonicTime = performanceNow > lastMonotonicTime ? performanceNow : lastMonotonicTime + 1;
     lastMonotonicTime = monotonicTime;
     monotonicCounter = (monotonicCounter + 1) % Number.MAX_SAFE_INTEGER;
     return { monotonicTime, counter: monotonicCounter };
@@ -51,6 +49,9 @@ export const generateTraceId = () => {
 export const generateEventId = () => {
     return generateMonotonicId();
 };
+export const generateBatchId = () => {
+    return toHex(randomBytes(16));
+};
 export const generateAnonymousId = () => {
     return generateMonotonicId("anon");
 };

package/dist/exporter/frontend-resource.js

@@ -1,7 +1,7 @@
-import { isDeniedKey } from "./sanitize.js";
+import { CLUEBASE_OTEL_ALLOWED_RESOURCE_KEYS, CLUEBASE_OTEL_SDK_SOURCE_REQUIRED_RESOURCE_KEYS, } from "../_generated/otel-resource-keys.js";
 import { SDK_VERSION } from "../provider/constants.js";
-import { CLUEBASE_OTEL_SDK_SOURCE_REQUIRED_RESOURCE_KEYS, CLUEBASE_OTEL_SDK_SOURCE_RESOURCE_KEYS, } from "../_generated/otel-resource-keys.js";
-const FRONTEND_RESOURCE_KEYS = new Set(CLUEBASE_OTEL_SDK_SOURCE_RESOURCE_KEYS);
+import { isDeniedKey } from "./sanitize.js";
+const FRONTEND_RESOURCE_KEYS = new Set(CLUEBASE_OTEL_ALLOWED_RESOURCE_KEYS);
 const FRONTEND_REQUIRED_RESOURCE_KEYS = new Set(CLUEBASE_OTEL_SDK_SOURCE_REQUIRED_RESOURCE_KEYS);
 const MAX_RESOURCE_VALUE_BYTES = 512;
 export const createFrontendResourceAttributes = (resolved) => ({
@@ -27,7 +27,8 @@ export const toFrontendSourceResource = (resource, deniedKeys = []) => {
     }
     for (const [key, value] of entries) {
         if (!FRONTEND_RESOURCE_KEYS.has(key) ||
-            (isDeniedKey(key, deniedKeys) && !FRONTEND_REQUIRED_RESOURCE_KEYS.has(key))) {
+            (isDeniedKey(key, deniedKeys) &&
+                !FRONTEND_REQUIRED_RESOURCE_KEYS.has(key))) {
             continue;
         }
         if (key === "cluebase.service_type" && value !== "frontend") {

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

@@ -1,7 +1,7 @@
 import { type ExportResult, ExportResultCode } from "@opentelemetry/core";
 import type { ReadableSpan, SpanExporter } from "@opentelemetry/sdk-trace-base";
 import type { CluebaseContext } from "../provider/types.js";
-import type { CollectionPermit } from "./browser-outbox.js";
+import type { CollectionPermit } from "./sdk-core-delivery.js";
 import type { BrowserSourceEvent, BrowserSourceSignalEvent } from "./source-event.js";
 export declare const EXPORT_RESULT_SUCCESS: ExportResultCode;
 export declare const EXPORT_RESULT_FAILED: ExportResultCode;
@@ -30,6 +30,7 @@ export declare class ObservationSourceEventExporter implements SpanExporter {
     private ignoreSpanReason;
     enqueue(event: BrowserSourceSignalEvent): void;
     export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    private exportAsync;
     forceFlush(): Promise<void>;
     shutdown(): Promise<void>;
     internalMetrics(): {

package/dist/exporter/observation-source-event-exporter.js

@@ -15,7 +15,7 @@ export class ObservationSourceEventExporter {
         this.shutdownImpl = options.shutdownImpl;
         this.getContext = options.getContext;
         this.deniedKeys = options.deniedKeys ?? [];
-        this.ignoreUrlPrefixes = (options.ignoreUrlPrefixes ?? []).filter((p) => typeof p === "string" && p.length > 0);
+        this.ignoreUrlPrefixes = options.ignoreUrlPrefixes ?? [];
     }
     ignoreSpanReason(span) {
         const spanFields = span;
@@ -30,7 +30,7 @@ export class ObservationSourceEventExporter {
                 ? fullUrl
                 : undefined;
         if (url &&
-            this.ignoreUrlPrefixes.some((prefix) => url.startsWith(prefix))) {
+            this.ignoreUrlPrefixes.some((prefix) => prefix.length > 0 && url.startsWith(prefix))) {
             return "loop";
         }
         if (!Object.keys(attrs).some((key) => key.startsWith("cluebase."))) {
@@ -55,6 +55,9 @@ export class ObservationSourceEventExporter {
             });
             return;
         }
+        void this.exportAsync(spans, resultCallback);
+    }
+    async exportAsync(spans, resultCallback) {
         try {
             const context = this.getContext();
             for (const span of spans) {
@@ -71,7 +74,7 @@ export class ObservationSourceEventExporter {
                         this.droppedSpanCount += 1;
                         continue;
                     }
-                    const sourceSignal = spanToSourceSignalEvent(span, {
+                    const sourceSignal = await spanToSourceSignalEvent(span, {
                         context,
                         deniedKeys: this.deniedKeys,
                     });
@@ -85,7 +88,7 @@ export class ObservationSourceEventExporter {
                     });
                 }
             }
-            void this.flushImpl()
+            await this.flushImpl()
                 .then(() => resultCallback({ code: ExportResultCode.SUCCESS }))
                 .catch((cause) => resultCallback({
                 code: ExportResultCode.FAILED,

package/dist/exporter/path-template.js

@@ -56,7 +56,9 @@ export const toPathTemplate = (pathname) => {
     }
     const normalizedPath = pathname.startsWith("/") ? pathname : `/${pathname}`;
     const [pathOnly] = normalizedPath.split("?");
-    const rawSegments = pathOnly.split("/").filter((segment) => segment.length > 0);
+    const rawSegments = pathOnly
+        .split("/")
+        .filter((segment) => segment.length > 0);
     const segments = rawSegments.map((segment, index) => shouldTemplateSegment(segment, rawSegments[index - 1] ?? null)
         ? ":id"
         : segment);

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

@@ -2,8 +2,8 @@ import { CLUEBASE_CORRELATION_ATTRIBUTE_KEYS } from "../_generated/correlation-a
 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 { isDeniedKey } from "./sanitize.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}$/;
@@ -236,7 +236,8 @@ export function rawEventToSourceSignalEvent(raw, options) {
         if (viewId)
             attributes["cluebase.view.id"] = viewId;
         if (failureType) {
-            attributes[cluebaseAuthoredPropertyAttribute("failure_type")] = failureType;
+            attributes[cluebaseAuthoredPropertyAttribute("failure_type")] =
+                failureType;
         }
         if (outcomeClass)
             attributes["cluebase.outcome_class"] = outcomeClass;
@@ -291,6 +292,7 @@ export function rawEventToSourceSignalEvent(raw, options) {
             attributes,
             events: [],
             resource: toFrontendSourceResource(options.resource, options.deniedKeys),
+            raw_resource: toFrontendSourceResource(options.resource, options.deniedKeys),
             context: contextRecord(context, {
                 session_id: sessionId,
                 trace_id: traceId,

package/dist/exporter/sanitize.d.ts

@@ -1,4 +1,5 @@
-import { detectIdentityPII } from "../_generated/identity-pii-policy.js";
+import { detectTextContainsPII } from "../_generated/identity-pii-policy-text-contains.js";
+import { detectWholeValuePII } from "../_generated/identity-pii-policy-whole-value.js";
 export type SanitizationAccumulator = {
     maskedValueCount: number;
     droppedFieldCount: number;
@@ -15,5 +16,5 @@ export declare const parseUrlForNetwork: (rawUrl: string) => {
     urlMaskedQuery: string;
 };
 export declare const maybeParseJson: (value: unknown) => unknown;
-export { detectIdentityPII };
+export { detectTextContainsPII, detectWholeValuePII };
 export declare const hashIdentityValue: (value: string) => string;

package/dist/exporter/sanitize.js

@@ -1,6 +1,7 @@
 import { sha256 } from "@noble/hashes/sha256";
 import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils";
-import { detectIdentityPII, PII_HASH_HEX_LENGTH, PII_HASH_PREFIX, } from "../_generated/identity-pii-policy.js";
+import { detectTextContainsPII, PII_HASH_HEX_LENGTH, PII_HASH_PREFIX, } from "../_generated/identity-pii-policy-text-contains.js";
+import { detectWholeValuePII } from "../_generated/identity-pii-policy-whole-value.js";
 import { isDeniedLookupKey, toDeniedLookupKeySet, } from "../_generated/ingest-privacy-tables.js";
 import { toPathTemplate } from "../exporter/path-template.js";
 import { ALWAYS_DENIED_KEYS, MASKED_VALUE, MAX_SANITIZE_DEPTH, } from "../provider/constants.js";
@@ -67,7 +68,7 @@ export const sanitizeObject = (value, deniedKeys = [], summary, pathPrefix = "",
         if (maskIdentityPii &&
             !preserveExplicitTraits &&
             typeof current === "string" &&
-            detectIdentityPII(current) !== null) {
+            detectTextContainsPII(current) !== null) {
             if (current === MASKED_VALUE)
                 return current;
             if (summary) {
@@ -140,5 +141,5 @@ export const maybeParseJson = (value) => {
         return null;
     }
 };
-export { detectIdentityPII };
+export { detectTextContainsPII, detectWholeValuePII };
 export const hashIdentityValue = (value) => `${PII_HASH_PREFIX}${bytesToHex(sha256(utf8ToBytes(value))).slice(0, PII_HASH_HEX_LENGTH)}`;

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

@@ -0,0 +1,225 @@
+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 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

@@ -0,0 +1,11 @@
+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 spanToObservationSourceEventJson: (spanJson: string, optionsJson: string) => string;
+export declare const deliveryCommandJson: (requestJson: string) => string;
+export type IngestEndpointDescription = {
+    readonly ingestBatchUrl: string;
+    readonly browserTokenUrl: string;
+};
+export declare const describeIngestEndpoint: (endpoint: string) => Promise<IngestEndpointDescription>;

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

@@ -0,0 +1,39 @@
+import init, { deliveryCommandJson as wasmDeliveryCommandJson, spanToObservationSourceEventJson as wasmSpanToObservationSourceEventJson, } from "../wasm/pkg-web/cluebase_sdk_core_wasm.js";
+let readyPromise = null;
+let ready = false;
+export const initSdkCoreWasm = (input) => {
+    if (!readyPromise) {
+        readyPromise = init(input).then(() => {
+            ready = true;
+        });
+    }
+    return readyPromise;
+};
+export const isSdkCoreWasmReady = () => ready;
+const requireReady = () => {
+    if (!ready) {
+        throw new Error("cluebase sdk core wasm is not initialized; call initSdkCoreWasm() first");
+    }
+};
+export const spanToObservationSourceEventJson = (spanJson, optionsJson) => {
+    requireReady();
+    return wasmSpanToObservationSourceEventJson(spanJson, optionsJson);
+};
+export const deliveryCommandJson = (requestJson) => {
+    requireReady();
+    return wasmDeliveryCommandJson(requestJson);
+};
+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;
@@ -61,6 +62,7 @@ export type BrowserSdkSignal = {
         attributes: Record<string, CanonicalJsonValue>;
     }>;
     resource: Record<string, CanonicalJsonValue>;
+    raw_resource: Record<string, CanonicalJsonValue>;
     context: BrowserSdkSignalContext;
 };
 export type BrowserSourceSignalEvent = {
@@ -98,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)) {