@posthog/browser-common 0.9.3 → 0.9.4

package/dist/client.d.ts

@@ -19,6 +19,8 @@ export interface SessionContext {
     readonly windowId: string;
     /** When the session started, as a Unix timestamp in milliseconds. */
     readonly sessionStartTimestamp: number;
+    /** Most recent session activity, as a Unix timestamp in milliseconds. */
+    readonly lastActivityTimestamp: number;
 }
 /** A captured event, as observed by `onEvent`. */
 export interface CapturedEventInfo {
@@ -98,8 +100,8 @@ export interface Client {
     readonly initialPersonProperties: DeepReadonly<Record<string, unknown>>;
     /** Active group memberships attached to events as `$groups`. */
     readonly groups: DeepReadonly<Record<string, string>>;
-    /** The current session, created on first read if needed. */
-    readonly session: SessionContext;
+    /** The current session, if one exists. Reading it need not create one. */
+    readonly session: SessionContext | undefined;
     /** Whether the host currently permits data capture. */
     readonly canCapture: boolean;
     /** Synchronously admits an analytics event to the client's normal pipeline. */

package/dist/config.js

@@ -27,7 +27,7 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-const packageVersion = "0.9.3";
+const packageVersion = "0.9.4";
 const Config = {
     DEBUG: false,
     LIB_VERSION: packageVersion,

package/dist/config.mjs

@@ -1,4 +1,4 @@
-const packageVersion = "0.9.3";
+const packageVersion = "0.9.4";
 const Config = {
     DEBUG: false,
     LIB_VERSION: packageVersion,

package/dist/console-logs.d.ts

@@ -0,0 +1,15 @@
+import type { BufferedConsoleEntry } from './logs-types';
+import type { CaptureLogOptions } from '@posthog/types';
+import type { LogSdkContext } from '@posthog/core';
+export interface ConsoleLogsSink {
+    captureConsoleLog(options: CaptureLogOptions): void;
+    captureBufferedConsoleLog?(options: CaptureLogOptions, context: LogSdkContext, occurredAtMs: number): void;
+}
+export interface ConsoleLogsHost {
+    console: Console;
+    hostname: string;
+    getCapturingLogs(): ConsoleLogsSink | undefined;
+}
+export declare const initializeLogs: (host: ConsoleLogsHost) => (() => void);
+/** Replays console calls the main bundle recorded before this script loaded. */
+export declare const replayConsoleBuffer: (host: ConsoleLogsHost, entries: BufferedConsoleEntry[]) => void;

package/dist/console-logs.js

@@ -0,0 +1,317 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    initializeLogs: ()=>initializeLogs,
+    replayConsoleBuffer: ()=>replayConsoleBuffer
+});
+const patch_js_namespaceObject = require("./utils/patch.js");
+const console_original_js_namespaceObject = require("./utils/console-original.js");
+const core_namespaceObject = require("@posthog/core");
+const LOG_BODY_SIZE_LIMIT = 10000;
+const LOG_ATTRIBUTES_LIMIT = 50;
+const appendWithLimit = (parts, text, budget)=>{
+    if (budget.remaining <= 0) {
+        budget.truncated = true;
+        return false;
+    }
+    if (text.length <= budget.remaining) {
+        parts.push(text);
+        budget.remaining -= text.length;
+        return true;
+    }
+    parts.push(text.slice(0, budget.remaining));
+    budget.remaining = 0;
+    budget.truncated = true;
+    return false;
+};
+const stringifyStringWithLimit = (value, parts, budget)=>{
+    const serialized = JSON.stringify(value);
+    if (serialized.length <= budget.remaining) return appendWithLimit(parts, serialized, budget);
+    budget.truncated = true;
+    if (budget.remaining < 2) return false;
+    let low = 0;
+    let high = Math.min(value.length, budget.remaining - 2);
+    while(low < high){
+        const mid = Math.ceil((low + high) / 2);
+        if (JSON.stringify(value.slice(0, mid)).length <= budget.remaining) low = mid;
+        else high = mid - 1;
+    }
+    return appendWithLimit(parts, JSON.stringify(value.slice(0, low)), budget);
+};
+const isJSONSerializablePrimitive = (value)=>void 0 !== value && 'function' != typeof value && 'symbol' != typeof value && 'bigint' != typeof value;
+const isNumberOrBoolean = (value)=>{
+    try {
+        return (0, core_namespaceObject.isNumber)(value) || (0, core_namespaceObject.isBoolean)(value);
+    } catch  {
+        return false;
+    }
+};
+const collectAttributeValue = (key, value, collector)=>{
+    if (collector.truncated) return;
+    collector.keysRemaining -= 1;
+    collector.sizeRemaining -= String(value).length + key.length;
+    if (collector.keysRemaining <= 0 || collector.sizeRemaining <= 0) {
+        collector.truncated = true;
+        collector.result['attributes_truncated'] = true;
+        return;
+    }
+    collector.result[key] = value;
+};
+const collectFlattenedAttributes = (value, key, collector)=>{
+    if (collector.truncated) return;
+    if ((0, core_namespaceObject.isObject)(value)) {
+        if (collector.seen.has(value)) return void collectAttributeValue(key || 'circular', '[Circular]', collector);
+        collector.seen.add(value);
+        try {
+            for(const childKey in value)try {
+                if (!Object.prototype.hasOwnProperty.call(value, childKey)) continue;
+                const childValue = value[childKey];
+                collectFlattenedAttributes(childValue, key ? `${key}.${childKey}` : childKey, collector);
+                if (collector.truncated) break;
+            } catch  {
+                continue;
+            }
+        } catch  {}
+        return;
+    }
+    collectAttributeValue(key, value, collector);
+};
+const stringifyValueWithLimit = (value, parts, budget, seen, inArray = false, attributeCollector)=>{
+    if (!isJSONSerializablePrimitive(value)) return inArray ? appendWithLimit(parts, 'null', budget) : true;
+    if ((0, core_namespaceObject.isNull)(value) || isNumberOrBoolean(value)) return appendWithLimit(parts, JSON.stringify(value), budget);
+    if ('string' == typeof value) return stringifyStringWithLimit(value, parts, budget);
+    if (!(0, core_namespaceObject.isObject)(value) && !(0, core_namespaceObject.isArray)(value)) return appendWithLimit(parts, JSON.stringify(value), budget);
+    if (seen.has(value)) return stringifyStringWithLimit('[Circular]', parts, budget);
+    seen.add(value);
+    try {
+        const toJSON = value.toJSON;
+        if ((0, core_namespaceObject.isFunction)(toJSON)) return stringifyValueWithLimit(toJSON.call(value), parts, budget, seen, inArray);
+    } catch  {}
+    try {
+        const objectTag = Object.prototype.toString.call(value);
+        if ('[object String]' === objectTag) return stringifyStringWithLimit(String(value.valueOf()), parts, budget);
+        if ('[object Number]' === objectTag || '[object Boolean]' === objectTag) return appendWithLimit(parts, JSON.stringify(value.valueOf()), budget);
+    } catch  {}
+    if (value instanceof Error) {
+        const errorObject = {};
+        try {
+            for(const key in value)if (Object.prototype.hasOwnProperty.call(value, key)) errorObject[key] = value[key];
+        } catch  {}
+        try {
+            errorObject.name = value.name;
+        } catch  {}
+        try {
+            errorObject.message = value.message;
+        } catch  {}
+        try {
+            errorObject.stack = value.stack;
+        } catch  {}
+        return stringifyValueWithLimit(errorObject, parts, budget, seen, inArray, attributeCollector);
+    }
+    if ((0, core_namespaceObject.isArray)(value)) {
+        if (!appendWithLimit(parts, '[', budget)) return false;
+        for(let i = 0; i < value.length; i++){
+            if (i > 0 && !appendWithLimit(parts, ',', budget)) return false;
+            let item;
+            try {
+                item = value[i];
+            } catch  {
+                item = void 0;
+            }
+            if (!stringifyValueWithLimit(item, parts, budget, seen, true)) return false;
+        }
+        return appendWithLimit(parts, ']', budget);
+    }
+    if (!appendWithLimit(parts, '{', budget)) return false;
+    let isFirst = true;
+    try {
+        for(const key in value){
+            if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+            if (budget.remaining <= 0) {
+                budget.truncated = true;
+                return false;
+            }
+            let propertyValue;
+            try {
+                propertyValue = value[key];
+            } catch  {
+                continue;
+            }
+            if (attributeCollector) try {
+                collectFlattenedAttributes(propertyValue, key, attributeCollector);
+            } catch  {}
+            if (!isJSONSerializablePrimitive(propertyValue)) continue;
+            const propertyPrefix = `${isFirst ? '' : ','}${JSON.stringify(key)}:`;
+            if (propertyPrefix.length >= budget.remaining) {
+                budget.truncated = true;
+                return false;
+            }
+            const partsBeforeProperty = parts.length;
+            const remainingBeforeProperty = budget.remaining;
+            const truncatedBeforeProperty = budget.truncated;
+            if (!appendWithLimit(parts, propertyPrefix, budget)) return false;
+            const partsBeforeValue = parts.length;
+            const serialized = stringifyValueWithLimit(propertyValue, parts, budget, seen, false);
+            const truncatedAfterValue = budget.truncated;
+            if (parts.length === partsBeforeValue) {
+                parts.length = partsBeforeProperty;
+                budget.remaining = remainingBeforeProperty;
+                budget.truncated = serialized ? truncatedBeforeProperty : truncatedAfterValue;
+                if (!serialized) return false;
+                continue;
+            }
+            isFirst = false;
+            if (!serialized) return false;
+        }
+    } catch  {}
+    return appendWithLimit(parts, '}', budget);
+};
+const stringifyArgsSafely = (args, sizeLimit)=>{
+    const parts = [];
+    const budget = {
+        remaining: sizeLimit,
+        truncated: false
+    };
+    const attributeCollector = (0, core_namespaceObject.isObject)(args[0]) ? {
+        result: {},
+        keysRemaining: LOG_ATTRIBUTES_LIMIT,
+        sizeRemaining: LOG_BODY_SIZE_LIMIT,
+        truncated: false,
+        seen: new WeakSet([
+            args[0]
+        ])
+    } : void 0;
+    for(let i = 0; i < args.length; i++){
+        if (i > 0 && !appendWithLimit(parts, ' ', budget)) break;
+        if (!stringifyValueWithLimit(args[i], parts, budget, new WeakSet(), false, 0 === i ? attributeCollector : void 0)) break;
+    }
+    return {
+        body: parts.join('') + (budget.truncated ? '...' : ''),
+        truncated: budget.truncated,
+        attributes: attributeCollector?.result || {}
+    };
+};
+const LEVEL_MAP = {
+    debug: 'debug',
+    log: 'info',
+    warn: 'warn',
+    error: 'error',
+    info: 'info'
+};
+const initializeLogs = (host)=>{
+    const console = host.console;
+    let currentHost = host;
+    const restoreConsoleMethods = [];
+    const attributes = {
+        host: host.hostname
+    };
+    let isCapturingLog = false;
+    const dispose = ()=>{
+        currentHost = void 0;
+        for (const restore of restoreConsoleMethods)try {
+            restore();
+        } catch  {}
+    };
+    try {
+        for (const level of Object.keys(LEVEL_MAP)){
+            const logWrapper = (next)=>(...args)=>{
+                    let acquiredGuard = false;
+                    try {
+                        const activeHost = currentHost;
+                        if (args.length > 0 && !isCapturingLog && activeHost) {
+                            const logs = activeHost.getCapturingLogs();
+                            if (logs) {
+                                isCapturingLog = true;
+                                acquiredGuard = true;
+                                const { body, truncated, attributes: flattenedAttributes } = stringifyArgsSafely(args, LOG_BODY_SIZE_LIMIT);
+                                const logAttributes = {
+                                    ...attributes,
+                                    ...truncated ? {
+                                        body_truncated: 'true'
+                                    } : {}
+                                };
+                                const options = {
+                                    level: LEVEL_MAP[level],
+                                    body,
+                                    attributes: {
+                                        'log.source': `console.${level}`,
+                                        ...logAttributes,
+                                        ...flattenedAttributes
+                                    }
+                                };
+                                logs.captureConsoleLog(options);
+                            }
+                        }
+                    } catch  {} finally{
+                        if (acquiredGuard) isCapturingLog = false;
+                        next.apply(console, args);
+                    }
+                };
+            const consoleBeforePatch = console[level];
+            restoreConsoleMethods.push((0, patch_js_namespaceObject.patch)(console, level, (next)=>{
+                const wrapped = logWrapper(next);
+                wrapped.__rrweb_original__ = (0, console_original_js_namespaceObject.originalConsoleMethod)(consoleBeforePatch);
+                return wrapped;
+            }));
+        }
+    } catch (error) {
+        dispose();
+        throw error;
+    }
+    return dispose;
+};
+const replayConsoleBuffer = (host, entries)=>{
+    const logs = host.getCapturingLogs();
+    if (!logs) return;
+    for (const entry of entries)try {
+        const { body, truncated, attributes: flattenedAttributes } = stringifyArgsSafely(entry.args, LOG_BODY_SIZE_LIMIT);
+        logs.captureBufferedConsoleLog?.({
+            level: LEVEL_MAP[entry.level],
+            body,
+            attributes: {
+                'log.source': `console.${entry.level}`,
+                host: host.hostname,
+                ...truncated ? {
+                    body_truncated: 'true'
+                } : {},
+                ...flattenedAttributes
+            }
+        }, entry.context, entry.occurredAtMs);
+    } catch  {}
+};
+exports.initializeLogs = __webpack_exports__.initializeLogs;
+exports.replayConsoleBuffer = __webpack_exports__.replayConsoleBuffer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initializeLogs",
+    "replayConsoleBuffer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/console-logs.mjs

@@ -0,0 +1,276 @@
+import { patch } from "./utils/patch.mjs";
+import { originalConsoleMethod } from "./utils/console-original.mjs";
+import { isArray, isBoolean, isFunction, isNull, isNumber, isObject } from "@posthog/core";
+const LOG_BODY_SIZE_LIMIT = 10000;
+const LOG_ATTRIBUTES_LIMIT = 50;
+const appendWithLimit = (parts, text, budget)=>{
+    if (budget.remaining <= 0) {
+        budget.truncated = true;
+        return false;
+    }
+    if (text.length <= budget.remaining) {
+        parts.push(text);
+        budget.remaining -= text.length;
+        return true;
+    }
+    parts.push(text.slice(0, budget.remaining));
+    budget.remaining = 0;
+    budget.truncated = true;
+    return false;
+};
+const stringifyStringWithLimit = (value, parts, budget)=>{
+    const serialized = JSON.stringify(value);
+    if (serialized.length <= budget.remaining) return appendWithLimit(parts, serialized, budget);
+    budget.truncated = true;
+    if (budget.remaining < 2) return false;
+    let low = 0;
+    let high = Math.min(value.length, budget.remaining - 2);
+    while(low < high){
+        const mid = Math.ceil((low + high) / 2);
+        if (JSON.stringify(value.slice(0, mid)).length <= budget.remaining) low = mid;
+        else high = mid - 1;
+    }
+    return appendWithLimit(parts, JSON.stringify(value.slice(0, low)), budget);
+};
+const isJSONSerializablePrimitive = (value)=>void 0 !== value && 'function' != typeof value && 'symbol' != typeof value && 'bigint' != typeof value;
+const isNumberOrBoolean = (value)=>{
+    try {
+        return isNumber(value) || isBoolean(value);
+    } catch  {
+        return false;
+    }
+};
+const collectAttributeValue = (key, value, collector)=>{
+    if (collector.truncated) return;
+    collector.keysRemaining -= 1;
+    collector.sizeRemaining -= String(value).length + key.length;
+    if (collector.keysRemaining <= 0 || collector.sizeRemaining <= 0) {
+        collector.truncated = true;
+        collector.result['attributes_truncated'] = true;
+        return;
+    }
+    collector.result[key] = value;
+};
+const collectFlattenedAttributes = (value, key, collector)=>{
+    if (collector.truncated) return;
+    if (isObject(value)) {
+        if (collector.seen.has(value)) return void collectAttributeValue(key || 'circular', '[Circular]', collector);
+        collector.seen.add(value);
+        try {
+            for(const childKey in value)try {
+                if (!Object.prototype.hasOwnProperty.call(value, childKey)) continue;
+                const childValue = value[childKey];
+                collectFlattenedAttributes(childValue, key ? `${key}.${childKey}` : childKey, collector);
+                if (collector.truncated) break;
+            } catch  {
+                continue;
+            }
+        } catch  {}
+        return;
+    }
+    collectAttributeValue(key, value, collector);
+};
+const stringifyValueWithLimit = (value, parts, budget, seen, inArray = false, attributeCollector)=>{
+    if (!isJSONSerializablePrimitive(value)) return inArray ? appendWithLimit(parts, 'null', budget) : true;
+    if (isNull(value) || isNumberOrBoolean(value)) return appendWithLimit(parts, JSON.stringify(value), budget);
+    if ('string' == typeof value) return stringifyStringWithLimit(value, parts, budget);
+    if (!isObject(value) && !isArray(value)) return appendWithLimit(parts, JSON.stringify(value), budget);
+    if (seen.has(value)) return stringifyStringWithLimit('[Circular]', parts, budget);
+    seen.add(value);
+    try {
+        const toJSON = value.toJSON;
+        if (isFunction(toJSON)) return stringifyValueWithLimit(toJSON.call(value), parts, budget, seen, inArray);
+    } catch  {}
+    try {
+        const objectTag = Object.prototype.toString.call(value);
+        if ('[object String]' === objectTag) return stringifyStringWithLimit(String(value.valueOf()), parts, budget);
+        if ('[object Number]' === objectTag || '[object Boolean]' === objectTag) return appendWithLimit(parts, JSON.stringify(value.valueOf()), budget);
+    } catch  {}
+    if (value instanceof Error) {
+        const errorObject = {};
+        try {
+            for(const key in value)if (Object.prototype.hasOwnProperty.call(value, key)) errorObject[key] = value[key];
+        } catch  {}
+        try {
+            errorObject.name = value.name;
+        } catch  {}
+        try {
+            errorObject.message = value.message;
+        } catch  {}
+        try {
+            errorObject.stack = value.stack;
+        } catch  {}
+        return stringifyValueWithLimit(errorObject, parts, budget, seen, inArray, attributeCollector);
+    }
+    if (isArray(value)) {
+        if (!appendWithLimit(parts, '[', budget)) return false;
+        for(let i = 0; i < value.length; i++){
+            if (i > 0 && !appendWithLimit(parts, ',', budget)) return false;
+            let item;
+            try {
+                item = value[i];
+            } catch  {
+                item = void 0;
+            }
+            if (!stringifyValueWithLimit(item, parts, budget, seen, true)) return false;
+        }
+        return appendWithLimit(parts, ']', budget);
+    }
+    if (!appendWithLimit(parts, '{', budget)) return false;
+    let isFirst = true;
+    try {
+        for(const key in value){
+            if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+            if (budget.remaining <= 0) {
+                budget.truncated = true;
+                return false;
+            }
+            let propertyValue;
+            try {
+                propertyValue = value[key];
+            } catch  {
+                continue;
+            }
+            if (attributeCollector) try {
+                collectFlattenedAttributes(propertyValue, key, attributeCollector);
+            } catch  {}
+            if (!isJSONSerializablePrimitive(propertyValue)) continue;
+            const propertyPrefix = `${isFirst ? '' : ','}${JSON.stringify(key)}:`;
+            if (propertyPrefix.length >= budget.remaining) {
+                budget.truncated = true;
+                return false;
+            }
+            const partsBeforeProperty = parts.length;
+            const remainingBeforeProperty = budget.remaining;
+            const truncatedBeforeProperty = budget.truncated;
+            if (!appendWithLimit(parts, propertyPrefix, budget)) return false;
+            const partsBeforeValue = parts.length;
+            const serialized = stringifyValueWithLimit(propertyValue, parts, budget, seen, false);
+            const truncatedAfterValue = budget.truncated;
+            if (parts.length === partsBeforeValue) {
+                parts.length = partsBeforeProperty;
+                budget.remaining = remainingBeforeProperty;
+                budget.truncated = serialized ? truncatedBeforeProperty : truncatedAfterValue;
+                if (!serialized) return false;
+                continue;
+            }
+            isFirst = false;
+            if (!serialized) return false;
+        }
+    } catch  {}
+    return appendWithLimit(parts, '}', budget);
+};
+const stringifyArgsSafely = (args, sizeLimit)=>{
+    const parts = [];
+    const budget = {
+        remaining: sizeLimit,
+        truncated: false
+    };
+    const attributeCollector = isObject(args[0]) ? {
+        result: {},
+        keysRemaining: LOG_ATTRIBUTES_LIMIT,
+        sizeRemaining: LOG_BODY_SIZE_LIMIT,
+        truncated: false,
+        seen: new WeakSet([
+            args[0]
+        ])
+    } : void 0;
+    for(let i = 0; i < args.length; i++){
+        if (i > 0 && !appendWithLimit(parts, ' ', budget)) break;
+        if (!stringifyValueWithLimit(args[i], parts, budget, new WeakSet(), false, 0 === i ? attributeCollector : void 0)) break;
+    }
+    return {
+        body: parts.join('') + (budget.truncated ? '...' : ''),
+        truncated: budget.truncated,
+        attributes: attributeCollector?.result || {}
+    };
+};
+const LEVEL_MAP = {
+    debug: 'debug',
+    log: 'info',
+    warn: 'warn',
+    error: 'error',
+    info: 'info'
+};
+const initializeLogs = (host)=>{
+    const console = host.console;
+    let currentHost = host;
+    const restoreConsoleMethods = [];
+    const attributes = {
+        host: host.hostname
+    };
+    let isCapturingLog = false;
+    const dispose = ()=>{
+        currentHost = void 0;
+        for (const restore of restoreConsoleMethods)try {
+            restore();
+        } catch  {}
+    };
+    try {
+        for (const level of Object.keys(LEVEL_MAP)){
+            const logWrapper = (next)=>(...args)=>{
+                    let acquiredGuard = false;
+                    try {
+                        const activeHost = currentHost;
+                        if (args.length > 0 && !isCapturingLog && activeHost) {
+                            const logs = activeHost.getCapturingLogs();
+                            if (logs) {
+                                isCapturingLog = true;
+                                acquiredGuard = true;
+                                const { body, truncated, attributes: flattenedAttributes } = stringifyArgsSafely(args, LOG_BODY_SIZE_LIMIT);
+                                const logAttributes = {
+                                    ...attributes,
+                                    ...truncated ? {
+                                        body_truncated: 'true'
+                                    } : {}
+                                };
+                                const options = {
+                                    level: LEVEL_MAP[level],
+                                    body,
+                                    attributes: {
+                                        'log.source': `console.${level}`,
+                                        ...logAttributes,
+                                        ...flattenedAttributes
+                                    }
+                                };
+                                logs.captureConsoleLog(options);
+                            }
+                        }
+                    } catch  {} finally{
+                        if (acquiredGuard) isCapturingLog = false;
+                        next.apply(console, args);
+                    }
+                };
+            const consoleBeforePatch = console[level];
+            restoreConsoleMethods.push(patch(console, level, (next)=>{
+                const wrapped = logWrapper(next);
+                wrapped.__rrweb_original__ = originalConsoleMethod(consoleBeforePatch);
+                return wrapped;
+            }));
+        }
+    } catch (error) {
+        dispose();
+        throw error;
+    }
+    return dispose;
+};
+const replayConsoleBuffer = (host, entries)=>{
+    const logs = host.getCapturingLogs();
+    if (!logs) return;
+    for (const entry of entries)try {
+        const { body, truncated, attributes: flattenedAttributes } = stringifyArgsSafely(entry.args, LOG_BODY_SIZE_LIMIT);
+        logs.captureBufferedConsoleLog?.({
+            level: LEVEL_MAP[entry.level],
+            body,
+            attributes: {
+                'log.source': `console.${entry.level}`,
+                host: host.hostname,
+                ...truncated ? {
+                    body_truncated: 'true'
+                } : {},
+                ...flattenedAttributes
+            }
+        }, entry.context, entry.occurredAtMs);
+    } catch  {}
+};
+export { initializeLogs, replayConsoleBuffer };

package/dist/extension-tokens.d.ts

@@ -0,0 +1,4 @@
+import type { PostHogFeatureFlags } from './feature-flags';
+import type { ExtensionToken } from './token';
+/** Resolve the common feature-flags API without importing its implementation. */
+export declare const FeatureFlagsCommonExtension: ExtensionToken<PostHogFeatureFlags>;