@zuplo/cli 7.7.8 → 7.7.9

package/node_modules/@posthog/core/dist/traces/otlp.js

@@ -0,0 +1,158 @@
+"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__, {
+    buildOtlpSpan: ()=>buildOtlpSpan,
+    buildOtlpTracesPayload: ()=>buildOtlpTracesPayload,
+    buildTracesResourceAttributes: ()=>buildTracesResourceAttributes,
+    msToUnixNanoString: ()=>msToUnixNanoString,
+    spanKindToOtlp: ()=>spanKindToOtlp
+});
+const external_span_js_namespaceObject = require("./span.js");
+const otlp_any_value_js_namespaceObject = require("../utils/otlp-any-value.js");
+const json_utils_js_namespaceObject = require("../utils/json-utils.js");
+const otlp_resource_js_namespaceObject = require("../utils/otlp-resource.js");
+const SPAN_KIND_TO_OTLP = {
+    internal: 1,
+    server: 2,
+    client: 3,
+    producer: 4,
+    consumer: 5
+};
+const SPAN_STATUS_TO_OTLP = {
+    ok: 1,
+    error: 2
+};
+const TRACE_FLAGS_SAMPLED = 0x01;
+const SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE = 0x100;
+const SPAN_FLAGS_CONTEXT_IS_REMOTE = 0x200;
+function spanFlags(record) {
+    const traceFlags = parseInt(record.traceFlags, 16);
+    const w3c = Number.isFinite(traceFlags) ? 0xff & traceFlags : TRACE_FLAGS_SAMPLED;
+    return w3c | SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE | (record.parentIsRemote ? SPAN_FLAGS_CONTEXT_IS_REMOTE : 0);
+}
+function wireString(value) {
+    if ('string' == typeof value) return (0, json_utils_js_namespaceObject.sanitizeString)(value);
+    try {
+        return (0, json_utils_js_namespaceObject.sanitizeString)(String(value));
+    } catch  {
+        return json_utils_js_namespaceObject.UNSERIALIZABLE_VALUE;
+    }
+}
+function spanKindToOtlp(kind) {
+    if (kind && Object.prototype.hasOwnProperty.call(SPAN_KIND_TO_OTLP, kind)) return SPAN_KIND_TO_OTLP[kind];
+    return SPAN_KIND_TO_OTLP.internal;
+}
+function msToUnixNanoString(ms) {
+    let whole = Math.floor(ms);
+    let fractionalNanos = Math.round((ms - whole) * 1e6);
+    if (fractionalNanos >= 1e6) {
+        whole += 1;
+        fractionalNanos = 0;
+    }
+    return String(whole) + String(fractionalNanos).padStart(6, '0');
+}
+function toOtlpEvent(event, logger) {
+    const encoded = {
+        name: wireString(event.name),
+        timeUnixNano: msToUnixNanoString(event.timestamp)
+    };
+    if (event.attributes) {
+        const attributes = (0, otlp_any_value_js_namespaceObject.toOtlpKeyValueList)(event.attributes, logger);
+        if (attributes.length) encoded.attributes = attributes;
+    }
+    const dropped = (0, external_span_js_namespaceObject.nonNegativeCount)(event.droppedAttributesCount);
+    if (dropped) encoded.droppedAttributesCount = dropped;
+    return encoded;
+}
+function buildOtlpSpan(record, logger) {
+    const span = {
+        traceId: record.traceId,
+        spanId: record.spanId,
+        name: wireString(record.name),
+        kind: spanKindToOtlp(record.kind),
+        startTimeUnixNano: msToUnixNanoString(record.startTime),
+        endTimeUnixNano: msToUnixNanoString(record.endTime),
+        flags: spanFlags(record)
+    };
+    if (record.parentSpanId) span.parentSpanId = record.parentSpanId;
+    if (record.traceState) span.traceState = wireString(record.traceState);
+    const attributes = (0, otlp_any_value_js_namespaceObject.toOtlpKeyValueList)(record.attributes, logger);
+    if (attributes.length) span.attributes = attributes;
+    if (record.events.length) span.events = record.events.map((event)=>toOtlpEvent(event, logger));
+    const droppedAttributes = (0, external_span_js_namespaceObject.nonNegativeCount)(record.droppedAttributesCount);
+    if (droppedAttributes) span.droppedAttributesCount = droppedAttributes;
+    const droppedEvents = (0, external_span_js_namespaceObject.nonNegativeCount)(record.droppedEventsCount);
+    if (droppedEvents) span.droppedEventsCount = droppedEvents;
+    if (record.status) span.status = {
+        code: SPAN_STATUS_TO_OTLP[record.status.code],
+        ...record.status.message && {
+            message: wireString(record.status.message)
+        }
+    };
+    return span;
+}
+function buildTracesResourceAttributes(config, sdkName, sdkVersion) {
+    return (0, otlp_resource_js_namespaceObject.buildOtlpResourceAttributes)(config, sdkName, sdkVersion);
+}
+function buildOtlpTracesPayload(spans, resourceAttributes, scopeName, scopeVersion, logger) {
+    return {
+        resourceSpans: [
+            {
+                resource: {
+                    attributes: (0, otlp_resource_js_namespaceObject.toOtlpResourceKeyValueList)(resourceAttributes, logger)
+                },
+                scopeSpans: [
+                    {
+                        scope: {
+                            name: scopeName,
+                            version: scopeVersion
+                        },
+                        spans
+                    }
+                ]
+            }
+        ]
+    };
+}
+exports.buildOtlpSpan = __webpack_exports__.buildOtlpSpan;
+exports.buildOtlpTracesPayload = __webpack_exports__.buildOtlpTracesPayload;
+exports.buildTracesResourceAttributes = __webpack_exports__.buildTracesResourceAttributes;
+exports.msToUnixNanoString = __webpack_exports__.msToUnixNanoString;
+exports.spanKindToOtlp = __webpack_exports__.spanKindToOtlp;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildOtlpSpan",
+    "buildOtlpTracesPayload",
+    "buildTracesResourceAttributes",
+    "msToUnixNanoString",
+    "spanKindToOtlp"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/node_modules/@posthog/core/dist/traces/otlp.mjs

