@genn-inc/cluebase-frontend-sdk 0.0.1

package/dist/provider/config.js

@@ -0,0 +1,177 @@
+import { ALWAYS_DENIED_KEYS, DEFAULT_CONFIG, DEFAULT_FRONTEND_SOURCE_IDENTIFIER, MAX_DIAGNOSTIC_TTL_MS, } from "./constants.js";
+import { SDK_COLLECTION_MODE } from "./contracts.js";
+const normalizeKeyList = (keys) => {
+    if (!keys || keys.length === 0) {
+        return [];
+    }
+    return [
+        ...new Set(keys.map((key) => key.trim().toLowerCase()).filter(Boolean)),
+    ];
+};
+const clampRate = (value, fallback) => {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        return fallback;
+    }
+    if (value < 0) {
+        return 0;
+    }
+    if (value > 1) {
+        return 1;
+    }
+    return value;
+};
+const positiveIntOrFallback = (value, fallback) => {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return fallback;
+    }
+    return Math.floor(value);
+};
+const normalizeCollectionMode = (value) => {
+    if (value === SDK_COLLECTION_MODE.diagnostic) {
+        return SDK_COLLECTION_MODE.diagnostic;
+    }
+    return SDK_COLLECTION_MODE.standard;
+};
+const normalizeDiagnosticScope = (value) => {
+    if (!value) {
+        return {};
+    }
+    const entries = Object.entries(value)
+        .map(([key, scopeValue]) => [key.trim(), scopeValue])
+        .filter(([key]) => key.length > 0)
+        .filter(([, scopeValue]) => {
+        return (scopeValue === null ||
+            typeof scopeValue === "string" ||
+            typeof scopeValue === "number" ||
+            typeof scopeValue === "boolean");
+    })
+        .slice(0, 20);
+    return Object.fromEntries(entries);
+};
+const normalizeDiagnosticConfig = (value) => {
+    const ttlMs = Math.min(positiveIntOrFallback(value?.ttlMs, DEFAULT_CONFIG.collection.diagnostic.ttlMs), MAX_DIAGNOSTIC_TTL_MS);
+    const budgetWindowMs = positiveIntOrFallback(value?.budgetWindowMs, DEFAULT_CONFIG.collection.diagnostic.budgetWindowMs);
+    const maxEventsPerWindow = positiveIntOrFallback(value?.maxEventsPerWindow, DEFAULT_CONFIG.collection.diagnostic.maxEventsPerWindow);
+    return {
+        enabledCollectors: normalizeKeyList(value?.enabledCollectors),
+        scope: normalizeDiagnosticScope(value?.scope),
+        ttlMs,
+        expiresAt: value?.expiresAt?.trim() || null,
+        budgetWindowMs,
+        maxEventsPerWindow,
+        sampleRate: clampRate(value?.sampleRate, DEFAULT_CONFIG.collection.diagnostic.sampleRate),
+        reason: value?.reason?.trim() || null,
+        enabledBy: value?.enabledBy?.trim() || null,
+    };
+};
+// The protocols Cluebase can actually deliver over. Every place that rejects an
+// address reads this one set, so a browser-only scheme cannot be refused here
+// and accepted there.
+const SENDABLE_PROTOCOLS = new Set(["http:", "https:"]);
+/**
+ * Read an address Cluebase is able to send to, or `null` when it cannot.
+ *
+ * `cluebase.init` refuses such an endpoint loudly and `resolveConfig` drops it to
+ * `""`; the two reactions differ but the question does not, so neither restates
+ * the rule.
+ */
+export const parseSendableUrl = (value) => {
+    try {
+        const parsed = new URL(value.trim());
+        return SENDABLE_PROTOCOLS.has(parsed.protocol) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+};
+const normalizeConfiguredEndpoint = (value) => parseSendableUrl(value)?.toString() ?? "";
+const normalizeTracePropagationOrigin = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    // Unlike an endpoint, an origin that does not parse is kept as written: the
+    // caller matches these against request URLs itself.
+    try {
+        const parsed = new URL(trimmed);
+        return SENDABLE_PROTOCOLS.has(parsed.protocol) ? parsed.origin : null;
+    }
+    catch {
+        return trimmed;
+    }
+};
+// The SDK does not emit a ProjectService environment. The server resolves
+// dev/prod from the `projectKey` prefix and ProjectService.
+export const resolveConfig = (options) => {
+    const originalEndpoint = normalizeConfiguredEndpoint(options.endpoint);
+    const customDenied = normalizeKeyList(options.privacy?.deniedKeys);
+    const deniedKeys = [...new Set([...ALWAYS_DENIED_KEYS, ...customDenied])];
+    const tracePropagationOrigins = [
+        ...new Set((options.network?.tracePropagationOrigins ?? [])
+            .map(normalizeTracePropagationOrigin)
+            .filter((origin) => Boolean(origin))),
+    ];
+    return {
+        endpoint: originalEndpoint,
+        originalEndpoint,
+        localSetupCheckEndpoint: null,
+        projectKey: options.projectKey?.trim() ?? "",
+        producerId: DEFAULT_FRONTEND_SOURCE_IDENTIFIER,
+        transportProfile: DEFAULT_CONFIG.transportProfile,
+        autocapture: options.autocapture ?? DEFAULT_CONFIG.autocapture,
+        captureNetwork: options.captureNetwork ?? DEFAULT_CONFIG.captureNetwork,
+        captureErrors: options.captureErrors ?? DEFAULT_CONFIG.captureErrors,
+        capturePerformance: options.capturePerformance ?? DEFAULT_CONFIG.capturePerformance,
+        network: {
+            tracePropagationOrigins,
+        },
+        batch: {
+            enabled: options.batch?.enabled ?? DEFAULT_CONFIG.batch.enabled,
+            maxSize: positiveIntOrFallback(options.batch?.maxSize, DEFAULT_CONFIG.batch.maxSize),
+            flushIntervalMs: positiveIntOrFallback(options.batch?.flushIntervalMs, DEFAULT_CONFIG.batch.flushIntervalMs),
+            maxEventBytes: positiveIntOrFallback(options.batch?.maxEventBytes, DEFAULT_CONFIG.batch.maxEventBytes),
+            maxPayloadBytes: positiveIntOrFallback(options.batch?.maxPayloadBytes, DEFAULT_CONFIG.batch.maxPayloadBytes),
+        },
+        privacy: {
+            deniedKeys,
+        },
+        sampling: {
+            sessionSampleRate: clampRate(options.sampling?.sessionSampleRate, DEFAULT_CONFIG.sampling.sessionSampleRate),
+        },
+        collection: {
+            mode: normalizeCollectionMode(undefined),
+            diagnostic: normalizeDiagnosticConfig(undefined),
+        },
+        release: {
+            frontendRelease: options.release?.frontendRelease?.trim() ||
+                DEFAULT_CONFIG.release.frontendRelease,
+        },
+        contextTraitsProvider: options.contextTraitsProvider,
+        otelProviderMode: options.otelProviderMode ?? "detect",
+    };
+};
+export const validateConfig = (config) => {
+    const issues = [];
+    if (!config.endpoint) {
+        issues.push("endpoint is required");
+    }
+    if (!config.projectKey) {
+        issues.push("projectKey is required");
+    }
+    if (config.batch.flushIntervalMs < 100) {
+        issues.push("batch.flushIntervalMs must be >= 100ms");
+    }
+    if (config.batch.maxSize < 1) {
+        issues.push("batch.maxSize must be >= 1");
+    }
+    if (config.batch.maxEventBytes < 512) {
+        issues.push("batch.maxEventBytes must be >= 512 bytes");
+    }
+    if (config.batch.maxPayloadBytes < config.batch.maxEventBytes) {
+        issues.push("batch.maxPayloadBytes must be >= batch.maxEventBytes");
+    }
+    return issues;
+};
+export const isConfigValid = (config) => {
+    return validateConfig(config).length === 0;
+};

