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

package/dist/exporter/delivery-response.js

@@ -1,143 +1,72 @@
-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 }),
+        ...(decision.sdk_encryption === undefined
+            ? {}
+            : { sdkEncryption: decision.sdk_encryption }),
+        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/parameter-encryption.d.ts

@@ -0,0 +1,10 @@
+import { type ParameterValueFact } from "./sdk-core-wasm.js";
+export declare const parameterValueFact: (value: unknown) => ParameterValueFact;
+export declare const beginParameterCaptureDecision: (key: string, value: unknown) => string;
+export declare const canEncryptParameters: () => boolean;
+export declare const beginParameterEncryption: (plaintext: string) => {
+    handle: string;
+    keyVersion: number;
+} | null;
+export declare const settleParameterCaptureDecisions: (node: unknown) => void;
+export declare const settlePendingEncryptions: <T>(value: T) => Promise<T>;

package/dist/exporter/parameter-encryption.js

@@ -0,0 +1,219 @@
+import { currentSdkEncryption, } from "../provider/sdk-encryption-store.js";
+import { decideParameterCaptures, } from "./sdk-core-wasm.js";
+const PENDING_PREFIX = "cbenc~";
+const PENDING_DECISION_PREFIX = "cbdec~";
+const MAX_PENDING_ENCRYPTIONS = 1000;
+const pending = new Map();
+const pendingDecisions = new Map();
+const importedKeys = new Map();
+const toBase64 = (bytes) => {
+    let binary = "";
+    for (let index = 0; index < bytes.length; index += 1) {
+        binary += String.fromCharCode(bytes[index] ?? 0);
+    }
+    return btoa(binary);
+};
+const fromBase64 = (text) => {
+    const binary = atob(text);
+    const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+};
+const subtle = () => typeof crypto !== "undefined" && crypto.subtle ? crypto.subtle : null;
+const importPublicKey = (config) => {
+    const cacheKey = `${config.keyVersion}:${config.publicKey}`;
+    const cached = importedKeys.get(cacheKey);
+    if (cached)
+        return cached;
+    const api = subtle();
+    const imported = api
+        ? api
+            .importKey("spki", fromBase64(config.publicKey), { name: "RSA-OAEP", hash: "SHA-256" }, false, ["encrypt"])
+            .catch(() => null)
+        : Promise.resolve(null);
+    importedKeys.set(cacheKey, imported);
+    return imported;
+};
+const encryptNow = async (config, plaintext) => {
+    const api = subtle();
+    const bytes = new TextEncoder().encode(plaintext);
+    try {
+        const key = await importPublicKey(config);
+        if (!api || !key)
+            return null;
+        const encrypted = await api.encrypt({ name: "RSA-OAEP" }, key, bytes);
+        return {
+            keyVersion: config.keyVersion,
+            ciphertext: toBase64(new Uint8Array(encrypted)),
+        };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        bytes.fill(0);
+    }
+};
+const newHandle = (prefix) => {
+    const random = new Uint8Array(12);
+    crypto.getRandomValues(random);
+    return `${prefix}${toBase64(random).replace(/[^A-Za-z0-9]/g, "")}`;
+};
+export const parameterValueFact = (value) => {
+    if (typeof value === "boolean")
+        return { type: "boolean" };
+    if (typeof value === "number")
+        return { type: "number", number: value };
+    if (typeof value === "string")
+        return { type: "text", text: value };
+    return { type: "other" };
+};
+export const beginParameterCaptureDecision = (key, value) => {
+    const handle = newHandle(PENDING_DECISION_PREFIX);
+    if (pendingDecisions.size >= MAX_PENDING_ENCRYPTIONS) {
+        const oldest = pendingDecisions.keys().next().value;
+        if (oldest !== undefined)
+            pendingDecisions.delete(oldest);
+    }
+    pendingDecisions.set(handle, {
+        key,
+        value,
+        fact: parameterValueFact(value),
+    });
+    return handle;
+};
+export const canEncryptParameters = () => currentSdkEncryption() !== null && subtle() !== null;
+export const beginParameterEncryption = (plaintext) => {
+    const config = currentSdkEncryption();
+    if (!config || !subtle())
+        return null;
+    const handle = newHandle(PENDING_PREFIX);
+    if (pending.size >= MAX_PENDING_ENCRYPTIONS) {
+        const oldest = pending.keys().next().value;
+        if (oldest !== undefined)
+            pending.delete(oldest);
+    }
+    pending.set(handle, encryptNow(config, plaintext));
+    return { handle, keyVersion: config.keyVersion };
+};
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const MASKED_FALLBACK = "__cluebase_masked__";
+const settleLeaf = async (leaf) => {
+    const handle = leaf.ciphertext;
+    if (typeof handle !== "string" || !handle.startsWith(PENDING_PREFIX))
+        return;
+    const result = await pending.get(handle);
+    pending.delete(handle);
+    if (result) {
+        leaf.key_version = result.keyVersion;
+        leaf.ciphertext = result.ciphertext;
+        return;
+    }
+    leaf.capture_mode = "masked_fingerprint";
+    leaf.value = MASKED_FALLBACK;
+    delete leaf.key_version;
+    delete leaf.ciphertext;
+};
+const collectPendingDecisionLeaves = (node, found) => {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            collectPendingDecisionLeaves(child, found);
+        return;
+    }
+    if (!isRecord(node))
+        return;
+    const handle = node.ciphertext;
+    if (typeof handle === "string" &&
+        handle.startsWith(PENDING_DECISION_PREFIX)) {
+        found.push({ leaf: node, handle });
+        return;
+    }
+    for (const child of Object.values(node)) {
+        collectPendingDecisionLeaves(child, found);
+    }
+};
+const applyCaptureDecision = (leaf, value, decision) => {
+    if (decision === "plain") {
+        leaf.value = value;
+        leaf.capture_mode = "plain";
+        return;
+    }
+    if (decision !== "encrypt" || typeof value !== "string")
+        return;
+    const encryption = beginParameterEncryption(value);
+    if (!encryption)
+        return;
+    leaf.capture_mode = "encrypted";
+    leaf.key_version = encryption.keyVersion;
+    leaf.ciphertext = encryption.handle;
+};
+export const settleParameterCaptureDecisions = (node) => {
+    const leaves = [];
+    collectPendingDecisionLeaves(node, leaves);
+    if (leaves.length === 0)
+        return;
+    const requested = leaves.map(({ handle }) => pendingDecisions.get(handle));
+    const decisions = decideParameterCaptures(requested
+        .filter((entry) => entry !== undefined)
+        .map(({ key, fact }) => ({ key, value: fact })));
+    let answered = 0;
+    for (const [index, { leaf, handle }] of leaves.entries()) {
+        delete leaf.ciphertext;
+        pendingDecisions.delete(handle);
+        const entry = requested[index];
+        if (entry === undefined)
+            continue;
+        applyCaptureDecision(leaf, entry.value, decisions[answered]);
+        answered += 1;
+    }
+};
+const settleTree = async (node) => {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            await settleTree(child);
+        return;
+    }
+    if (!isRecord(node))
+        return;
+    if (node.capture_mode === "encrypted") {
+        await settleLeaf(node);
+        return;
+    }
+    for (const child of Object.values(node))
+        await settleTree(child);
+};
+const settleText = async (text) => {
+    if (!text.includes(PENDING_PREFIX) &&
+        !text.includes(PENDING_DECISION_PREFIX)) {
+        return text;
+    }
+    try {
+        const parsed = JSON.parse(text);
+        settleParameterCaptureDecisions(parsed);
+        await settleTree(parsed);
+        return JSON.stringify(parsed);
+    }
+    catch {
+        return text;
+    }
+};
+export const settlePendingEncryptions = async (value) => {
+    if (typeof value === "string")
+        return (await settleText(value));
+    if (Array.isArray(value)) {
+        const settled = [];
+        for (const child of value)
+            settled.push(await settlePendingEncryptions(child));
+        return settled;
+    }
+    if (isRecord(value)) {
+        const settled = {};
+        for (const [key, child] of Object.entries(value)) {
+            settled[key] = await settlePendingEncryptions(child);
+        }
+        return settled;
+    }
+    return value;
+};

