@genn-inc/cluebase-frontend-sdk 0.0.1 → 0.0.2

package/README.md

@@ -10,7 +10,6 @@ After `pnpm add @genn-inc/cluebase-frontend-sdk`, the intended Next.js integrati
 import cluebase from "@genn-inc/cluebase-frontend-sdk";
 
 cluebase.init({
-  endpoint: process.env.NEXT_PUBLIC_CLUEBASE_API_BASE_URL!,
   projectKey: process.env.NEXT_PUBLIC_CLUEBASE_PROJECT_KEY!,
 });
 
@@ -18,16 +17,19 @@ cluebase.identify(user.id, { name: user.name });
 cluebase.group("organization", organization.id, { name: organization.name });
 ```
 
-For Vite, use `import.meta.env.VITE_CLUEBASE_API_BASE_URL` and
-`import.meta.env.VITE_CLUEBASE_PROJECT_KEY`. For React apps that use the
-Create React App env contract, use `process.env.REACT_APP_CLUEBASE_API_BASE_URL`
-and `process.env.REACT_APP_CLUEBASE_PROJECT_KEY`. Other frontend frameworks should
-use the public env names generated by Cluebase setup.
+For Vite, use `import.meta.env.VITE_CLUEBASE_PROJECT_KEY`. For React apps that
+use the Create React App env contract, use
+`process.env.REACT_APP_CLUEBASE_PROJECT_KEY`. Other frontend frameworks should
+use the public project-key env name generated by Cluebase setup.
+
+`endpoint` is optional and defaults to `https://api.cluebase.io`. Set it only
+when the SDK must send to another Cluebase API base URL, such as a local
+environment.
 
 `projectKey` is the public ingest key. The API resolves authoritative
-`tenantId`, `projectId`, and dev/prod `ProjectService` from that key. `endpoint`
-is the Cluebase API base URL. The SDK appends `/api/v1/ingest/browser-tokens` and
-the canonical browser observation batch path internally.
+`tenantId`, `projectId`, and dev/prod `ProjectService` from that key. The SDK
+appends `/api/v1/ingest/browser-tokens` and the canonical browser observation
+batch path internally.
 
 ## Responsibility boundary
 

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