package/dist/provider/constants.d.ts

@@ -0,0 +1,62 @@
+import type { CluebaseConsentState, ResolvedCluebaseConfig } from "./types.js";
+import { SDK_VERSION } from "./_version.js";
+export { SDK_VERSION };
+export declare const SDK_NAME = "@genn-inc/cluebase-frontend-sdk";
+export declare const EVENT_SOURCE: "frontend_sdk";
+export declare const EVENT_VERSION = 1;
+export declare const SOURCE_SCHEMA_VERSION = "1";
+export declare const SURFACE_TYPE: "web";
+export declare const DEFAULT_FRONTEND_SOURCE_IDENTIFIER = "frontend";
+export declare const MASKED_VALUE = "__cluebase_masked__";
+export declare const FORBIDDEN_PARAMETER_VALUE = "__forbidden__";
+export declare const TRUNCATED_PARAMETER_VALUE = "__truncated__";
+export declare const DEFAULT_CONSENT: CluebaseConsentState;
+export declare const CONSENT_DENIED_ABORT_REASON = "consent_denied";
+export declare const DEFAULT_SESSION_TIMEOUT_MS: number;
+export declare const DEFAULT_LIFECYCLE_INTERACTION_GRACE_WINDOW_MS = 30000;
+export declare const DEFAULT_MAX_EVENT_PAYLOAD_BYTES: number;
+export declare const DEFAULT_BATCH_FLUSH_THRESHOLD_BYTES: number;
+export declare const DEFAULT_MAX_BATCH_PAYLOAD_BYTES: number;
+export declare const DEFAULT_MAX_BATCH_QUEUE_BYTES: number;
+export declare const DEFAULT_MAX_BATCH_QUEUE_ITEMS = 5000;
+export declare const DEFAULT_DIAGNOSTIC_TTL_MS = 600000;
+export declare const MAX_DIAGNOSTIC_TTL_MS = 1800000;
+export declare const DEFAULT_DIAGNOSTIC_BUDGET_WINDOW_MS = 60000;
+export declare const DEFAULT_DIAGNOSTIC_MAX_EVENTS_PER_WINDOW = 100;
+export declare const STORAGE_KEYS: {
+    readonly anonymousId: "cluebase:anon_id";
+    readonly userId: "cluebase:user_id";
+    readonly organizationId: "cluebase:organization_id";
+    readonly tabId: "cluebase:tab_id";
+    readonly sessionId: "cluebase:session_id";
+    readonly sessionStartedAt: "cluebase:session_started_at";
+    readonly sessionLastActivityAt: "cluebase:session_last_activity_at";
+};
+/**
+ * SDK-side denied keys. Stripped from event properties / metrics /
+ * traits / headers / body fragments before the value is set as an OTel
+ * span attribute or attached to a source-signal envelope.
+ *
+ * This list is a strict superset of the server-side hard-deny list
+ * (`INGEST_HARD_DENY_KEYS`) **by construction**: both are emitted from the
+ * same canonical data file,
+ * `packages/cluebase-shared/src/ingest/ingest-privacy-policy.v1.json`.
+ * It is not a hand-kept copy asserted by a parity test any more.
+ *
+ * `@cluebase/shared` is `private: true` and the published SDK is built with
+ * `tsc` alone (no bundling), so the SDK cannot import it at customer
+ * runtime. The shared-contract generator therefore writes the table into
+ * this package instead; the generated file's banner names the command to
+ * re-run. Do not re-declare the list, or the command, here.
+ */
+export declare const ALWAYS_DENIED_KEYS: readonly string[];
+export declare const MAX_SCHEMA_DEPTH = 6;
+export declare const MAX_SCHEMA_KEYS = 512;
+export declare const MAX_SANITIZE_DEPTH = 20;
+export declare const DEFAULT_CONFIG: ResolvedCluebaseConfig;
+export declare const RETRY_CONFIG: {
+    readonly maxAttempts: 3;
+    readonly baseDelayMs: 300;
+    readonly maxDelayMs: 5000;
+    readonly maxAdditiveJitterMs: 200;
+};