package/dist/exporter/parameter-snapshot.js

@@ -1,7 +1,9 @@
 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 { beginParameterCaptureDecision, canEncryptParameters, settleParameterCaptureDecisions, } from "./parameter-encryption.js";
 import { isDeniedKey } from "./sanitize.js";
+import { isSdkCoreWasmReady } from "./sdk-core-wasm.js";
 const SNAPSHOT_UNAVAILABLE_KEY = "_cluebase_snapshot_unavailable";
 const normalizeParameterLookupPath = (path) => {
     return path.replace(/\[\d+\]/g, "[]");
@@ -60,6 +62,19 @@ const buildLeaf = (value, captureMode, released = false) => {
             : {}),
     };
 };
+const leafKeyOf = (path) => {
+    const trimmed = path.replace(/(?:\[\])+$/, "");
+    return trimmed.slice(trimmed.lastIndexOf(".") + 1);
+};
+const buildClassifiedLeaf = (path, value) => {
+    const masked = buildLeaf(value, PARAMETER_CAPTURE_MODE.maskedFingerprint);
+    if (!path)
+        return masked;
+    return {
+        ...masked,
+        ciphertext: beginParameterCaptureDecision(leafKeyOf(path), value),
+    };
+};
 export const buildUnavailableParameterSnapshot = () => ({
     [SNAPSHOT_UNAVAILABLE_KEY]: buildLeaf("snapshot_unavailable", PARAMETER_CAPTURE_MODE.maskedFingerprint),
 });
@@ -173,10 +188,15 @@ export const buildParameterSnapshotBundle = (value, options) => {
         const matchedAllowedPath = path
             ? (allowedPathLookup.get(normalizeParameterLookupPath(path)) ?? null)
             : null;
-        const captureMode = PARAMETER_CAPTURE_MODE.maskedFingerprint;
+        if (matchedAllowedPath !== null && !canEncryptParameters()) {
+            return {
+                snapshot: buildLeaf(current, PARAMETER_CAPTURE_MODE.maskedFingerprint, true),
+                allowedValueKeys: [matchedAllowedPath],
+            };
+        }
         return {
-            snapshot: buildLeaf(current, captureMode, matchedAllowedPath !== null),
-            allowedValueKeys: matchedAllowedPath ? [matchedAllowedPath] : [],
+            snapshot: buildClassifiedLeaf(path, current),
+            allowedValueKeys: [],
         };
     };
     const rootBundle = walk(value, rootPathPrefix, 0);
@@ -185,6 +205,8 @@ export const buildParameterSnapshotBundle = (value, options) => {
         !Array.isArray(rootBundle.snapshot)
         ? rootBundle.snapshot
         : {};
+    if (isSdkCoreWasmReady())
+        settleParameterCaptureDecisions(snapshot);
     return {
         snapshot,
         allowedValueKeys: [...new Set(rootBundle.allowedValueKeys)].sort(),