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

package/dist/exporter/delivery-response.js

@@ -1,143 +1,69 @@
-import { parseGovernorFeedbackEnvelope } from "../provider/usage-governor.js";
-import { observationSourceEventBatchResponseSchema, } from "./delivery-response-contract.js";
-export const BROWSER_REJECTION_STRATEGIES = {
-    invalid_request: "stop_and_report",
-    unsupported_source_schema_version: "stop_and_report",
-    missing_project_key: "stop_and_report",
-    project_key_mismatch: "stop_and_report",
-    unresolved_project_or_environment: "stop_and_report",
-    missing_browser_token: "stop_and_report",
-    invalid_browser_token: "stop_and_report",
-    expired_browser_token: "retry_same_batch",
-    stale_browser_token: "retry_same_batch",
-    origin_not_allowed: "stop_and_report",
-    authorization_denied: "stop_and_report",
-    idempotency_conflict: "mark_failed",
-    batch_too_large: "split_batch",
-    all_events_dropped: "drop_event",
-    usage_governor_denied: "retry_same_batch",
-    all_events_rejected_by_ingest_controls: "retry_same_batch",
-    route_throttled: "retry_same_batch",
-    raw_ingest_produce_failed: "retry_same_batch",
-    raw_ingest_ack_unknown: "retry_same_batch",
-    raw_ingest_receipt_metadata_failed: "retry_same_batch",
-    raw_ingest_receipt_unprocessable: "stop_and_report",
-    ingest_config_changed_retryable: "retry_same_batch",
-    usage_meter_unavailable: "retry_same_batch",
+import { evaluateResponse, } from "./sdk-core-delivery.js";
+const RETRY_STRATEGY_BY_OUTCOME = {
+    accepted_complete: null,
+    accepted_filtered: null,
+    accepted_partial: null,
+    retry_same_batch: "retry_same_batch",
+    split_batch: "split_batch",
+    terminal_stop: "stop_and_report",
+    terminal_failed: "mark_failed",
+    terminal_drop: "drop_event",
+    invalid_response: "retry_same_batch",
 };
-export const evaluateBrowserDeliveryResponse = (input) => {
-    const decoded = decode(input.bodyText);
-    if (decoded !== null && hasAcceptedDiscriminator(decoded)) {
-        const parsed = observationSourceEventBatchResponseSchema.safeParse(decoded);
-        if (parsed.success &&
-            submittedCountMatches(parsed.data, input.localSubmittedCount) &&
-            hasPublicDropDetails(parsed.data)) {
-            if (parsed.data.accepted) {
-                if (input.status < 200 || input.status >= 300) {
-                    return invalidResponse();
-                }
-                const partial = parsed.data.dropped_event_count > 0;
-                const diagnosticCodes = [];
-                if (partial) {
-                    diagnosticCodes.push(parsed.data.dropped_events.length > 0
-                        ? "intentional_drop"
-                        : "duplicate_drop_details_unavailable");
-                }
-                if (input.status !== 202) {
-                    diagnosticCodes.push("non_canonical_success_status");
-                }
-                return {
-                    ok: true,
-                    retryStrategy: null,
-                    privacyPolicy: parsed.data.privacy_policy,
-                    governor: parseGovernorFeedbackEnvelope(parsed.data),
-                    observationIngestBatchId: parsed.data.observation_ingest_batch_id,
-                    droppedEventCount: parsed.data.dropped_event_count,
-                    acceptedEventCount: parsed.data.accepted_event_count,
-                    acceptedPartial: partial,
-                    reason: partial ? "accepted_partial" : null,
-                    diagnosticCodes,
-                };
-            }
-            if (BROWSER_REJECTION_STRATEGIES[parsed.data.reason] !==
-                parsed.data.retry_strategy) {
-                return invalidResponse();
-            }
-            return {
-                ok: false,
-                retryStrategy: parsed.data.retry_strategy,
-                governor: null,
-                droppedEventCount: parsed.data.dropped_event_count ?? 0,
-                acceptedEventCount: parsed.data.accepted_event_count ?? 0,
-                acceptedPartial: false,
-                reason: parsed.data.reason,
-                diagnosticCodes: [],
-            };
-        }
-        return invalidResponse();
+const ACCEPTED_OUTCOMES = new Set([
+    "accepted_complete",
+    "accepted_filtered",
+    "accepted_partial",
+]);
+export const evaluateBrowserDeliveryResponse = (input) => translate({ kind: "response", status: input.status, body: input.bodyText }, input.localSubmittedCount);
+export const evaluateBrowserTransportOutcome = (outcome) => translate(outcome, 1);
+export const classifyIngestHttpStatus = (status) => translate({ kind: "response", status, body: "" }, 1).retryStrategy ??
+    "retry_same_batch";
+const translate = (outcome, localSubmittedCount) => {
+    const evaluation = evaluateResponse(outcome, localSubmittedCount);
+    if (evaluation.kind !== "decision") {
+        return consentRevoked();
     }
-    return fallback(input.status);
+    return project(evaluation.decision);
 };
-const submittedCountMatches = (value, localSubmittedCount) => value.submitted_event_count === undefined ||
-    value.submitted_event_count === localSubmittedCount;
-const hasPublicDropDetails = (value) => (value.dropped_events ?? []).every((detail) => detail.source_event_payload_fingerprint === null);
-const decode = (bodyText) => {
-    if (!bodyText.trim())
-        return null;
-    try {
-        return JSON.parse(bodyText);
-    }
-    catch {
-        return null;
-    }
+const project = (decision) => {
+    const accepted = ACCEPTED_OUTCOMES.has(decision.outcome);
+    const batchId = decision.result.observation_ingest_batch_id;
+    return {
+        ok: accepted,
+        retryStrategy: accepted
+            ? null
+            : (RETRY_STRATEGY_BY_OUTCOME[decision.outcome] ?? "retry_same_batch"),
+        ...(decision.privacy_policy === undefined
+            ? {}
+            : { privacyPolicy: decision.privacy_policy }),
+        directiveUnreadable: decision.directive_unreadable === true,
+        ...(batchId === undefined ? {} : { observationIngestBatchId: batchId }),
+        droppedEventCount: decision.result.dropped_event_count ?? 0,
+        acceptedEventCount: decision.result.accepted_event_count ?? 0,
+        acceptedPartial: decision.outcome === "accepted_partial",
+        acceptedFiltered: decision.outcome === "accepted_filtered",
+        reason: reasonOf(decision),
+        diagnosticCodes: decision.diagnostic_codes,
+    };
 };
-const hasAcceptedDiscriminator = (value) => value !== null &&
-    typeof value === "object" &&
-    !Array.isArray(value) &&
-    Object.prototype.hasOwnProperty.call(value, "accepted");
-const invalidResponse = () => ({
-    ok: false,
-    retryStrategy: "retry_same_batch",
-    governor: null,
-    droppedEventCount: 0,
-    acceptedEventCount: 0,
-    acceptedPartial: false,
-    reason: "invalid_response",
-    diagnosticCodes: ["invalid_response"],
-});
-export const classifyIngestHttpStatus = (status) => {
-    if (status >= 200 && status < 300)
-        return "retry_same_batch";
-    if (status === 409)
-        return "mark_failed";
-    if (status === 413)
-        return "split_batch";
-    if ([400, 401, 403, 404, 405, 406, 410, 415].includes(status)) {
-        return "stop_and_report";
-    }
-    return "retry_same_batch";
+const reasonOf = (decision) => {
+    if (decision.outcome === "accepted_complete")
+        return null;
+    if (decision.outcome === "accepted_partial")
+        return "accepted_partial";
+    if (decision.outcome === "accepted_filtered")
+        return "accepted_filtered";
+    return decision.result.reason ?? decision.outcome;
 };
-const RETRYABLE_CLIENT_STATUSES = [408, 422, 425, 429];
-const fallback = (status) => ({
+const consentRevoked = () => ({
     ok: false,
-    retryStrategy: classifyIngestHttpStatus(status),
-    governor: null,
+    retryStrategy: "drop_event",
+    directiveUnreadable: false,
     droppedEventCount: 0,
     acceptedEventCount: 0,
     acceptedPartial: false,
-    reason: `http_${status}`,
-    diagnosticCodes: fallbackDiagnosticCodes(status),
+    acceptedFiltered: false,
+    reason: "consent_denied",
+    diagnosticCodes: [],
 });
-const fallbackDiagnosticCodes = (status) => {
-    if (classifyIngestHttpStatus(status) !== "retry_same_batch")
-        return [];
-    if (status >= 200 && status <= 299)
-        return ["invalid_response"];
-    if (status >= 300 && status <= 399)
-        return ["protocol_redirect"];
-    if (status >= 500 && status <= 599)
-        return [];
-    if (RETRYABLE_CLIENT_STATUSES.includes(status))
-        return ["invalid_response"];
-    return ["unknown_status"];
-};

package/dist/exporter/diagnostics.d.ts

@@ -1,5 +1,6 @@
+import { type DiagnosticCode } from "../_generated/diagnostic-codes.js";
 import type { IngestRetryStrategy } from "./delivery-response-contract.js";
-export type DiagnosticCode = "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";
+export type { DiagnosticCode };
 export type DiagnosticLifecycle = "open" | "closing" | "closing_failed" | "closed";
 export type DiagnosticFlushOutcome = "clean" | "failed" | null;
 export type DiagnosticCloseOutcome = "clean" | "retryable_failure" | "terminal_failure" | null;

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",

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

@@ -49,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/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;

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."))) {

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

@@ -2,4 +2,10 @@ 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 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, 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,30 @@ 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 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,
+    };
 };