@@ -0,0 +1,108 @@
+import { nonNegativeCount } from "./span.mjs";
+import { toOtlpKeyValueList } from "../utils/otlp-any-value.mjs";
+import { UNSERIALIZABLE_VALUE, sanitizeString } from "../utils/json-utils.mjs";
+import { buildOtlpResourceAttributes, toOtlpResourceKeyValueList } from "../utils/otlp-resource.mjs";
+const SPAN_KIND_TO_OTLP = {
+    internal: 1,
+    server: 2,
+    client: 3,
+    producer: 4,
+    consumer: 5
+};
+const SPAN_STATUS_TO_OTLP = {
+    ok: 1,
+    error: 2
+};
+const TRACE_FLAGS_SAMPLED = 0x01;
+const SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE = 0x100;
+const SPAN_FLAGS_CONTEXT_IS_REMOTE = 0x200;
+function spanFlags(record) {
+    const traceFlags = parseInt(record.traceFlags, 16);
+    const w3c = Number.isFinite(traceFlags) ? 0xff & traceFlags : TRACE_FLAGS_SAMPLED;
+    return w3c | SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE | (record.parentIsRemote ? SPAN_FLAGS_CONTEXT_IS_REMOTE : 0);
+}
+function wireString(value) {
+    if ('string' == typeof value) return sanitizeString(value);
+    try {
+        return sanitizeString(String(value));
+    } catch  {
+        return UNSERIALIZABLE_VALUE;
+    }
+}
+function spanKindToOtlp(kind) {
+    if (kind && Object.prototype.hasOwnProperty.call(SPAN_KIND_TO_OTLP, kind)) return SPAN_KIND_TO_OTLP[kind];
+    return SPAN_KIND_TO_OTLP.internal;
+}
+function msToUnixNanoString(ms) {
+    let whole = Math.floor(ms);
+    let fractionalNanos = Math.round((ms - whole) * 1e6);
+    if (fractionalNanos >= 1e6) {
+        whole += 1;
+        fractionalNanos = 0;
+    }
+    return String(whole) + String(fractionalNanos).padStart(6, '0');
+}
+function toOtlpEvent(event, logger) {
+    const encoded = {
+        name: wireString(event.name),
+        timeUnixNano: msToUnixNanoString(event.timestamp)
+    };
+    if (event.attributes) {
+        const attributes = toOtlpKeyValueList(event.attributes, logger);
+        if (attributes.length) encoded.attributes = attributes;
+    }
+    const dropped = nonNegativeCount(event.droppedAttributesCount);
+    if (dropped) encoded.droppedAttributesCount = dropped;
+    return encoded;
+}
+function buildOtlpSpan(record, logger) {
+    const span = {
+        traceId: record.traceId,
+        spanId: record.spanId,
+        name: wireString(record.name),
+        kind: spanKindToOtlp(record.kind),
+        startTimeUnixNano: msToUnixNanoString(record.startTime),
+        endTimeUnixNano: msToUnixNanoString(record.endTime),
+        flags: spanFlags(record)
+    };
+    if (record.parentSpanId) span.parentSpanId = record.parentSpanId;
+    if (record.traceState) span.traceState = wireString(record.traceState);
+    const attributes = toOtlpKeyValueList(record.attributes, logger);
+    if (attributes.length) span.attributes = attributes;
+    if (record.events.length) span.events = record.events.map((event)=>toOtlpEvent(event, logger));
+    const droppedAttributes = nonNegativeCount(record.droppedAttributesCount);
+    if (droppedAttributes) span.droppedAttributesCount = droppedAttributes;
+    const droppedEvents = nonNegativeCount(record.droppedEventsCount);
+    if (droppedEvents) span.droppedEventsCount = droppedEvents;
+    if (record.status) span.status = {
+        code: SPAN_STATUS_TO_OTLP[record.status.code],
+        ...record.status.message && {
+            message: wireString(record.status.message)
+        }
+    };
+    return span;
+}
+function buildTracesResourceAttributes(config, sdkName, sdkVersion) {
+    return buildOtlpResourceAttributes(config, sdkName, sdkVersion);
+}
+function buildOtlpTracesPayload(spans, resourceAttributes, scopeName, scopeVersion, logger) {
+    return {
+        resourceSpans: [
+            {
+                resource: {
+                    attributes: toOtlpResourceKeyValueList(resourceAttributes, logger)
+                },
+                scopeSpans: [
+                    {
+                        scope: {
+                            name: scopeName,
+                            version: scopeVersion
+                        },
+                        spans
+                    }
+                ]
+            }
+        ]
+    };
+}
+export { buildOtlpSpan, buildOtlpTracesPayload, buildTracesResourceAttributes, msToUnixNanoString, spanKindToOtlp };