package/dist/provider/constants.js

@@ -0,0 +1,118 @@
+import { SDK_ALWAYS_DENIED_KEYS } from "../_generated/ingest-privacy-tables.js";
+import { SDK_RETRY_POLICY } from "../_generated/sdk-runtime-policy.js";
+import { SDK_VERSION } from "./_version.js";
+// SDK_VERSION SoT is `package.json` `version`, generated into
+// `_version.ts` by `scripts/generate-version-module.mjs` at build time.
+// Re-export it here so call sites keep the existing import path.
+export { SDK_VERSION };
+export const SDK_NAME = "@genn-inc/cluebase-frontend-sdk";
+export const EVENT_SOURCE = "frontend_sdk";
+export const EVENT_VERSION = 1;
+export const SOURCE_SCHEMA_VERSION = "1";
+export const SURFACE_TYPE = "web";
+export const DEFAULT_FRONTEND_SOURCE_IDENTIFIER = "frontend";
+// Canonical mask sentinel — matches Node SDK / Python SDK / `@cluebase/shared`
+// (`__cluebase_masked__`). Aligning across the 3 SDKs lets downstream analytics
+// queries and redaction UIs detect masked values by a single string literal.
+export const MASKED_VALUE = "__cluebase_masked__";
+export const FORBIDDEN_PARAMETER_VALUE = "__forbidden__";
+export const TRUNCATED_PARAMETER_VALUE = "__truncated__";
+export const DEFAULT_CONSENT = "unknown";
+// 送信中の取りやめが「同意の取り消し」だったのかを、中断の理由で見分けます。
+// 立てる側 (`batch.ts`) と読む側 (`client.ts`) が別の module なので、字面を
+// 両方へ書くと片方だけずれても誰も気づきません。**ずれると取り消し後の束が
+// 破棄ではなく再送**になり、利用者が拒否した後の観測が顧客のサイトから出ます。
+// 正本を 1 つにして、両端がここを読みます (AGENTS §0.2)。
+export const CONSENT_DENIED_ABORT_REASON = "consent_denied";
+export const DEFAULT_SESSION_TIMEOUT_MS = 30 * 60 * 1000;
+export const DEFAULT_LIFECYCLE_INTERACTION_GRACE_WINDOW_MS = 30000;
+export const DEFAULT_MAX_EVENT_PAYLOAD_BYTES = 48 * 1024;
+export const DEFAULT_BATCH_FLUSH_THRESHOLD_BYTES = 48 * 1024;
+export const DEFAULT_MAX_BATCH_PAYLOAD_BYTES = 60 * 1024;
+export const DEFAULT_MAX_BATCH_QUEUE_BYTES = 300 * 1024;
+// EventQueue の保持件数上限。 maxBytes (300KB) と二重にガードして OOM を防ぐ。
+// queueMaxBytes は payload size 起点で削るが、件数ベースの暴走 (極小 event の連射等)
+// を捕捉するために件数上限も併設する。
+export const DEFAULT_MAX_BATCH_QUEUE_ITEMS = 5000;
+export const DEFAULT_DIAGNOSTIC_TTL_MS = 600000;
+export const MAX_DIAGNOSTIC_TTL_MS = 1800000;
+export const DEFAULT_DIAGNOSTIC_BUDGET_WINDOW_MS = 60000;
+export const DEFAULT_DIAGNOSTIC_MAX_EVENTS_PER_WINDOW = 100;
+export const STORAGE_KEYS = {
+    anonymousId: "cluebase:anon_id",
+    userId: "cluebase:user_id",
+    organizationId: "cluebase:organization_id",
+    tabId: "cluebase:tab_id",
+    sessionId: "cluebase:session_id",
+    sessionStartedAt: "cluebase:session_started_at",
+    sessionLastActivityAt: "cluebase:session_last_activity_at",
+};
+/**
+ * SDK-side denied keys. Stripped from event properties / metrics /
+ * traits / headers / body fragments before the value is set as an OTel
+ * span attribute or attached to a source-signal envelope.
+ *
+ * This list is a strict superset of the server-side hard-deny list
+ * (`INGEST_HARD_DENY_KEYS`) **by construction**: both are emitted from the
+ * same canonical data file,
+ * `packages/cluebase-shared/src/ingest/ingest-privacy-policy.v1.json`.
+ * It is not a hand-kept copy asserted by a parity test any more.
+ *
+ * `@cluebase/shared` is `private: true` and the published SDK is built with
+ * `tsc` alone (no bundling), so the SDK cannot import it at customer
+ * runtime. The shared-contract generator therefore writes the table into
+ * this package instead; the generated file's banner names the command to
+ * re-run. Do not re-declare the list, or the command, here.
+ */
+export const ALWAYS_DENIED_KEYS = SDK_ALWAYS_DENIED_KEYS;
+export const MAX_SCHEMA_DEPTH = 6;
+export const MAX_SCHEMA_KEYS = 512;
+export const MAX_SANITIZE_DEPTH = 20;
+export const DEFAULT_CONFIG = {
+    endpoint: "",
+    originalEndpoint: "",
+    localSetupCheckEndpoint: null,
+    projectKey: "",
+    producerId: DEFAULT_FRONTEND_SOURCE_IDENTIFIER,
+    transportProfile: "standard",
+    autocapture: true,
+    captureNetwork: true,
+    captureErrors: true,
+    capturePerformance: true,
+    network: {
+        tracePropagationOrigins: [],
+    },
+    batch: {
+        enabled: true,
+        maxSize: 50,
+        flushIntervalMs: 180000,
+        maxEventBytes: DEFAULT_MAX_EVENT_PAYLOAD_BYTES,
+        maxPayloadBytes: DEFAULT_MAX_BATCH_PAYLOAD_BYTES,
+    },
+    privacy: {
+        deniedKeys: [...ALWAYS_DENIED_KEYS],
+    },
+    sampling: {
+        sessionSampleRate: 1,
+    },
+    collection: {
+        mode: "standard",
+        diagnostic: {
+            enabledCollectors: [],
+            scope: {},
+            ttlMs: DEFAULT_DIAGNOSTIC_TTL_MS,
+            expiresAt: null,
+            budgetWindowMs: DEFAULT_DIAGNOSTIC_BUDGET_WINDOW_MS,
+            maxEventsPerWindow: DEFAULT_DIAGNOSTIC_MAX_EVENTS_PER_WINDOW,
+            sampleRate: 1,
+            reason: null,
+            enabledBy: null,
+        },
+    },
+    release: {
+        frontendRelease: SDK_VERSION,
+    },
+    contextTraitsProvider: undefined,
+    otelProviderMode: "detect",
+};
+export const RETRY_CONFIG = SDK_RETRY_POLICY;

