@clue-ai/browser-sdk 0.0.1

package/dist/normalize/builders.js

@@ -0,0 +1,786 @@
+import { FRONTEND_EVENT_CATEGORY, FRONTEND_EVENT_NAME, FRONTEND_EVENT_STATUS, } from "../core/contracts";
+import { maskMessage, maskUnknown, maskUrl } from "../privacy/mask";
+import { parseUrlForNetwork, sanitizeObject } from "../privacy/sanitize";
+import { buildParameterSnapshotBundle, buildUnavailableParameterSnapshot, truncateParameterSnapshotValue, } from "../privacy/parameter-snapshot";
+import { createCanonicalBaseEvent } from "./canonical";
+const asString = (value) => {
+    return typeof value === "string" ? value : null;
+};
+const asBoolean = (value) => {
+    return typeof value === "boolean" ? value : null;
+};
+const asNumber = (value) => {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+};
+const countCaptureModes = (value) => {
+    const counts = {
+        maskedValueCount: 0,
+        forbiddenValueCount: 0,
+        truncatedValueCount: 0,
+    };
+    const walk = (current) => {
+        if (Array.isArray(current)) {
+            for (const child of current) {
+                walk(child);
+            }
+            return;
+        }
+        if (!current || typeof current !== "object") {
+            return;
+        }
+        const record = current;
+        switch (record.capture_mode) {
+            case "masked_fingerprint":
+                counts.maskedValueCount += 1;
+                return;
+            case "forbidden":
+                counts.forbiddenValueCount += 1;
+                return;
+            case "truncated":
+                counts.truncatedValueCount += 1;
+                return;
+            default:
+                break;
+        }
+        for (const child of Object.values(record)) {
+            walk(child);
+        }
+    };
+    walk(value);
+    return counts;
+};
+const asNonNegativeNumber = (value) => {
+    const numberValue = asNumber(value);
+    return numberValue !== undefined && numberValue >= 0
+        ? Math.round(numberValue)
+        : null;
+};
+const asNonNegativeFinite = (value) => {
+    const numberValue = asNumber(value);
+    return numberValue !== undefined && numberValue >= 0 ? numberValue : null;
+};
+const asRecord = (value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+};
+const asStringArray = (value) => {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((entry) => typeof entry === "string");
+};
+const setJsonStringEvidence = (target, sourceFields, key, sourceField, value) => {
+    const trimmed = value?.trim() ?? "";
+    if (!trimmed) {
+        return;
+    }
+    target[key] = trimmed;
+    sourceFields.push(sourceField);
+};
+const uniqueStrings = (values) => {
+    return [...new Set(values)].sort();
+};
+const buildTargetObjectHintEvidence = (event) => {
+    const sourceFields = [];
+    const actionTarget = {};
+    const requestTarget = {};
+    setJsonStringEvidence(actionTarget, sourceFields, "stable_key", "stable_key", event.stable_key);
+    setJsonStringEvidence(actionTarget, sourceFields, "stable_key_quality", "stable_key_quality", event.stable_key_quality);
+    setJsonStringEvidence(actionTarget, sourceFields, "form_key", "form_key", event.form_key);
+    setJsonStringEvidence(actionTarget, sourceFields, "element_tag", "properties.element_tag", asString(event.properties.element_tag));
+    setJsonStringEvidence(actionTarget, sourceFields, "element_role", "properties.element_role", asString(event.properties.element_role));
+    setJsonStringEvidence(actionTarget, sourceFields, "element_label_candidate", "properties.element_label_candidate", asString(event.properties.element_label_candidate));
+    setJsonStringEvidence(actionTarget, sourceFields, "field_name_candidate", "properties.field_name_candidate", asString(event.properties.field_name_candidate));
+    setJsonStringEvidence(requestTarget, sourceFields, "method", "method", event.method);
+    setJsonStringEvidence(requestTarget, sourceFields, "path_template", "path_template", event.path_template);
+    setJsonStringEvidence(requestTarget, sourceFields, "path", "path", event.path);
+    setJsonStringEvidence(requestTarget, sourceFields, "target_service", "target_service", event.target_service);
+    if (sourceFields.length === 0) {
+        return null;
+    }
+    const hint = {
+        evidence_source: "browser_sdk_local_capture",
+        source_fields: uniqueStrings(sourceFields),
+    };
+    if (Object.keys(actionTarget).length > 0) {
+        hint.action_target = actionTarget;
+    }
+    if (Object.keys(requestTarget).length > 0) {
+        hint.request_target = requestTarget;
+    }
+    return hint;
+};
+const buildBehaviorUnitHintEvidence = (event) => {
+    const sourceFields = ["event_name", "event_category"];
+    const hint = {
+        evidence_source: "browser_sdk_local_capture",
+        source_event_type: event.source_event_type ?? event.event_name,
+        source_event_kind: event.source_event_kind ?? event.event_category,
+    };
+    setJsonStringEvidence(hint, sourceFields, "interaction_id", "interaction_id", event.interaction_id);
+    setJsonStringEvidence(hint, sourceFields, "request_id", "request_id", event.request_id);
+    setJsonStringEvidence(hint, sourceFields, "request_span_id", "request_span_id", event.request_span_id);
+    setJsonStringEvidence(hint, sourceFields, "request_lifecycle_outcome", "attempt_status", event.attempt_status ?? null);
+    setJsonStringEvidence(hint, sourceFields, "stable_key", "stable_key", event.stable_key);
+    setJsonStringEvidence(hint, sourceFields, "form_key", "form_key", event.form_key);
+    setJsonStringEvidence(hint, sourceFields, "path_template", "path_template", event.path_template);
+    if (sourceFields.length <= 2) {
+        return null;
+    }
+    hint.source_fields = uniqueStrings(sourceFields);
+    return hint;
+};
+const applyLocalHintEvidence = (event) => {
+    const targetObjectHint = buildTargetObjectHintEvidence(event);
+    if (targetObjectHint) {
+        event.target_object_hint = targetObjectHint;
+    }
+    const behaviorUnitHint = buildBehaviorUnitHintEvidence(event);
+    if (behaviorUnitHint) {
+        event.properties.behavior_unit_hint_evidence = behaviorUnitHint;
+    }
+    return event;
+};
+const normalizeRequestLifecycleOutcome = (value) => {
+    switch (value) {
+        case "completed":
+        case "failed":
+        case "aborted":
+        case "unknown":
+            return value;
+        default:
+            return null;
+    }
+};
+const resolveRequestLifecycleOutcome = (input) => {
+    const explicitOutcome = normalizeRequestLifecycleOutcome(input.explicitOutcome);
+    if (explicitOutcome) {
+        return explicitOutcome;
+    }
+    const outcomeClass = input.outcomeClass?.toLowerCase() ?? "";
+    const failureType = input.failureType?.toLowerCase() ?? "";
+    if (outcomeClass === "aborted" || failureType.includes("abort")) {
+        return "aborted";
+    }
+    if (input.isFailed || failureType) {
+        return "failed";
+    }
+    if (typeof input.statusCode === "number") {
+        return input.statusCode >= 400 ? "failed" : "completed";
+    }
+    if (outcomeClass === "success") {
+        return "completed";
+    }
+    if (outcomeClass) {
+        return "failed";
+    }
+    return "unknown";
+};
+const normalizePathLike = (value) => {
+    if (!value) {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+        return parseUrlForNetwork(trimmed).path || "/";
+    }
+    return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+};
+const normalizeFormKey = (value) => {
+    const trimmed = value?.trim() ?? "";
+    return trimmed || null;
+};
+const canonicalizeUrl = (value) => {
+    if (!value) {
+        return null;
+    }
+    try {
+        const url = new URL(value, globalThis.location?.origin);
+        return `${url.origin}${url.pathname}`;
+    }
+    catch {
+        return normalizePathLike(value);
+    }
+};
+const normalizeStableKeyQuality = (value) => {
+    switch (value) {
+        case "official":
+        case "compat":
+        case "structural":
+            return value;
+        default:
+            return null;
+    }
+};
+const inferStableKeyQuality = (stableKey) => {
+    if (!stableKey) {
+        return null;
+    }
+    if (stableKey.startsWith("dtid:") || stableKey.startsWith("dqa:")) {
+        return "compat";
+    }
+    if (stableKey.startsWith("name:") || stableKey.startsWith("aria:")) {
+        return "structural";
+    }
+    if (stableKey.startsWith("struct:")) {
+        return "structural";
+    }
+    if (stableKey.startsWith("id:")) {
+        return "structural";
+    }
+    return null;
+};
+const buildBaseEvent = (input) => {
+    return createCanonicalBaseEvent({
+        eventName: input.eventName,
+        eventCategory: input.eventCategory,
+        status: input.status,
+        context: input.options.context,
+        occurredAtMs: input.raw.occurredAtMs,
+        requestId: input.requestId,
+        requestSpanId: input.requestSpanId,
+        interactionId: input.interactionId ?? asString(input.raw.payload.interactionId),
+        traceId: input.traceId,
+    });
+};
+const setStringProperty = (event, key, value) => {
+    if (value) {
+        event.properties[key] = value;
+    }
+};
+const setUnknownProperty = (event, key, value) => {
+    if (value !== null && value !== undefined) {
+        event.properties[key] = value;
+    }
+};
+const setNumericMetric = (event, key, value) => {
+    if (typeof value === "number") {
+        event.metrics[key] = value;
+    }
+};
+const applySummaryContract = (event, payload) => {
+    event.collector_name = asString(payload.collectorName);
+    event.aggregation_kind = asString(payload.aggregationKind);
+    event.summary_window_ms = asNonNegativeNumber(payload.summaryWindowMs);
+    event.summary_count = asNonNegativeNumber(payload.summaryCount);
+    event.dropped_count = asNonNegativeNumber(payload.droppedCount);
+    event.sample_rate = asNonNegativeFinite(payload.sampleRate);
+    event.budget_window_ms = asNonNegativeNumber(payload.budgetWindowMs);
+    event.rate_limit_key = asString(payload.rateLimitKey);
+    setNumericMetric(event, "summary_count", event.summary_count ?? undefined);
+    setNumericMetric(event, "dropped_count", event.dropped_count ?? undefined);
+    setNumericMetric(event, "sample_rate", event.sample_rate ?? undefined);
+    return event;
+};
+const applyPerformanceSummaryContract = (event, payload) => {
+    event.performance_kind = asString(payload.performanceKind);
+    event.rating = asString(payload.rating);
+    event.metric_name = asString(payload.metricName);
+    event.metric_value_bucket = asString(payload.metricValueBucket);
+    event.long_task_count = asNonNegativeNumber(payload.longTaskCount);
+    event.resource_failure_count = asNonNegativeNumber(payload.resourceFailureCount);
+    event.slow_resource_count = asNonNegativeNumber(payload.slowResourceCount);
+    event.worst_duration_bucket = asString(payload.worstDurationBucket);
+    setStringProperty(event, "performance_kind", event.performance_kind);
+    setStringProperty(event, "rating", event.rating);
+    setStringProperty(event, "metric_name", event.metric_name);
+    setStringProperty(event, "metric_value_bucket", event.metric_value_bucket);
+    setStringProperty(event, "worst_duration_bucket", event.worst_duration_bucket);
+    setStringProperty(event, "load_duration_bucket", asString(payload.loadDurationBucket));
+    setStringProperty(event, "interaction_ready_ms_bucket", asString(payload.interactionReadyMsBucket));
+    setStringProperty(event, "long_task_count_bucket", asString(payload.longTaskCountBucket));
+    setStringProperty(event, "resource_failure_count_bucket", asString(payload.resourceFailureCountBucket));
+    setUnknownProperty(event, "web_vital_buckets", payload.webVitalBuckets);
+    setStringProperty(event, "flush_reason", asString(payload.flushReason));
+    setNumericMetric(event, "long_task_count", event.long_task_count ?? undefined);
+    setNumericMetric(event, "resource_failure_count", event.resource_failure_count ?? undefined);
+    setNumericMetric(event, "slow_resource_count", event.slow_resource_count ?? undefined);
+    return event;
+};
+const readFallbackPageUrl = (payload) => {
+    return (asString(payload.pageUrl) ??
+        asString(payload.url) ??
+        (typeof globalThis.location?.href === "string"
+            ? globalThis.location.href
+            : null));
+};
+const readFallbackPath = (payload) => {
+    return (asString(payload.path) ??
+        asString(payload.route) ??
+        asString(payload.toPath) ??
+        normalizePathLike(asString(payload.pageUrl) ?? asString(payload.url)) ??
+        (typeof globalThis.location?.pathname === "string"
+            ? globalThis.location.pathname
+            : null));
+};
+const applyCurrentPageContext = (event, raw) => {
+    const pageUrl = readFallbackPageUrl(raw.payload);
+    const path = readFallbackPath(raw.payload);
+    if (pageUrl && event.url_canonical == null) {
+        event.url_canonical = canonicalizeUrl(pageUrl);
+    }
+    if (path && event.path == null) {
+        event.path = path;
+    }
+    return event;
+};
+const applySemanticCaptureContract = (event, raw, options) => {
+    const payload = raw.payload;
+    const viewId = asString(payload.viewId);
+    const stableKey = asString(payload.stableKey);
+    const stableKeyQuality = normalizeStableKeyQuality(asString(payload.stableKeyQuality)) ??
+        inferStableKeyQuality(stableKey);
+    const formKey = normalizeFormKey(asString(payload.formKey) ??
+        asString(payload.formId) ??
+        asString(payload.formName));
+    const urlCanonical = canonicalizeUrl(asString(payload.urlCanonical) ??
+        asString(payload.pageUrl) ??
+        asString(payload.url) ??
+        event.url_canonical ??
+        null);
+    const referrerUrlCanonical = canonicalizeUrl(asString(payload.referrerUrlCanonical) ??
+        asString(payload.referrerUrl) ??
+        asString(payload.referrer) ??
+        options.context.referrer);
+    const screenKey = normalizePathLike(asString(payload.screenKey) ??
+        asString(payload.path) ??
+        asString(payload.route) ??
+        asString(payload.toPath)) ?? normalizePathLike(urlCanonical);
+    event.view_id = viewId;
+    event.screen_key = screenKey;
+    event.url_canonical = urlCanonical;
+    event.referrer_url_canonical = referrerUrlCanonical;
+    event.stable_key = stableKey;
+    event.stable_key_quality = stableKeyQuality;
+    event.form_key = formKey;
+    return event;
+};
+const sanitizeForCustomProperties = (value, options) => {
+    try {
+        const sanitized = sanitizeObject(value, options.deniedKeys);
+        if (sanitized &&
+            typeof sanitized === "object" &&
+            !Array.isArray(sanitized)) {
+            const properties = { ...sanitized };
+            delete properties.custom_event_name;
+            delete properties.customEventName;
+            return properties;
+        }
+        return sanitized;
+    }
+    catch (error) {
+        options.onMaskingError?.(error);
+        return {};
+    }
+};
+const buildSessionEvent = (raw, options) => {
+    const payload = raw.payload;
+    const isStart = raw.type === FRONTEND_EVENT_NAME.sessionStarted;
+    const event = buildBaseEvent({
+        raw,
+        eventName: raw.type,
+        eventCategory: FRONTEND_EVENT_CATEGORY.session,
+        status: FRONTEND_EVENT_STATUS.observed,
+        options,
+    });
+    const lifecycleUrl = canonicalizeUrl(asString(payload.entryUrl) ?? asString(payload.exitUrl));
+    if (lifecycleUrl) {
+        event.url_canonical = lifecycleUrl;
+    }
+    const sessionId = asString(payload.sessionId);
+    if (sessionId) {
+        event.session_id = sessionId;
+    }
+    setNumericMetric(event, "duration_ms", asNumber(payload.durationMs));
+    return event;
+};
+const buildNavigationEvent = (raw, options) => {
+    const payload = raw.payload;
+    const event = buildBaseEvent({
+        raw,
+        eventName: raw.type,
+        eventCategory: FRONTEND_EVENT_CATEGORY.navigation,
+        status: FRONTEND_EVENT_STATUS.observed,
+        options,
+    });
+    if (raw.type === FRONTEND_EVENT_NAME.pageView) {
+        event.view_id = asString(payload.viewId);
+        event.screen_key = normalizePathLike(asString(payload.screenKey));
+        event.path = normalizePathLike(asString(payload.path));
+        event.url_canonical = canonicalizeUrl(asString(payload.urlCanonical));
+        event.page_title_candidate = asString(payload.pageTitleCandidate);
+        event.route_name_candidate = asString(payload.routeNameCandidate);
+        event.primary_heading_candidate = asString(payload.primaryHeadingCandidate);
+    }
+    if (raw.type === FRONTEND_EVENT_NAME.pageLeave) {
+        event.view_id = asString(payload.viewId);
+        event.screen_key = normalizePathLike(asString(payload.screenKey));
+        event.path = normalizePathLike(asString(payload.path));
+        event.time_on_page_ms = asNumber(payload.timeOnPageMs) ?? null;
+    }
+    if (raw.type === FRONTEND_EVENT_NAME.routeChange) {
+        event.from_view_id = asString(payload.fromViewId);
+        event.to_view_id = asString(payload.toViewId);
+        event.from_screen_key = normalizePathLike(asString(payload.fromScreenKey));
+        event.to_screen_key = normalizePathLike(asString(payload.toScreenKey));
+        event.from_path = normalizePathLike(asString(payload.fromPath));
+        event.to_path = normalizePathLike(asString(payload.toPath));
+    }
+    return event;
+};
+const applyActionCommonPayload = (event, payload) => {
+    setStringProperty(event, "element_tag", asString(payload.elementTag));
+    setStringProperty(event, "element_role", asString(payload.elementRole));
+    setStringProperty(event, "element_id", asString(payload.elementId));
+    setUnknownProperty(event, "element_class", payload.elementClass);
+    setStringProperty(event, "field_name_candidate", asString(payload.fieldName));
+    setStringProperty(event, "field_type", asString(payload.fieldType));
+    setStringProperty(event, "element_label_candidate", asString(payload.clickTargetText) ?? asString(payload.fieldDisplayLabel));
+    setStringProperty(event, "aria_label_candidate", asString(payload.clickTargetAriaLabel) ?? asString(payload.fieldAriaLabel));
+    setStringProperty(event, "placeholder_candidate", asString(payload.fieldPlaceholder));
+    setStringProperty(event, "section_heading", asString(payload.sectionHeading));
+    setUnknownProperty(event, "field_name_meta", payload.fieldNameMeta);
+    setUnknownProperty(event, "element_label_meta", payload.elementLabelMeta);
+    setUnknownProperty(event, "aria_label_meta", payload.ariaLabelMeta);
+    setUnknownProperty(event, "placeholder_meta", payload.placeholderMeta);
+    return event;
+};
+const buildActionEvent = (raw, options) => {
+    const payload = raw.payload;
+    const event = buildBaseEvent({
+        raw,
+        eventName: raw.type,
+        eventCategory: FRONTEND_EVENT_CATEGORY.action,
+        status: FRONTEND_EVENT_STATUS.observed,
+        options,
+    });
+    applySemanticCaptureContract(event, raw, options);
+    applyCurrentPageContext(event, raw);
+    applyActionCommonPayload(event, payload);
+    setUnknownProperty(event, "input_value_meta", payload.inputValueMeta);
+    setUnknownProperty(event, "selected_value_meta", payload.selectedValueMeta);
+    setUnknownProperty(event, "file_selection_meta", payload.fileSelectionMeta);
+    setUnknownProperty(event, "file_descriptors", payload.fileDescriptors);
+    setUnknownProperty(event, "drag_types", payload.dragTypes);
+    if (raw.type === FRONTEND_EVENT_NAME.formSubmitted) {
+        event.submit_result = asString(payload.submitResult);
+        event.result_source = asString(payload.resultSource);
+        setStringProperty(event, "submit_result", event.submit_result);
+        setStringProperty(event, "result_source", event.result_source);
+        setNumericMetric(event, "time_to_result_ms", asNumber(payload.timeToResultMs));
+        setNumericMetric(event, "invalid_field_count", asNumber(payload.invalidFieldCount));
+        setUnknownProperty(event, "invalid_field_stable_keys", payload.invalidFieldStableKeys);
+        setUnknownProperty(event, "validation_reason_codes", payload.validationReasonCodes);
+        setStringProperty(event, "validation_message_fingerprint", asString(payload.validationMessageFingerprint));
+        setUnknownProperty(event, "linked_request_span_ids", payload.linkedRequestSpanIds);
+        setStringProperty(event, "linked_backend_outcome_class", asString(payload.linkedBackendOutcomeClass));
+    }
+    const checked = asBoolean(payload.checked);
+    if (checked !== null) {
+        event.properties.checked = checked;
+    }
+    setNumericMetric(event, "selected_count", asNumber(payload.selectedCount));
+    setNumericMetric(event, "file_count", asNumber(payload.fileCount));
+    setNumericMetric(event, "drag_item_count", asNumber(payload.dragItemCount));
+    return applyLocalHintEvidence(event);
+};
+const buildRequestEvent = (raw, options) => {
+    const payload = raw.payload;
+    const isFailed = raw.type === FRONTEND_EVENT_NAME.requestFailed;
+    const event = buildBaseEvent({
+        raw,
+        eventName: raw.type === FRONTEND_EVENT_NAME.requestFinished
+            ? FRONTEND_EVENT_NAME.requestFinished
+            : FRONTEND_EVENT_NAME.requestFailed,
+        eventCategory: FRONTEND_EVENT_CATEGORY.request,
+        status: isFailed
+            ? FRONTEND_EVENT_STATUS.failed
+            : FRONTEND_EVENT_STATUS.finished,
+        options,
+        requestId: asString(payload.requestId),
+        requestSpanId: asString(payload.requestSpanId),
+        interactionId: asString(payload.interactionId),
+        traceId: asString(payload.traceId),
+    });
+    const rawUrl = asString(payload.url);
+    const parsedUrl = rawUrl ? parseUrlForNetwork(rawUrl) : null;
+    const path = normalizePathLike(asString(payload.path) ?? parsedUrl?.path ?? null);
+    const pathTemplate = normalizePathLike(asString(payload.pathTemplate) ?? parsedUrl?.pathTemplate ?? null) ?? "/";
+    const targetService = asString(payload.targetService) ??
+        asString(payload.target_service) ??
+        (parsedUrl?.host || null);
+    const statusCode = asNumber(payload.statusCode) ?? (isFailed ? 0 : undefined);
+    const requestParametersSource = payload.requestParametersSource ?? {};
+    const responseParametersSource = payload.responseParametersSource ?? {};
+    event.method = asString(payload.method);
+    event.path_template = pathTemplate;
+    event.path = path;
+    event.target_service = targetService;
+    setStringProperty(event, "failure_type", asString(payload.failureType));
+    event.status_code = statusCode ?? null;
+    event.duration_ms = asNumber(payload.durationMs) ?? null;
+    event.outcome_class = asString(payload.outcomeClass);
+    event.attempt_status = resolveRequestLifecycleOutcome({
+        isFailed,
+        statusCode: event.status_code,
+        failureType: asString(payload.failureType),
+        outcomeClass: event.outcome_class,
+        explicitOutcome: asString(payload.requestLifecycleOutcome),
+    });
+    event.request_schema_hash = asString(payload.requestSchemaHash);
+    event.response_schema_hash = asString(payload.responseSchemaHash);
+    event.request_shape_size = asNumber(payload.requestShapeSize) ?? null;
+    event.response_shape_size = asNumber(payload.responseShapeSize) ?? null;
+    setStringProperty(event, "outcome_class", event.outcome_class);
+    setStringProperty(event, "request_lifecycle_outcome", event.attempt_status);
+    setStringProperty(event, "request_kind", asString(payload.requestKind));
+    setStringProperty(event, "error_code_candidate", asString(payload.errorCodeCandidate));
+    setStringProperty(event, "request_schema_hash", event.request_schema_hash);
+    setStringProperty(event, "response_schema_hash", event.response_schema_hash);
+    setUnknownProperty(event, "request_field_paths", payload.requestFieldPaths);
+    setUnknownProperty(event, "response_field_paths", payload.responseFieldPaths);
+    setStringProperty(event, "graphql_operation_name", asString(payload.graphqlOperationName));
+    setStringProperty(event, "graphql_operation_type", asString(payload.graphqlOperationType));
+    setUnknownProperty(event, "graphql_top_level_fields", payload.graphqlTopLevelFields);
+    setNumericMetric(event, "request_shape_size", event.request_shape_size ?? undefined);
+    setNumericMetric(event, "response_shape_size", event.response_shape_size ?? undefined);
+    setNumericMetric(event, "request_size_bytes", asNumber(payload.requestSizeBytes));
+    setNumericMetric(event, "response_size_bytes", asNumber(payload.responseSizeBytes));
+    const requestMetadata = payload.requestMetadataSummary
+        ? asRecord(payload.requestMetadataSummary)
+        : {};
+    requestMetadata.path_template = pathTemplate;
+    const queryKeys = asStringArray(payload.queryKeys);
+    if (queryKeys.length > 0) {
+        requestMetadata.query_keys = queryKeys;
+    }
+    if (Object.keys(requestMetadata).length > 0) {
+        event.request_metadata = requestMetadata;
+    }
+    if (payload.responseMetadataSummary) {
+        event.response_metadata = asRecord(payload.responseMetadataSummary);
+    }
+    try {
+        const requestSnapshot = buildParameterSnapshotBundle(requestParametersSource, {
+            allowedPaths: options.allowedValuePaths ?? [],
+            deniedKeys: options.deniedKeys,
+        });
+        const responseSnapshot = buildParameterSnapshotBundle(responseParametersSource, {
+            allowedPaths: options.allowedValuePaths ?? [],
+            deniedKeys: options.deniedKeys,
+            pathPrefix: "response",
+        });
+        event.request_parameters_snapshot_json = requestSnapshot.snapshot;
+        event.response_parameters_snapshot_json = responseSnapshot.snapshot;
+        const allowedValueKeys = [
+            ...requestSnapshot.allowedValueKeys,
+            ...responseSnapshot.allowedValueKeys,
+        ];
+        if (allowedValueKeys.length > 0) {
+            event.allowed_value_keys = [...new Set(allowedValueKeys)].sort();
+        }
+        const requestCaptureCounts = countCaptureModes(requestSnapshot.snapshot);
+        const responseCaptureCounts = countCaptureModes(responseSnapshot.snapshot);
+        event.masked_value_count =
+            requestCaptureCounts.maskedValueCount +
+                responseCaptureCounts.maskedValueCount;
+        event.forbidden_value_count =
+            requestCaptureCounts.forbiddenValueCount +
+                responseCaptureCounts.forbiddenValueCount;
+        event.truncated_value_count =
+            requestCaptureCounts.truncatedValueCount +
+                responseCaptureCounts.truncatedValueCount;
+        setNumericMetric(event, "masked_value_count", event.masked_value_count);
+        setNumericMetric(event, "forbidden_value_count", event.forbidden_value_count);
+        setNumericMetric(event, "truncated_value_count", event.truncated_value_count);
+    }
+    catch (error) {
+        options.onMaskingError?.(error);
+        event.request_parameters_snapshot_json =
+            buildUnavailableParameterSnapshot();
+        event.response_parameters_snapshot_json =
+            buildUnavailableParameterSnapshot();
+    }
+    applySemanticCaptureContract(event, raw, options);
+    applyCurrentPageContext(event, raw);
+    return applyLocalHintEvidence(event);
+};
+const buildErrorEvent = (raw, options) => {
+    const payload = raw.payload;
+    const event = buildBaseEvent({
+        raw,
+        eventName: raw.type,
+        eventCategory: FRONTEND_EVENT_CATEGORY.error,
+        status: FRONTEND_EVENT_STATUS.observed,
+        options,
+    });
+    applySemanticCaptureContract(event, raw, options);
+    applyCurrentPageContext(event, raw);
+    setStringProperty(event, "error_type", asString(payload.errorType));
+    setStringProperty(event, "error_fingerprint", asString(payload.errorFingerprint));
+    setStringProperty(event, "source_file_hint", asString(payload.sourceFileHint));
+    setStringProperty(event, "source_file", maskUrl(asString(payload.sourceFile)));
+    setStringProperty(event, "message", maskMessage(asString(payload.message)));
+    setUnknownProperty(event, "stack", maskUnknown(payload.stack));
+    setNumericMetric(event, "repeat_count", asNumber(payload.repeatCount));
+    setNumericMetric(event, "line_number", asNumber(payload.lineNumber));
+    setNumericMetric(event, "column_number", asNumber(payload.columnNumber));
+    return event;
+};
+const buildSupportEvent = (raw, options) => {
+    const payload = raw.payload;
+    const event = buildBaseEvent({
+        raw,
+        eventName: raw.type,
+        eventCategory: FRONTEND_EVENT_CATEGORY.support,
+        status: FRONTEND_EVENT_STATUS.observed,
+        options,
+    });
+    applySemanticCaptureContract(event, raw, options);
+    applyCurrentPageContext(event, raw);
+    applyActionCommonPayload(event, payload);
+    event.collector_name = asString(payload.collectorName);
+    setStringProperty(event, "collector_name", event.collector_name);
+    setStringProperty(event, "detail_reason", asString(payload.detailReason));
+    setStringProperty(event, "resource_kind", asString(payload.resourceKind));
+    setStringProperty(event, "initiator_type", asString(payload.initiatorType));
+    setStringProperty(event, "url_canonical", asString(payload.urlCanonical));
+    setNumericMetric(event, "repeat_count", asNumber(payload.repeatCount));
+    return event;
+};
+const buildSummaryEvent = (raw, options) => {
+    const payload = raw.payload;
+    const eventCategory = raw.type === FRONTEND_EVENT_NAME.performanceSummaryObserved
+        ? FRONTEND_EVENT_CATEGORY.performance
+        : FRONTEND_EVENT_CATEGORY.support;
+    const event = buildBaseEvent({
+        raw,
+        eventName: raw.type,
+        eventCategory,
+        status: FRONTEND_EVENT_STATUS.observed,
+        options,
+    });
+    applySemanticCaptureContract(event, raw, options);
+    applyCurrentPageContext(event, raw);
+    applySummaryContract(event, payload);
+    if (raw.type === FRONTEND_EVENT_NAME.performanceSummaryObserved) {
+        applyPerformanceSummaryContract(event, payload);
+    }
+    setStringProperty(event, "detail_reason", asString(payload.detailReason));
+    setStringProperty(event, "report_type", asString(payload.reportType));
+    setStringProperty(event, "network_phase", asString(payload.networkPhase));
+    setStringProperty(event, "capture_disabled_reason", asString(payload.captureDisabledReason));
+    setUnknownProperty(event, "active_capture_modules", payload.activeCaptureModules);
+    setNumericMetric(event, "events_summarized_count", asNumber(payload.eventsSummarizedCount));
+    setNumericMetric(event, "sampling_dropped_count", asNumber(payload.samplingDroppedCount));
+    setNumericMetric(event, "transport_failed_count", asNumber(payload.transportFailedCount));
+    setNumericMetric(event, "transport_retry_count", asNumber(payload.transportRetryCount));
+    return event;
+};
+const buildCustomEvent = (raw, options) => {
+    const payload = raw.payload;
+    const metrics = asRecord(payload.metrics);
+    const event = buildBaseEvent({
+        raw,
+        eventName: FRONTEND_EVENT_NAME.customEmitted,
+        eventCategory: FRONTEND_EVENT_CATEGORY.custom,
+        status: FRONTEND_EVENT_STATUS.observed,
+        options,
+    });
+    const customEventName = asString(payload.eventName)?.trim() ?? "";
+    for (const [key, value] of Object.entries(metrics)) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            event.metrics[key] = value;
+        }
+    }
+    const properties = sanitizeForCustomProperties(payload.properties, options);
+    if (properties &&
+        typeof properties === "object" &&
+        !Array.isArray(properties)) {
+        event.properties = {
+            ...event.properties,
+            ...properties,
+        };
+    }
+    if (customEventName) {
+        event.custom_event_name = customEventName;
+    }
+    applyCurrentPageContext(event, raw);
+    return event;
+};
+const cloneCanonicalEvent = (event) => {
+    return JSON.parse(JSON.stringify(event));
+};
+const hasParameterSnapshots = (event) => {
+    return (event.request_parameters_snapshot_json !== undefined ||
+        event.response_parameters_snapshot_json !== undefined);
+};
+const buildParameterSnapshotTruncatedCandidate = (event) => {
+    const truncated = cloneCanonicalEvent(event);
+    if (truncated.request_parameters_snapshot_json !== undefined) {
+        truncated.request_parameters_snapshot_json = truncateParameterSnapshotValue(truncated.request_parameters_snapshot_json);
+    }
+    if (truncated.response_parameters_snapshot_json !== undefined) {
+        truncated.response_parameters_snapshot_json =
+            truncateParameterSnapshotValue(truncated.response_parameters_snapshot_json);
+    }
+    truncated.properties.degradation_stage = "parameter_snapshot_truncated";
+    return truncated;
+};
+export const buildDegradedCanonicalCandidates = (event) => {
+    if (!hasParameterSnapshots(event)) {
+        return [];
+    }
+    return [
+        {
+            stage: "parameter_snapshot_truncated",
+            event: buildParameterSnapshotTruncatedCandidate(event),
+        },
+    ];
+};
+export const buildCanonicalEvent = (raw, options) => {
+    switch (raw.type) {
+        case FRONTEND_EVENT_NAME.sessionStarted:
+        case FRONTEND_EVENT_NAME.sessionEnded:
+            return buildSessionEvent(raw, options);
+        case FRONTEND_EVENT_NAME.pageView:
+        case FRONTEND_EVENT_NAME.pageLeave:
+        case FRONTEND_EVENT_NAME.routeChange:
+            return buildNavigationEvent(raw, options);
+        case FRONTEND_EVENT_NAME.elementClicked:
+        case FRONTEND_EVENT_NAME.formSubmitted:
+        case FRONTEND_EVENT_NAME.inputCommitted:
+        case FRONTEND_EVENT_NAME.toggleChanged:
+        case FRONTEND_EVENT_NAME.selectionCommitted:
+        case FRONTEND_EVENT_NAME.fileSelected:
+        case FRONTEND_EVENT_NAME.dragDropCompleted:
+            return buildActionEvent(raw, options);
+        case FRONTEND_EVENT_NAME.requestFinished:
+        case FRONTEND_EVENT_NAME.requestFailed:
+            return buildRequestEvent(raw, options);
+        case FRONTEND_EVENT_NAME.performanceSummaryObserved:
+        case FRONTEND_EVENT_NAME.browserReportSummaryObserved:
+        case FRONTEND_EVENT_NAME.uiLifecycleSummaryObserved:
+        case FRONTEND_EVENT_NAME.streamLifecycleSummaryObserved:
+        case FRONTEND_EVENT_NAME.sdkDiagnosticObserved:
+            return buildSummaryEvent(raw, options);
+        case FRONTEND_EVENT_NAME.frontendError:
+        case FRONTEND_EVENT_NAME.unhandledRejection:
+            return buildErrorEvent(raw, options);
+        case FRONTEND_EVENT_NAME.deadClickDetected:
+        case FRONTEND_EVENT_NAME.errorClickDetected:
+        case FRONTEND_EVENT_NAME.rageClickDetected:
+            return buildSupportEvent(raw, options);
+        case FRONTEND_EVENT_NAME.customEmitted:
+            return buildCustomEvent(raw, options);
+        default:
+            return null;
+    }
+};