package/node_modules/@posthog/core/dist/traces/sanitize.d.ts

@@ -0,0 +1,32 @@
+import type { Logger } from '../types';
+import type { SpanTimeInput } from '@posthog/types';
+/**
+ * Span and event names must be non-empty. An empty or non-string name is
+ * replaced rather than dropped, so a mis-instrumented call site loses its name,
+ * not its span. `label` names what is being sanitized in the warning.
+ */
+export declare function sanitizeName(name: unknown, label: string, maxLength: number, logger?: Logger): string;
+/**
+ * Normalizes a caller-supplied time to a millisecond epoch.
+ *
+ * Returns `undefined` for anything unusable — the wrong type, `NaN`, or outside
+ * the representable range — leaving the caller to fall back to a derived time.
+ */
+export declare function toEpochMs(value: SpanTimeInput | undefined): number | undefined;
+/**
+ * Resolves a caller-supplied start time, warning when it is deep enough in the
+ * past that the server will clamp it.
+ */
+export declare function resolveStartTime(value: SpanTimeInput | undefined, now: number, logger?: Logger): number;
+/**
+ * Corrects an end time that precedes its start, producing a zero-duration span
+ * rather than a negative one the server would reject.
+ */
+export declare function clampEndTime(endTime: number, startTime: number): number;
+/**
+ * Keeps a caller-supplied end or event time inside the representable range,
+ * falling back to the span's own clock basis when it is unusable. `label` names
+ * what is being sanitized in the warning.
+ */
+export declare function resolveSuppliedTime(value: SpanTimeInput | undefined, derived: number, label: string, logger?: Logger): number;
+//# sourceMappingURL=sanitize.d.ts.map

package/node_modules/@posthog/core/dist/traces/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/traces/sanitize.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACtC,OAAO,KAAK,EAAkB,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAanE;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CASrG;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,aAAa,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAoB9E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAkBvG;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,aAAa,GAAG,SAAS,EAChC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CASR"}

package/node_modules/@posthog/core/dist/traces/sanitize.js