package/dist/provider/contracts.d.ts

@@ -0,0 +1,51 @@
+export declare const FRONTEND_EVENT_CATEGORY: {
+    readonly session: "session";
+    readonly navigation: "navigation";
+    readonly action: "action";
+    readonly interaction: "interaction";
+    readonly request: "request";
+    readonly error: "error";
+    readonly performance: "performance";
+    readonly support: "support";
+    readonly custom: "custom";
+};
+export type FrontendEventCategory = (typeof FRONTEND_EVENT_CATEGORY)[keyof typeof FRONTEND_EVENT_CATEGORY];
+export declare const FRONTEND_EVENT_STATUS: {
+    readonly observed: "observed";
+    readonly finished: "finished";
+    readonly failed: "failed";
+};
+export type FrontendEventStatus = (typeof FRONTEND_EVENT_STATUS)[keyof typeof FRONTEND_EVENT_STATUS];
+export declare const SDK_COLLECTION_MODE: {
+    readonly standard: "standard";
+    readonly diagnostic: "diagnostic";
+};
+export type SdkCollectionMode = (typeof SDK_COLLECTION_MODE)[keyof typeof SDK_COLLECTION_MODE];
+export declare const FRONTEND_EVENT_NAME: {
+    readonly sessionStarted: "session_started";
+    readonly sessionEnded: "session_ended";
+    readonly pageView: "page_view";
+    readonly pageLeave: "page_leave";
+    readonly routeChange: "route_change";
+    readonly elementClicked: "element_clicked";
+    readonly formSubmitted: "form_submitted";
+    readonly inputCommitted: "input_committed";
+    readonly toggleChanged: "toggle_changed";
+    readonly selectionCommitted: "selection_committed";
+    readonly fileSelected: "file_selected";
+    readonly dragDropCompleted: "drag_drop_completed";
+    readonly requestStarted: "request_started";
+    readonly requestFinished: "request_finished";
+    readonly requestFailed: "request_failed";
+    readonly frontendError: "frontend_error";
+    readonly unhandledRejection: "unhandled_rejection";
+    readonly performanceSummaryObserved: "performance_summary_observed";
+    readonly customEmitted: "custom_emitted";
+};
+export type FrontendEventName = (typeof FRONTEND_EVENT_NAME)[keyof typeof FRONTEND_EVENT_NAME];
+export declare const PARAMETER_CAPTURE_MODE: {
+    readonly maskedFingerprint: "masked_fingerprint";
+    readonly forbidden: "forbidden";
+    readonly truncated: "truncated";
+};
+export type ParameterCaptureMode = (typeof PARAMETER_CAPTURE_MODE)[keyof typeof PARAMETER_CAPTURE_MODE];

