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

package/dist/_generated/correlation-attribute-keys.js

@@ -11,6 +11,7 @@ export const CLUEBASE_CORRELATION_ATTRIBUTE_KEYS = new Set([
     "cluebase.actor.user_id",
     "cluebase.action.id",
     "cluebase.action_id",
+    "cluebase.entity_id_masked",
     "cluebase.interaction.id",
     "cluebase.interaction_id",
     "cluebase.organization.id",

package/dist/exporter/batch.js

@@ -1,9 +1,11 @@
 import { DEFAULT_CONFIG } from "../provider/constants.js";
 import { applyDeliveredPrivacyPolicy, resetPrivacyPolicy, } from "../provider/privacy-policy-store.js";
+import { applyDeliveredSdkEncryption, resetSdkEncryption, } from "../provider/sdk-encryption-store.js";
 import { BrowserOutbox } from "./browser-outbox.js";
 import { ownEvent, sentByteLength } from "./browser-outbox-records.js";
 import { DeliveryPipeline, } from "./delivery-pipeline.js";
 import { DiagnosticStore } from "./diagnostics.js";
+import { settlePendingEncryptions } from "./parameter-encryption.js";
 const CLOSE_DEADLINE_MS = 5000;
 const CORE_CONSENT = {
     unknown: "unknown",
@@ -112,9 +114,10 @@ export class BatchTransport {
         }
         const snapshot = owned.value();
         void this.queueOutboxMutation(async () => {
+            const settled = await settlePendingEncryptions(snapshot);
             const draft = await this.outbox.withDeliveryLock(async () => {
                 this.adoptStoredRecords();
-                return this.outbox.holdDraft(snapshot);
+                return this.outbox.holdDraft(settled);
             });
             if (!draft) {
                 this.metrics?.increment("dropped_count");
@@ -311,6 +314,10 @@ export class BatchTransport {
         }
         else if (observation.directiveUnreadable) {
             resetPrivacyPolicy();
+            resetSdkEncryption();
+        }
+        if (observation.sdkEncryption !== undefined) {
+            applyDeliveredSdkEncryption(observation.sdkEncryption);
         }
         const progress = observation.progress;
         if (progress.kind !== "retry_scheduled") {

package/dist/exporter/client.js

@@ -1,6 +1,7 @@
 import { canonicalize as canonicalJsonStringify } from "json-canonicalize";
 import { CONSENT_DENIED_ABORT_REASON, DEFAULT_FRONTEND_SOURCE_IDENTIFIER, } from "../provider/constants.js";
 import { appliedPrivacyPolicyToken } from "../provider/privacy-policy-store.js";
+import { currentSdkEncryption } from "../provider/sdk-encryption-store.js";
 import { classifyIngestHttpStatus, } from "./delivery-response.js";
 import { generateBatchId } from "./event-id.js";
 import { describeIngestEndpoint, } from "./sdk-core-wasm.js";
@@ -109,6 +110,7 @@ export class IngestClient {
             idempotencyKey: metadata.idempotency_key,
             sentAt: metadata.sent_at,
             privacyPolicyToken: appliedPrivacyPolicyToken(),
+            sdkEncryptionKeyVersion: currentSdkEncryption()?.keyVersion,
             producerMetadata: {
                 producer_id: this.producerId,
                 sdk_type: this.sdkType,

package/dist/exporter/delivery-pipeline.d.ts

@@ -31,6 +31,7 @@ export type DeliveryObservation = {
     readonly httpStatus: number | null;
     readonly reason: string | null;
     readonly privacyPolicy?: unknown;
+    readonly sdkEncryption?: unknown;
     readonly directiveUnreadable: boolean;
     readonly diagnosticCodes: readonly DiagnosticCode[];
 };

package/dist/exporter/delivery-pipeline.js

@@ -190,6 +190,9 @@ const observe = (report) => {
         ...(report.decision?.privacy_policy === undefined
             ? {}
             : { privacyPolicy: report.decision.privacy_policy }),
+        ...(report.decision?.sdk_encryption === undefined
+            ? {}
+            : { sdkEncryption: report.decision.sdk_encryption }),
         directiveUnreadable: report.decision?.directive_unreadable === true,
         diagnosticCodes: report.decision?.diagnostic_codes ?? [],
     };

package/dist/exporter/delivery-response-contract.d.ts

@@ -20,4 +20,8 @@ export declare const ingestPrivacyPolicySchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type IngestPrivacyPolicy = z.output<typeof ingestPrivacyPolicySchema>;
+export declare const ingestSdkEncryptionSchema: z.ZodObject<{
+    key_version: z.ZodNumber;
+    public_key: z.ZodString;
+}, z.core.$strict>;
 export {};

package/dist/exporter/delivery-response-contract.js

@@ -21,3 +21,9 @@ export const ingestPrivacyPolicySchema = z
         .max(500),
 })
     .strict();
+export const ingestSdkEncryptionSchema = z
+    .object({
+    key_version: z.number().int().positive(),
+    public_key: z.string().trim().min(1).max(2048),
+})
+    .strict();

package/dist/exporter/delivery-response.d.ts

@@ -5,6 +5,7 @@ export type { IngestRetryStrategy } from "./delivery-response-contract.js";
 export type BrowserDeliveryDecision = {
     readonly ok: boolean;
     readonly privacyPolicy?: unknown;
+    readonly sdkEncryption?: unknown;
     readonly directiveUnreadable: boolean;
     readonly retryStrategy: IngestRetryStrategy | null;
     readonly observationIngestBatchId?: string;

package/dist/exporter/delivery-response.js

@@ -37,6 +37,9 @@ const project = (decision) => {
         ...(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,

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(),

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

@@ -181,6 +181,7 @@ export type DeliveryDecision = {
     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 = {

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

@@ -4,6 +4,23 @@ export declare const initSdkCoreWasm: (input?: SdkCoreWasmInitInput) => Promise<
 export declare const isSdkCoreWasmReady: () => boolean;
 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;

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

@@ -1,4 +1,4 @@
-import init, { deliveryCommandJson as wasmDeliveryCommandJson, spanToObservationSourceEventJson as wasmSpanToObservationSourceEventJson, } 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) => {
@@ -23,6 +23,13 @@ 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();

package/dist/provider/_version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION: "0.0.8";
+export declare const SDK_VERSION: "0.0.10";

package/dist/provider/_version.js

@@ -1,3 +1,3 @@
 // This file is generated by scripts/generate-version-module.mjs.
 // Do NOT edit by hand. The source of truth is `package.json` `version`.
-export const SDK_VERSION = "0.0.8";
+export const SDK_VERSION = "0.0.10";

package/dist/provider/contracts.d.ts

@@ -47,5 +47,7 @@ export declare const PARAMETER_CAPTURE_MODE: {
     readonly maskedFingerprint: "masked_fingerprint";
     readonly forbidden: "forbidden";
     readonly truncated: "truncated";
+    readonly encrypted: "encrypted";
+    readonly plain: "plain";
 };
 export type ParameterCaptureMode = (typeof PARAMETER_CAPTURE_MODE)[keyof typeof PARAMETER_CAPTURE_MODE];

package/dist/provider/contracts.js

@@ -43,4 +43,6 @@ export const PARAMETER_CAPTURE_MODE = {
     maskedFingerprint: "masked_fingerprint",
     forbidden: "forbidden",
     truncated: "truncated",
+    encrypted: "encrypted",
+    plain: "plain",
 };

package/dist/provider/sdk-encryption-store.d.ts

@@ -0,0 +1,7 @@
+export type SdkEncryptionConfig = {
+    readonly keyVersion: number;
+    readonly publicKey: string;
+};
+export declare const applyDeliveredSdkEncryption: (value: unknown) => void;
+export declare const resetSdkEncryption: () => void;
+export declare const currentSdkEncryption: () => SdkEncryptionConfig | null;

package/dist/provider/sdk-encryption-store.js

@@ -0,0 +1,15 @@
+import { ingestSdkEncryptionSchema } from "../exporter/delivery-response-contract.js";
+let appliedEncryption = null;
+export const applyDeliveredSdkEncryption = (value) => {
+    const parsed = ingestSdkEncryptionSchema.safeParse(value);
+    appliedEncryption = parsed.success
+        ? {
+            keyVersion: parsed.data.key_version,
+            publicKey: parsed.data.public_key,
+        }
+        : null;
+};
+export const resetSdkEncryption = () => {
+    appliedEncryption = null;
+};
+export const currentSdkEncryption = () => appliedEncryption;

package/dist/provider/types.d.ts

@@ -137,6 +137,8 @@ export type ParameterSnapshotLeaf = {
     capture_mode: ParameterCaptureMode;
     truncated_reason?: "max_event_bytes";
     original_size_bytes?: number;
+    key_version?: number;
+    ciphertext?: string;
 };
 export type ParameterSnapshotValue = ParameterSnapshotLeaf | ParameterSnapshotValue[] | {
     [key: string]: ParameterSnapshotValue;

package/dist/wasm/pkg-web/cluebase_sdk_core_wasm.d.ts

@@ -3,6 +3,10 @@
 
 export function deliveryCommandJson(request_json: string): string;
 
+export function isCompleteAcceptedJson(result_json: string): boolean;
+
+export function parameterCaptureDecisionsJson(request_json: string): string;
+
 export function spanToObservationSourceEventJson(span_json: string, options_json: string): string;
 
 export function spanToSdkSignalJson(span_json: string, options_json: string): string;
@@ -12,6 +16,8 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly deliveryCommandJson: (a: number, b: number, c: number) => void;
+    readonly isCompleteAcceptedJson: (a: number, b: number, c: number) => void;
+    readonly parameterCaptureDecisionsJson: (a: number, b: number, c: number) => void;
     readonly spanToObservationSourceEventJson: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly spanToSdkSignalJson: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly __wbindgen_export: (a: number) => void;

package/dist/wasm/pkg-web/cluebase_sdk_core_wasm.js

@@ -31,6 +31,59 @@ export function deliveryCommandJson(request_json) {
     }
 }
 
+/**
+ * @param {string} result_json
+ * @returns {boolean}
+ */
+export function isCompleteAcceptedJson(result_json) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(result_json, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.isCompleteAcceptedJson(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return r0 !== 0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @param {string} request_json
+ * @returns {string}
+ */
+export function parameterCaptureDecisionsJson(request_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.parameterCaptureDecisionsJson(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * @param {string} span_json
  * @param {string} options_json

package/dist/wasm/pkg-web/cluebase_sdk_core_wasm_bg.wasm.d.ts

@@ -2,6 +2,8 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const deliveryCommandJson: (a: number, b: number, c: number) => void;
+export const isCompleteAcceptedJson: (a: number, b: number, c: number) => void;
+export const parameterCaptureDecisionsJson: (a: number, b: number, c: number) => void;
 export const spanToObservationSourceEventJson: (a: number, b: number, c: number, d: number, e: number) => void;
 export const spanToSdkSignalJson: (a: number, b: number, c: number, d: number, e: number) => void;
 export const __wbindgen_export: (a: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@genn-inc/cluebase-frontend-sdk",
-	"version": "0.0.8",
+	"version": "0.0.10",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/genn-inc/cluebase.git"