@@ -0,0 +1,93 @@
+"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__);
+const FALLBACK_SPAN_NAME = 'unknown';
+const MAX_TIMESTAMP_MS = 9223372036854;
+const MIN_TIMESTAMP_MS = 0;
+const DEEP_BACKDATE_WARNING_MS = 86400000;
+function sanitizeName(name, label, maxLength, logger) {
+    if ('string' == typeof name && name.trim()) return name.length > maxLength ? name.slice(0, maxLength) : name;
+    logger?.debug(`${label} must be a non-empty string; using "${FALLBACK_SPAN_NAME}"`);
+    return FALLBACK_SPAN_NAME;
+}
+function toEpochMs(value) {
+    if (null == value) return;
+    let ms = value;
+    if (value instanceof Date) try {
+        ms = value.getTime();
+    } catch  {
+        return;
+    }
+    if ('number' != typeof ms || !Number.isFinite(ms)) return;
+    if (ms < MIN_TIMESTAMP_MS || ms > MAX_TIMESTAMP_MS) return;
+    return ms;
+}
+function resolveStartTime(value, now, logger) {
+    const supplied = toEpochMs(value);
+    if (void 0 === supplied) {
+        if (void 0 !== value) logger?.debug('Span startTime is out of range or not a valid time; using the current time');
+        return now;
+    }
+    if (now - supplied > DEEP_BACKDATE_WARNING_MS) logger?.debug('Span startTime is more than 24 hours in the past; the server will clamp it to receive time and keep the original in $originalTimestamp');
+    else if (supplied > now) logger?.debug('Span startTime is in the future; the span may export with a zero duration');
+    return supplied;
+}
+function clampEndTime(endTime, startTime) {
+    return endTime < startTime ? startTime : endTime;
+}
+function resolveSuppliedTime(value, derived, label, logger) {
+    const supplied = toEpochMs(value);
+    if (void 0 === supplied) {
+        if (void 0 !== value) logger?.debug(`Span ${label} is out of range or not a valid time; using the derived time`);
+        return derived;
+    }
+    return supplied;
+}
+__webpack_require__.d(__webpack_exports__, {
+    clampEndTime: ()=>clampEndTime,
+    resolveStartTime: ()=>resolveStartTime,
+    resolveSuppliedTime: ()=>resolveSuppliedTime,
+    sanitizeName: ()=>sanitizeName,
+    toEpochMs: ()=>toEpochMs
+});
+exports.clampEndTime = __webpack_exports__.clampEndTime;
+exports.resolveStartTime = __webpack_exports__.resolveStartTime;
+exports.resolveSuppliedTime = __webpack_exports__.resolveSuppliedTime;
+exports.sanitizeName = __webpack_exports__.sanitizeName;
+exports.toEpochMs = __webpack_exports__.toEpochMs;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "clampEndTime",
+    "resolveStartTime",
+    "resolveSuppliedTime",
+    "sanitizeName",
+    "toEpochMs"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/node_modules/@posthog/core/dist/traces/sanitize.mjs

@@ -0,0 +1,43 @@
+const FALLBACK_SPAN_NAME = 'unknown';
+const MAX_TIMESTAMP_MS = 9223372036854;
+const MIN_TIMESTAMP_MS = 0;
+const DEEP_BACKDATE_WARNING_MS = 86400000;
+function sanitizeName(name, label, maxLength, logger) {
+    if ('string' == typeof name && name.trim()) return name.length > maxLength ? name.slice(0, maxLength) : name;
+    logger?.debug(`${label} must be a non-empty string; using "${FALLBACK_SPAN_NAME}"`);
+    return FALLBACK_SPAN_NAME;
+}
+function toEpochMs(value) {
+    if (null == value) return;
+    let ms = value;
+    if (value instanceof Date) try {
+        ms = value.getTime();
+    } catch  {
+        return;
+    }
+    if ('number' != typeof ms || !Number.isFinite(ms)) return;
+    if (ms < MIN_TIMESTAMP_MS || ms > MAX_TIMESTAMP_MS) return;
+    return ms;
+}
+function resolveStartTime(value, now, logger) {
+    const supplied = toEpochMs(value);
+    if (void 0 === supplied) {
+        if (void 0 !== value) logger?.debug('Span startTime is out of range or not a valid time; using the current time');
+        return now;
+    }
+    if (now - supplied > DEEP_BACKDATE_WARNING_MS) logger?.debug('Span startTime is more than 24 hours in the past; the server will clamp it to receive time and keep the original in $originalTimestamp');
+    else if (supplied > now) logger?.debug('Span startTime is in the future; the span may export with a zero duration');
+    return supplied;
+}
+function clampEndTime(endTime, startTime) {
+    return endTime < startTime ? startTime : endTime;
+}
+function resolveSuppliedTime(value, derived, label, logger) {
+    const supplied = toEpochMs(value);
+    if (void 0 === supplied) {
+        if (void 0 !== value) logger?.debug(`Span ${label} is out of range or not a valid time; using the derived time`);
+        return derived;
+    }
+    return supplied;
+}
+export { clampEndTime, resolveStartTime, resolveSuppliedTime, sanitizeName, toEpochMs };