package/dist/provider/contracts.js

@@ -0,0 +1,46 @@
+export const FRONTEND_EVENT_CATEGORY = {
+    session: "session",
+    navigation: "navigation",
+    action: "action",
+    interaction: "interaction",
+    request: "request",
+    error: "error",
+    performance: "performance",
+    support: "support",
+    custom: "custom",
+};
+export const FRONTEND_EVENT_STATUS = {
+    observed: "observed",
+    finished: "finished",
+    failed: "failed",
+};
+export const SDK_COLLECTION_MODE = {
+    standard: "standard",
+    diagnostic: "diagnostic",
+};
+export const FRONTEND_EVENT_NAME = {
+    sessionStarted: "session_started",
+    sessionEnded: "session_ended",
+    pageView: "page_view",
+    pageLeave: "page_leave",
+    routeChange: "route_change",
+    elementClicked: "element_clicked",
+    formSubmitted: "form_submitted",
+    inputCommitted: "input_committed",
+    toggleChanged: "toggle_changed",
+    selectionCommitted: "selection_committed",
+    fileSelected: "file_selected",
+    dragDropCompleted: "drag_drop_completed",
+    requestStarted: "request_started",
+    requestFinished: "request_finished",
+    requestFailed: "request_failed",
+    frontendError: "frontend_error",
+    unhandledRejection: "unhandled_rejection",
+    performanceSummaryObserved: "performance_summary_observed",
+    customEmitted: "custom_emitted",
+};
+export const PARAMETER_CAPTURE_MODE = {
+    maskedFingerprint: "masked_fingerprint",
+    forbidden: "forbidden",
+    truncated: "truncated",
+};