@@ -9,6 +9,8 @@
 export const CLUEBASE_CORRELATION_ATTRIBUTE_KEYS = new Set([
     "cluebase.actor.anonymous_id",
     "cluebase.actor.user_id",
+    "cluebase.action.id",
+    "cluebase.action_id",
     "cluebase.interaction.id",
     "cluebase.interaction_id",
     "cluebase.organization.id",
@@ -26,6 +28,8 @@ export const CLUEBASE_CORRELATION_ATTRIBUTE_KEYS = new Set([
     "cluebase.tab.id",
     "cluebase.tab_id",
     "cluebase.trace_id",
+    "http.request.header.x-cluebase-action-id",
+    "http.request.header.x_cluebase_action_id",
     "enduser.id",
     "mcp.client.name",
     "mcp.client.version",

package/dist/_generated/otel-span-conversion.d.ts

@@ -1,48 +1,14 @@
-/**
- * 計測の区間 (span) を送信の形へ移す時の、時刻と属性の読み方の**正本**。
- *
- * ここは配る部品 2 つ（サーバー側・画面側）へ**書き出される元**です。
- * `scripts/generate-shared-contract-tables.mjs` が、この中身をそのまま
- * 各部品の `src/_generated/otel-span-conversion.ts` へ出します。
- * 出した先を手で直しても、`--check` が落とします。
- *
- * なぜ写しではなく生成なのか。配る部品は顧客の手元で `tsc` だけで組み立てられ、
- * まとめ込み (bundle) をしません。社内の共有部品は `private` なので、
- * 「配る部品から共有部品を取り込む」形は取れません（顧客の手元で解決できない
- * 取り込みになります）。**これが写しが存在していた理由です。**
- *
- * 中身の型を計測の枠組みから取らず、必要な形だけを書いています。そうしないと、
- * 出した先の 2 つで属性の型の名前が違う（`SdkSignalAttributes` と
- * `CanonicalJsonObject`）ため、同じ 1 つの文章にできません。
- */
-/** 計測の枠組みが渡す時刻。[秒, ナノ秒] の 2 つ組。 */
 type SpanHrTime = readonly [number, number] | undefined;
-/** 属性の入れ物。中身の型は読む側が決めるので、ここでは問いません。 */
 type SpanAttributes = {
     readonly [key: string]: unknown;
 };
-/** 親の区間を持つかもしれない区間。 */
 type SpanWithParent = {
     readonly parentSpanContext?: {
         readonly spanId?: string;
     };
 };
-/**
- * 時刻をナノ秒の文字列にする。
- *
- * 時刻が無い・数でない場合は「いま」で埋める。**送る形が壊れるより、
- * 近い時刻で送るほうがよい**（受け取る側は時刻の欠けを直せない）。
- */
 export declare function hrTimeToUnixNano(time: SpanHrTime): string;
-/** ナノ秒の文字列を、読める時刻の文字列にする。 */
 export declare function nanosToIso(nanos: string): string;
-/** 属性から「中身のある文字列」を取り出す。空白だけなら無いものとして扱う。 */
 export declare function attrString(attributes: SpanAttributes, key: string): string | null;
-/**
- * 親の区間の識別子。
- *
- * 属性に明示されていればそれを採る。計測の枠組みが持つ親より属性を優先するのは、
- * 画面と受付をまたぐ繋がりを、こちらで組み直して入れているため。
- */
 export declare function parentSpanId(span: SpanWithParent, attributes: SpanAttributes): string | null;
 export {};

package/dist/_generated/otel-span-conversion.js

@@ -5,29 +5,6 @@
 //
 // 正本を直したらこの file も一緒に commit してください。CI が
 // `node scripts/generate-shared-contract-tables.mjs --check` で照合し、ずれていれば落とします。
-/**
- * 計測の区間 (span) を送信の形へ移す時の、時刻と属性の読み方の**正本**。
- *
- * ここは配る部品 2 つ（サーバー側・画面側）へ**書き出される元**です。
- * `scripts/generate-shared-contract-tables.mjs` が、この中身をそのまま
- * 各部品の `src/_generated/otel-span-conversion.ts` へ出します。
- * 出した先を手で直しても、`--check` が落とします。
- *
- * なぜ写しではなく生成なのか。配る部品は顧客の手元で `tsc` だけで組み立てられ、
- * まとめ込み (bundle) をしません。社内の共有部品は `private` なので、
- * 「配る部品から共有部品を取り込む」形は取れません（顧客の手元で解決できない
- * 取り込みになります）。**これが写しが存在していた理由です。**
- *
- * 中身の型を計測の枠組みから取らず、必要な形だけを書いています。そうしないと、
- * 出した先の 2 つで属性の型の名前が違う（`SdkSignalAttributes` と
- * `CanonicalJsonObject`）ため、同じ 1 つの文章にできません。
- */
-/**
- * 時刻をナノ秒の文字列にする。
- *
- * 時刻が無い・数でない場合は「いま」で埋める。**送る形が壊れるより、
- * 近い時刻で送るほうがよい**（受け取る側は時刻の欠けを直せない）。
- */
 export function hrTimeToUnixNano(time) {
     if (!time)
         return `${Date.now()}000000`;
@@ -37,7 +14,6 @@ export function hrTimeToUnixNano(time) {
     }
     return (BigInt(seconds) * 1000000000n + BigInt(nanos)).toString();
 }
-/** ナノ秒の文字列を、読める時刻の文字列にする。 */
 export function nanosToIso(nanos) {
     try {
         const ms = Number(BigInt(nanos) / 1000000n);
@@ -45,23 +21,15 @@ export function nanosToIso(nanos) {
             return new Date(ms).toISOString();
     }
     catch {
-        // 試験の身代わりが壊れた時刻を渡すことがある。送る形は保つ。
     }
     return new Date().toISOString();
 }
-/** 属性から「中身のある文字列」を取り出す。空白だけなら無いものとして扱う。 */
 export function attrString(attributes, key) {
     const value = attributes[key];
     return typeof value === "string" && value.trim().length > 0
         ? value.trim()
         : null;
 }
-/**
- * 親の区間の識別子。
- *
- * 属性に明示されていればそれを採る。計測の枠組みが持つ親より属性を優先するのは、
- * 画面と受付をまたぐ繋がりを、こちらで組み直して入れているため。
- */
 export function parentSpanId(span, attributes) {
     return (attrString(attributes, "cluebase.parent_span_id") ??
         span.parentSpanContext?.spanId ??

package/dist/context/action-context.d.ts

@@ -0,0 +1,39 @@
+export type ActionContextSnapshot = {
+    actionId: string | null;
+    interactionId: string;
+    interactionInitiator: string | null;
+    interactionStartEventKind: string | null;
+    targetStableKey: string | null;
+    formKey: string | null;
+    interactionScopeKind: string | null;
+    interactionScopeKey: string | null;
+    traceId: string;
+    activeSpanId: string | null;
+};
+export declare class PrivateActionContextManager {
+    private readonly readAmbientContext;
+    private current;
+    private synchronousEventContext;
+    private synchronousEventGeneration;
+    private enabled;
+    private eventContexts;
+    private eventRegistrations;
+    private eventCleanups;
+    private restoreFunctions;
+    private ownedWrapperRecords;
+    constructor(readAmbientContext: () => ActionContextSnapshot | null);
+    enable(): void;
+    disable(): void;
+    getCurrent(): ActionContextSnapshot | null;
+    getSynchronousEventContext(): ActionContextSnapshot | null;
+    isEnabled(): boolean;
+    bindEvent(event: Event): void;
+    run<T>(snapshot: ActionContextSnapshot, callback: () => T): T;
+    private capture;
+    private wrapCallback;
+    private ownWrapper;
+    private patchPromiseCallbacks;
+    private patchTimerCallbacks;
+    private patchGlobalCallback;
+    private patchEventCallbacks;
+}

package/dist/context/action-context.js

@@ -0,0 +1,298 @@
+const ownedWrappers = new WeakMap();
+const resolveRestoredFunction = (candidate) => {
+    let current = candidate;
+    let record = ownedWrappers.get(current);
+    while (record && !record.active) {
+        current = record.original;
+        record = ownedWrappers.get(current);
+    }
+    return current;
+};
+const captureFlag = (options) => typeof options === "boolean" ? options : options?.capture === true;
+const isCallable = (value) => typeof value === "function";
+const invokeListener = (listener, thisValue, event) => {
+    if (typeof listener === "function") {
+        return listener.call(thisValue, event);
+    }
+    return listener.handleEvent.call(listener, event);
+};
+export class PrivateActionContextManager {
+    constructor(readAmbientContext) {
+        this.readAmbientContext = readAmbientContext;
+        this.current = null;
+        this.synchronousEventContext = null;
+        this.synchronousEventGeneration = 0;
+        this.enabled = false;
+        this.eventContexts = new WeakMap();
+        this.eventRegistrations = new WeakMap();
+        this.eventCleanups = [];
+        this.restoreFunctions = [];
+        this.ownedWrapperRecords = [];
+    }
+    enable() {
+        if (this.enabled)
+            return;
+        this.enabled = true;
+        this.patchPromiseCallbacks();
+        this.patchTimerCallbacks();
+        this.patchEventCallbacks();
+    }
+    disable() {
+        if (!this.enabled)
+            return;
+        this.enabled = false;
+        for (const record of this.ownedWrapperRecords)
+            record.active = false;
+        for (const cleanup of this.eventCleanups.splice(0))
+            cleanup();
+        for (let index = this.restoreFunctions.length - 1; index >= 0; index -= 1) {
+            this.restoreFunctions[index]?.();
+        }
+        this.restoreFunctions = [];
+        this.eventRegistrations = new WeakMap();
+        this.eventContexts = new WeakMap();
+        this.current = null;
+        this.synchronousEventContext = null;
+        this.synchronousEventGeneration += 1;
+        this.ownedWrapperRecords = [];
+    }
+    getCurrent() {
+        return this.current;
+    }
+    getSynchronousEventContext() {
+        return this.synchronousEventContext;
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    bindEvent(event) {
+        const snapshot = this.current ?? this.readAmbientContext();
+        if (!snapshot)
+            return;
+        this.eventContexts.set(event, snapshot);
+        this.synchronousEventContext = snapshot;
+        const generation = ++this.synchronousEventGeneration;
+        void Promise.resolve().then(() => {
+            if (generation !== this.synchronousEventGeneration)
+                return;
+            this.synchronousEventContext = null;
+        });
+    }
+    run(snapshot, callback) {
+        const previous = this.current;
+        this.current = snapshot;
+        try {
+            return callback();
+        }
+        finally {
+            this.current = previous;
+        }
+    }
+    capture() {
+        return this.current;
+    }
+    wrapCallback(callback, snapshot) {
+        if (!snapshot || !isCallable(callback))
+            return callback;
+        const manager = this;
+        return function (...args) {
+            if (!manager.enabled)
+                return callback.apply(this, args);
+            return manager.run(snapshot, () => callback.apply(this, args));
+        };
+    }
+    ownWrapper(wrapper, original) {
+        const record = { original, active: true };
+        ownedWrappers.set(wrapper, record);
+        this.ownedWrapperRecords.push(record);
+    }
+    patchPromiseCallbacks() {
+        const manager = this;
+        const promisePrototype = Promise.prototype;
+        for (const method of ["then", "catch", "finally"]) {
+            const original = promisePrototype[method];
+            if (!isCallable(original))
+                continue;
+            const wrapped = function (...args) {
+                if (!manager.enabled)
+                    return original.call(this, ...args);
+                const snapshot = manager.capture();
+                if (method === "finally") {
+                    return original.call(this, manager.wrapCallback(args[0], snapshot));
+                }
+                return original.call(this, manager.wrapCallback(args[0], snapshot), manager.wrapCallback(args[1], snapshot));
+            };
+            Object.defineProperty(promisePrototype, method, {
+                configurable: true,
+                enumerable: false,
+                writable: true,
+                value: wrapped,
+            });
+            this.ownWrapper(wrapped, original);
+            this.restoreFunctions.push(() => {
+                if (promisePrototype[method] === wrapped) {
+                    Object.defineProperty(promisePrototype, method, {
+                        configurable: true,
+                        enumerable: false,
+                        writable: true,
+                        value: resolveRestoredFunction(original),
+                    });
+                }
+            });
+        }
+    }
+    patchTimerCallbacks() {
+        const globalObject = globalThis;
+        this.patchGlobalCallback("setTimeout", globalObject, "setTimeout");
+        this.patchGlobalCallback("setInterval", globalObject, "setInterval");
+        this.patchGlobalCallback("queueMicrotask", globalObject, "queueMicrotask");
+        this.patchGlobalCallback("requestAnimationFrame", globalObject, "requestAnimationFrame");
+        this.patchGlobalCallback("requestIdleCallback", globalObject, "requestIdleCallback");
+        this.patchGlobalCallback("setImmediate", globalObject, "setImmediate");
+    }
+    patchGlobalCallback(property, globalObject, methodName) {
+        const original = globalObject[property];
+        if (!isCallable(original))
+            return;
+        const manager = this;
+        const wrapped = function (...args) {
+            if (!manager.enabled)
+                return original.call(this, ...args);
+            const snapshot = manager.capture();
+            if (methodName === "queueMicrotask") {
+                return original.call(this, manager.wrapCallback(args[0], snapshot));
+            }
+            return original.call(this, manager.wrapCallback(args[0], snapshot), ...args.slice(1));
+        };
+        globalObject[property] = wrapped;
+        this.ownWrapper(wrapped, original);
+        this.restoreFunctions.push(() => {
+            if (globalObject[property] === wrapped) {
+                globalObject[property] =
+                    resolveRestoredFunction(original);
+            }
+        });
+    }
+    patchEventCallbacks() {
+        if (typeof EventTarget === "undefined")
+            return;
+        const prototype = EventTarget.prototype;
+        const originalAdd = prototype.addEventListener;
+        const originalRemove = prototype.removeEventListener;
+        const manager = this;
+        const wrappedAdd = function (type, listener, options) {
+            if (!manager.enabled) {
+                originalAdd.call(this, type, listener, options);
+                return;
+            }
+            if (!listener) {
+                originalAdd.call(this, type, listener, options);
+                return;
+            }
+            const registrations = manager.eventRegistrations.get(this) ?? [];
+            if (registrations.some((registration) => registration.type === type &&
+                registration.listener === listener &&
+                captureFlag(registration.options) === captureFlag(options))) {
+                return;
+            }
+            if (typeof options === "object" &&
+                options !== null &&
+                options.signal?.aborted) {
+                originalAdd.call(this, type, listener, options);
+                return;
+            }
+            const registrationSnapshot = manager.capture();
+            const target = this;
+            const wrappedListener = function (event) {
+                const eventSnapshot = manager.eventContexts.get(event);
+                const snapshot = eventSnapshot ?? registrationSnapshot;
+                if (!manager.enabled)
+                    return invokeListener(listener, this, event);
+                if (!snapshot)
+                    return invokeListener(listener, this, event);
+                return manager.run(snapshot, () => invokeListener(listener, this, event));
+            };
+            let registration;
+            const abortHandler = () => registration.cleanup();
+            const cleanup = () => {
+                if (registration.removed)
+                    return;
+                registration.removed = true;
+                originalRemove.call(target, type, wrappedListener, options);
+                const currentRegistrations = manager.eventRegistrations.get(target) ?? [];
+                const registrationIndex = currentRegistrations.indexOf(registration);
+                if (registrationIndex >= 0)
+                    currentRegistrations.splice(registrationIndex, 1);
+                const cleanupIndex = manager.eventCleanups.indexOf(cleanup);
+                if (cleanupIndex >= 0)
+                    manager.eventCleanups.splice(cleanupIndex, 1);
+                if (typeof options === "object" && options?.signal) {
+                    originalRemove.call(options.signal, "abort", abortHandler);
+                }
+            };
+            registration = {
+                type,
+                listener,
+                wrapped: wrappedListener,
+                options,
+                cleanup,
+                removed: false,
+            };
+            originalAdd.call(target, type, wrappedListener, options);
+            registrations.push(registration);
+            manager.eventCleanups.push(cleanup);
+            manager.eventRegistrations.set(target, registrations);
+            if (typeof options === "object" && options?.signal) {
+                originalAdd.call(options.signal, "abort", abortHandler, { once: true });
+            }
+        };
+        const wrappedRemove = function (type, listener, options) {
+            if (!manager.enabled) {
+                originalRemove.call(this, type, listener, options);
+                return;
+            }
+            if (!listener) {
+                originalRemove.call(this, type, listener, options);
+                return;
+            }
+            const registrations = manager.eventRegistrations.get(this) ?? [];
+            const index = registrations.findIndex((registration) => registration.type === type &&
+                registration.listener === listener &&
+                captureFlag(registration.options) === captureFlag(options));
+            if (index < 0) {
+                originalRemove.call(this, type, listener, options);
+                return;
+            }
+            const registration = registrations[index];
+            registrations.splice(index, 1);
+            const cleanupIndex = manager.eventCleanups.indexOf(registration.cleanup);
+            if (cleanupIndex >= 0)
+                manager.eventCleanups.splice(cleanupIndex, 1);
+            registration.cleanup();
+        };
+        Object.defineProperty(prototype, "addEventListener", {
+            configurable: true,
+            value: wrappedAdd,
+        });
+        Object.defineProperty(prototype, "removeEventListener", {
+            configurable: true,
+            value: wrappedRemove,
+        });
+        this.ownWrapper(wrappedAdd, originalAdd);
+        this.ownWrapper(wrappedRemove, originalRemove);
+        this.restoreFunctions.push(() => {
+            if (prototype.addEventListener === wrappedAdd) {
+                Object.defineProperty(prototype, "addEventListener", {
+                    configurable: true,
+                    value: resolveRestoredFunction(originalAdd),
+                });
+            }
+            if (prototype.removeEventListener === wrappedRemove) {
+                Object.defineProperty(prototype, "removeEventListener", {
+                    configurable: true,
+                    value: resolveRestoredFunction(originalRemove),
+                });
+            }
+        });
+    }
+}

package/dist/context/browser-storage.d.ts

@@ -1,15 +1,3 @@
-/**
- * 画面側の保管先を 1 か所で決める。
- *
- * 4 つの入れ物（利用者・組織・滞在・タブ）が同じ「使えるか試して、駄目なら
- * メモリへ落とす」規則をそれぞれ持っていた。規則が 4 通りに分かれると、
- * 5 つ目の入れ物を足す人がどれを写すか選べない（CLAUDE.md §3）。
- */
 export type StorageLike = Pick<Storage, "getItem" | "setItem" | "removeItem">;
-/** 保管先が使えないときの落とし先。ページを離れると消える。 */
 export declare const createMemoryStorage: () => StorageLike;
-/**
- * 実際に 1 度書いて消してみてから返す。存在の確認だけでは足りない
- * （private browsing や容量上限では、存在しても `setItem` が投げる）。
- */
 export declare const resolveWebStorage: (kind: "local" | "session", probeKey: string) => StorageLike;

package/dist/context/browser-storage.js

@@ -1,11 +1,3 @@
-/**
- * 画面側の保管先を 1 か所で決める。
- *
- * 4 つの入れ物（利用者・組織・滞在・タブ）が同じ「使えるか試して、駄目なら
- * メモリへ落とす」規則をそれぞれ持っていた。規則が 4 通りに分かれると、
- * 5 つ目の入れ物を足す人がどれを写すか選べない（CLAUDE.md §3）。
- */
-/** 保管先が使えないときの落とし先。ページを離れると消える。 */
 export const createMemoryStorage = () => {
     const store = new Map();
     return {
@@ -18,10 +10,6 @@ export const createMemoryStorage = () => {
         },
     };
 };
-/**
- * 実際に 1 度書いて消してみてから返す。存在の確認だけでは足りない
- * （private browsing や容量上限では、存在しても `setItem` が投げる）。
- */
 export const resolveWebStorage = (kind, probeKey) => {
     try {
         const storage = kind === "local" ? globalThis.localStorage : globalThis.sessionStorage;
@@ -32,7 +20,6 @@ export const resolveWebStorage = (kind, probeKey) => {
         }
     }
     catch {
-        // Ignore and fallback.
     }
     return createMemoryStorage();
 };

package/dist/context/identity.js

@@ -90,7 +90,6 @@ export class IdentityManager {
             this.storage.setItem(STORAGE_KEYS.userId, userId);
         }
         catch {
-            // Swallow to keep SDK non-blocking.
         }
     }
     clearUser() {
@@ -100,7 +99,6 @@ export class IdentityManager {
             this.storage.removeItem(STORAGE_KEYS.userId);
         }
         catch {
-            // Swallow to keep SDK non-blocking.
         }
     }
     rotateAnonymousId() {
@@ -110,7 +108,6 @@ export class IdentityManager {
             this.storage.setItem(STORAGE_KEYS.anonymousId, anonymousId);
         }
         catch {
-            // Swallow to keep SDK non-blocking.
         }
         return anonymousId;
     }
@@ -126,7 +123,6 @@ export class IdentityManager {
                 this.storage.setItem(STORAGE_KEYS.anonymousId, anonymousId);
             }
             catch {
-                // Swallow to keep SDK non-blocking.
             }
         }
         const userId = this.storage.getItem(STORAGE_KEYS.userId);

package/dist/context/organization.d.ts

@@ -6,10 +6,6 @@ export declare class OrganizationManager {
     private state;
     constructor(storage?: StorageLike);
     getContext(): OrganizationContext;
-    /**
-     * Set the MVP company context directly. Public `cluebase.group("organization")`
-     * must not create or mutate future account/workspace context.
-     */
     setOrganization(organizationId: string, traits?: ContextTraitInput): void;
     reset(): void;
     private loadState;

package/dist/context/organization.js

@@ -12,10 +12,6 @@ export class OrganizationManager {
             traits: { ...this.state.traits },
         };
     }
-    /**
-     * Set the MVP company context directly. Public `cluebase.group("organization")`
-     * must not create or mutate future account/workspace context.
-     */
     setOrganization(organizationId, traits) {
         const sanitizedTraits = sanitizeContextTraits(traits);
         this.state.organizationId = organizationId;
@@ -27,7 +23,6 @@ export class OrganizationManager {
             this.storage.setItem(STORAGE_KEYS.organizationId, organizationId);
         }
         catch {
-            // Swallow to keep SDK non-blocking.
         }
     }
     reset() {
@@ -39,7 +34,6 @@ export class OrganizationManager {
             this.storage.removeItem(STORAGE_KEYS.organizationId);
         }
         catch {
-            // Swallow to keep SDK non-blocking.
         }
     }
     loadState() {
@@ -50,7 +44,6 @@ export class OrganizationManager {
             }
         }
         catch {
-            // Swallow to keep SDK non-blocking.
         }
         return {
             organizationId,

package/dist/context/session.js

@@ -59,7 +59,6 @@ export class SessionManager {
             this.storage.setItem(STORAGE_KEYS.sessionLastActivityAt, String(nowMs));
         }
         catch {
-            // Swallow to keep SDK non-blocking.
         }
     }
     endSession(nowMs = Date.now()) {
@@ -91,7 +90,6 @@ export class SessionManager {
             this.storage.setItem(STORAGE_KEYS.sessionLastActivityAt, String(nowMs));
         }
         catch {
-            // Swallow to keep SDK non-blocking.
         }
         return sessionId;
     }
@@ -107,7 +105,6 @@ export class SessionManager {
             this.storage.removeItem(STORAGE_KEYS.sessionLastActivityAt);
         }
         catch {
-            // Swallow to keep SDK non-blocking.
         }
     }
     loadState() {