package/node_modules/@posthog/core/dist/traces/span.d.ts

@@ -0,0 +1,189 @@
+import type { Span, SpanAttributes, SpanAttributeValue, SpanKind, SpanStatusCode, SpanTimeInput } from '@posthog/types';
+import type { Logger } from '../types';
+import type { SpanContextManager, SpanRecord } from './types';
+/**
+ * A monotonic millisecond reading where the platform has one, so an NTP
+ * correction mid-span can't produce a negative duration.
+ */
+export declare function monotonicNow(): number | undefined;
+export interface SpanInit {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    traceState?: string;
+    /** The trace-flags byte to propagate; the inbound one when continuing a remote trace. */
+    traceFlags?: string;
+    /** True when the parent came from a `traceparent` header rather than a local handle. */
+    parentIsRemote?: boolean;
+    name: string;
+    kind: SpanKind;
+    attributes: SpanAttributes;
+    /** ms epoch. */
+    startTime: number;
+    /** True when the caller supplied an explicit `startTime`. */
+    backdated: boolean;
+    /** Keys the SDK attached itself. Exempt from the attribute cap and never evicted. */
+    autoAttributeKeys: string[];
+    maxAttributes: number;
+    maxEvents: number;
+    maxAttributesPerEvent: number;
+    maxAttributeValueLength: number;
+}
+export declare class PostHogSpan implements Span {
+    private readonly _onEnd;
+    private readonly _logger?;
+    private readonly _traceId;
+    private readonly _spanId;
+    private readonly _parentSpanId?;
+    private readonly _traceState?;
+    private readonly _traceFlags;
+    private readonly _parentIsRemote;
+    private readonly _startTime;
+    private readonly _startMono?;
+    private _name;
+    private _kind;
+    private _attributes;
+    private _events;
+    private _status?;
+    private _ended;
+    private readonly _autoKeys;
+    private readonly _maxAttributes;
+    private readonly _maxEvents;
+    private readonly _maxAttributesPerEvent;
+    private readonly _maxAttributeValueLength;
+    private _userAttributeCount;
+    private _userEventCount;
+    private _droppedAttributes;
+    private _droppedEvents;
+    constructor(init: SpanInit, _onEnd: (record: SpanRecord, autoKeys: ReadonlySet<string>) => void, _logger?: Logger | undefined);
+    /**
+     * "Now" on this span's clock basis: start plus monotonic elapsed where we
+     * have it, wall clock otherwise.
+     */
+    private _now;
+    /** Guards every mutator: operations after `end()` no-op with a debug warning. */
+    private _mutable;
+    /**
+     * Writes an attribute unless the span is already at its user-attribute cap.
+     *
+     * Overwriting a key already on the span always succeeds — the cap counts
+     * distinct user keys, not writes — and SDK-attached keys never count toward
+     * it, so a span at the cap still carries its person and session ids.
+     */
+    private _writeAttribute;
+    setAttribute(key: string, value: SpanAttributeValue): this;
+    setAttributes(attributes: SpanAttributes): this;
+    addEvent(name: string, attributes?: SpanAttributes, timestamp?: SpanTimeInput): this;
+    setStatus(status: SpanStatusCode, message?: string): this;
+    /** True when the caller explicitly marked the span `ok`; `withSpan` treats that as final. */
+    get statusIsExplicitlyOk(): boolean;
+    recordException(error: unknown): this;
+    updateName(name: string): this;
+    traceparent(): string | null;
+    tracestate(): string | null;
+    /** Context a child span inherits when this handle is its parent. */
+    childContext(): {
+        traceId: string;
+        parentSpanId: string;
+        traceState?: string;
+        traceFlags: string;
+    };
+    end(endTime?: SpanTimeInput): void;
+}
+/**
+ * A caller-visible counter read back as a number, or 0 for anything else.
+ * Clamped to the `uint32` the OTLP field is declared as: a `beforeSpanSend` hook
+ * can write a larger number onto an event, and one that overflows the field is
+ * refused for the whole request.
+ */
+export declare function nonNegativeCount(value: unknown): number;
+/**
+ * Re-applies the per-span caps to a record a `beforeSpanSend` hook has already
+ * seen. The hook writes to the plain record, not through the span's own guarded
+ * writer, so an enriching hook would otherwise push a span past the cap it was
+ * trimmed to and back into the 413 path the cap exists to avoid.
+ *
+ * Earliest-set entries win, matching the span-side rule; SDK-attached keys are
+ * exempt. Counts add to whatever the span already dropped.
+ */
+export declare function applySpanLimits(record: SpanRecord, autoKeys: ReadonlySet<string>, maxAttributes: number, maxEvents: number, maxAttributesPerEvent: number, maxAttributeValueLength: number, keysBeforeHook?: readonly string[]): void;
+/**
+ * An inert handle returned whenever tracing cannot run — traces unconfigured,
+ * SDK disabled, user opted out. Supports the full surface so caller code never
+ * branches, and returns `null` from `traceparent()` so an id this SDK never
+ * recorded cannot propagate.
+ */
+export declare class NoopSpan implements Span {
+    setAttribute(): this;
+    setAttributes(): this;
+    addEvent(): this;
+    setStatus(): this;
+    recordException(): this;
+    updateName(): this;
+    traceparent(): string | null;
+    tracestate(): string | null;
+    end(): void;
+}
+export declare const NOOP_SPAN: Span;
+/**
+ * An inert handle that carries an inbound trace context. Records nothing, and
+ * echoes the `traceparent` it was handed — including the caller's version and
+ * sampled flag — so a service with tracing off still forwards the trace it
+ * received rather than severing it. The ids it propagates are the upstream
+ * caller's own; this SDK invents none.
+ */
+export declare class PassThroughSpan extends NoopSpan {
+    private readonly _traceparent;
+    private readonly _tracestate?;
+    constructor(_traceparent: string, _tracestate?: string | undefined);
+    traceparent(): string;
+    tracestate(): string | null;
+}
+/**
+ * The handle to return when a span cannot be recorded: a pass-through when a
+ * context is available, the shared no-op otherwise. With no explicit `parent`
+ * the active handle supplies it, so an inbound trace survives nesting.
+ *
+ * @internal Exposed for cross-package use within this SDK; not part of the stable public API.
+ */
+export declare function inertSpan(options?: {
+    parent?: unknown;
+    tracestate?: unknown;
+}, active?: Span): Span;
+/**
+ * Bounds every string reachable from an attribute value to `maxLength`
+ * characters, including the strings nested inside arrays and objects. Numbers
+ * and booleans are bounded already.
+ *
+ * An unbounded value is the one thing the per-span caps do not stop: a single
+ * multi-MB attribute makes the whole span too large for the ingestion endpoint,
+ * and the 413 path then drops that span whole. `setAttribute('payload', { body })`
+ * is the usual way one arrives, so the bound has to reach inside the value.
+ *
+ * Returns the value it was given when nothing needed shortening, so the common
+ * case allocates nothing.
+ */
+export declare function truncateAttributeValue(value: SpanAttributeValue, maxLength: number): SpanAttributeValue;
+/** `truncateAttributeValue` across an attribute bag, in place. */
+export declare function truncateAttributes(attributes: SpanAttributes, maxLength: number): SpanAttributes;
+/**
+ * Runs `fn` with `span` active, which every scoped helper does the same way.
+ *
+ * The shared no-op is never activated, so `getActiveSpan()` inside the callback
+ * reads null — callbacks should use the handle they're given. A pass-through
+ * handle is activated, so `getActiveSpan()?.traceparent()` still propagates an
+ * inbound trace through a service with tracing off.
+ *
+ * @internal Exposed for cross-package use within this SDK; not part of the stable public API.
+ */
+export declare function runWithActiveSpan<T>(contextManager: SpanContextManager, span: Span, fn: (span: Span) => T): T;
+/**
+ * Extracts the OTel `exception.type` / `exception.message` pair from whatever was
+ * thrown. Anything can be thrown in JS, so non-Errors are described by type.
+ */
+export declare function describeError(error: unknown): {
+    type: string;
+    message: string;
+    stack?: string;
+};
+//# sourceMappingURL=span.d.ts.map

package/node_modules/@posthog/core/dist/traces/span.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span.d.ts","sourceRoot":"","sources":["../../src/traces/span.ts"],"names":[],"mappings":"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"}