package/dist/provider/privacy-policy-store.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 届いた方針を適用する。**契約に合わない形は捨てて、伏せた側へ倒れます。**
+ * 途中まで読めた分を活かすと、顧客が決めていない項目を平文にし得ます。
+ */
+export declare const applyDeliveredPrivacyPolicy: (policy: unknown) => void;
+/** まだ何も適用していない状態へ戻す。= 全部伏せる。 */
+export declare const resetPrivacyPolicy: () => void;
+/** 塊の要求に載せる合印。持っていなければ載せない。 */
+export declare const appliedPrivacyPolicyToken: () => string | undefined;
+/**
+ * この入口・この向きで、顧客が平文にした項目名。
+ *
+ * **入口が決まらない時は空を返します。**曖昧に当てると、顧客が 1 つの入口について
+ * 決めたことが、関係のない通信まで平文にします。
+ */
+export declare const allowedValuePathsFor: (input: {
+    method: string | null | undefined;
+    pathTemplate: string | null | undefined;
+    direction: "request" | "response";
+}) => readonly string[];

package/dist/provider/privacy-policy-store.js

@@ -0,0 +1,56 @@
+import { ingestPrivacyPolicySchema, } from "../exporter/delivery-response-contract.js";
+const policyKey = (input) => `${input.direction} ${input.method.toUpperCase()} ${input.pathTemplate}`;
+let appliedToken = null;
+let allowedPathsByEntrance = new Map();
+/**
+ * 届いた方針を適用する。**契約に合わない形は捨てて、伏せた側へ倒れます。**
+ * 途中まで読めた分を活かすと、顧客が決めていない項目を平文にし得ます。
+ */
+export const applyDeliveredPrivacyPolicy = (policy) => {
+    const parsed = ingestPrivacyPolicySchema.safeParse(policy);
+    if (!parsed.success) {
+        resetPrivacyPolicy();
+        return;
+    }
+    setPrivacyPolicy(parsed.data);
+};
+const setPrivacyPolicy = (policy) => {
+    const next = new Map();
+    for (const entry of policy.entries) {
+        const key = policyKey({
+            method: entry.method,
+            pathTemplate: entry.path_template,
+            direction: entry.direction,
+        });
+        const paths = next.get(key);
+        if (paths) {
+            paths.push(entry.field_path);
+            continue;
+        }
+        next.set(key, [entry.field_path]);
+    }
+    allowedPathsByEntrance = next;
+    appliedToken = policy.token;
+};
+/** まだ何も適用していない状態へ戻す。= 全部伏せる。 */
+export const resetPrivacyPolicy = () => {
+    allowedPathsByEntrance = new Map();
+    appliedToken = null;
+};
+/** 塊の要求に載せる合印。持っていなければ載せない。 */
+export const appliedPrivacyPolicyToken = () => appliedToken ?? undefined;
+/**
+ * この入口・この向きで、顧客が平文にした項目名。
+ *
+ * **入口が決まらない時は空を返します。**曖昧に当てると、顧客が 1 つの入口について
+ * 決めたことが、関係のない通信まで平文にします。
+ */
+export const allowedValuePathsFor = (input) => {
+    if (!input.method || !input.pathTemplate)
+        return [];
+    return (allowedPathsByEntrance.get(policyKey({
+        method: input.method,
+        pathTemplate: input.pathTemplate,
+        direction: input.direction,
+    })) ?? []);
+};

package/dist/provider/sampling.d.ts

@@ -0,0 +1,2 @@
+export declare const secureRandomFloat: () => number;
+export declare const shouldSampleSession: (rate: number) => boolean;

package/dist/provider/sampling.js

@@ -0,0 +1,17 @@
+const UINT32_RANGE = 4294967296;
+export const secureRandomFloat = () => {
+    if (typeof globalThis.crypto === "undefined" ||
+        typeof globalThis.crypto.getRandomValues !== "function") {
+        throw new Error("Cluebase SDK requires crypto.getRandomValues for sampling");
+    }
+    const values = new Uint32Array(1);
+    globalThis.crypto.getRandomValues(values);
+    return values[0] / UINT32_RANGE;
+};
+export const shouldSampleSession = (rate) => {
+    if (rate >= 1)
+        return true;
+    if (rate <= 0)
+        return false;
+    return secureRandomFloat() < rate;
+};

package/dist/provider/sdk-event-pipeline.d.ts

@@ -0,0 +1,60 @@
+import { TraceManager } from "../context/trace.js";
+import type { EnvironmentManager } from "../context/environment.js";
+import type { IdentityManager } from "../context/identity.js";
+import type { OrganizationManager } from "../context/organization.js";
+import type { SessionManager } from "../context/session.js";
+import type { TabManager } from "../context/tab.js";
+import type { BatchTransport } from "../exporter/batch.js";
+import type { InternalMetricsStore } from "../internal/metrics.js";
+import type { CluebaseConsentState, CluebaseContext, CluebaseInternalLogger, IngestUsageGovernorFeedback, RawCapturedEvent, ResolvedCluebaseConfig } from "./types.js";
+export declare const OFFICIAL_CUSTOM_EVENT_NAME: {
+    readonly identityIdentified: "identity_identified";
+    readonly identityReset: "identity_reset";
+    readonly organizationAssociated: "organization_associated";
+    readonly sdkInitialized: "sdk_initialized";
+};
+export type OfficialCustomEventProperties = Record<string, string | string[] | number>;
+export declare const readCurrentLifecycleUrl: () => string | null;
+type ProviderEventPipelineRuntime = {
+    config: ResolvedCluebaseConfig;
+    identityManager: IdentityManager;
+    sessionManager: SessionManager;
+    tabManager: TabManager;
+    organizationManager: OrganizationManager;
+    environmentManager: EnvironmentManager;
+    traceManager: TraceManager;
+    transport: BatchTransport;
+    internalMetrics: InternalMetricsStore;
+    logger: CluebaseInternalLogger;
+    getConsent: () => CluebaseConsentState;
+};
+export declare const getSessionCaptureEligibility: (transport: BatchTransport) => boolean | undefined;
+export declare class ProviderEventPipeline {
+    private runtime;
+    private currentViewId;
+    private usageGovernorFeedback;
+    private sessionCaptureEligible;
+    private unregisterSessionCaptureEligibility;
+    configure(runtime: ProviderEventPipelineRuntime): void;
+    clearRuntime(): void;
+    resetViewId(): void;
+    getViewId(): string | null;
+    getObservationContext(): {
+        anonymousId: string | null;
+        userId: string | null;
+        organizationId?: string | null;
+        sessionId: string | null;
+        tabId: string | null;
+    };
+    enqueueRawEvent(event: RawCapturedEvent, skipSessionTouch?: boolean): void;
+    applyUsageGovernorFeedback(feedback: IngestUsageGovernorFeedback | null | undefined): void;
+    refreshSessionCaptureEligibility(): void;
+    buildContext(): CluebaseContext;
+    private attachInteractionContext;
+    private attachCurrentLocation;
+    private handleSessionLifecycle;
+    private shouldCaptureEvent;
+    private measureSerializedBytes;
+    private updateActiveTraceSpan;
+}
+export {};