testplane 9.1.1 → 9.2.1

package/build/src/profiler/runtime/runtime.js

@@ -0,0 +1,1343 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfilerRuntime = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+const node_perf_hooks_1 = require("node:perf_hooks");
+const node_perf_hooks_2 = require("node:perf_hooks");
+const node_os_1 = __importDefault(require("node:os"));
+const types_1 = require("node:util/types");
+const operation_store_1 = require("../retention/operation-store");
+const policy_v1_1 = require("../retention/policy-v1");
+const streaming_statistics_1 = require("../retention/streaming-statistics");
+const clock_1 = require("./clock");
+const async_activity_1 = require("./async-activity");
+const DEFAULT_QUALITY = {
+    timing: "exact",
+    cpu: "process-window",
+};
+const MAX_PENDING_FRAGMENTS_PER_SOURCE = 32;
+const MAX_PENDING_FRAGMENT_BYTES = 20 * 1024 * 1024;
+const SAMPLING_INTERVAL = {
+    1: 500,
+    2: 250,
+    3: 100,
+};
+const EVENT_LOOP_DELAY_RESOLUTION_MS = 10;
+const NOOP_SPAN = Object.freeze({ end: () => undefined });
+class ProfilerRuntime {
+    constructor(options) {
+        this._context = new node_async_hooks_1.AsyncLocalStorage();
+        this._openSpans = new Map();
+        this._operations = new operation_store_1.OperationStore();
+        this._aggregates = new Map();
+        this._fragmentAggregates = new Map();
+        this._metrics = new Map();
+        this._fragmentMetrics = new Map();
+        this._errors = [];
+        this._idSequence = 0;
+        this._stopped = false;
+        this._overheadMs = 0;
+        this._transferredOperationIds = new Set();
+        this._transferredErrorCount = 0;
+        this._ingestedFragmentSequences = new Map();
+        /** Out-of-order fragments waiting for a contiguous predecessor (RPC vs IPC race). */
+        this._pendingFragments = new Map();
+        this._pendingFragmentBytes = 0;
+        this._externalTruncation = new Map();
+        this._maxClockUncertaintyMs = 0;
+        this._unalignedFragments = 0;
+        this._aggregateIdentitiesSeen = 0;
+        this._aggregateIdentityOverflow = 0;
+        this._metricIdentitiesSeen = 0;
+        this._metricIdentityOverflow = 0;
+        this._fragmentSequence = 0;
+        this.runId = options.runId;
+        this.level = options.level;
+        this._clock = options.clock ?? clock_1.systemClock;
+        this._process = options.process ?? { type: "master", pid: process.pid };
+        this._operationIdPrefix = operationIdPrefix(this.runId, this._process);
+        this.originMonotonicMs = options.originMonotonicMs ?? this._clock.now();
+        this.originEpochMs =
+            options.originEpochMs ?? this._clock.epochNow() - (this._clock.now() - this.originMonotonicMs);
+        this._clockUncertaintyMs = options.clockUncertaintyMs;
+        if (this.level >= 3) {
+            try {
+                this._asyncActivity = new async_activity_1.AsyncActivityTracker(this._clock, () => this._context.getStore()?.spanId, error => this.recordError("runtime.asyncActivity", error));
+            }
+            catch (error) {
+                this.recordError("runtime.asyncActivity.setup", error);
+            }
+        }
+        this._startResourceSampler();
+    }
+    isEnabled(minLevel = 1) {
+        return !this._stopped && this.level >= minLevel;
+    }
+    adoptBootstrapProbe(probe) {
+        const records = probe.takeRecords();
+        const operationIds = new Map(records.map(record => [record.id, this._nextId("bootstrap")]));
+        for (const record of records) {
+            const operation = {
+                id: operationIds.get(record.id),
+                parentId: record.parentId === undefined ? undefined : operationIds.get(record.parentId),
+                kind: record.kind,
+                name: record.name,
+                process: this._process,
+                context: { runId: this.runId },
+                startOffsetMs: Math.max(0, record.startMs - this.originMonotonicMs),
+                timing: {
+                    wallMs: Math.max(0, record.endMs - record.startMs),
+                    processCpuMs: record.processCpuMs,
+                },
+                attributes: {},
+                quality: DEFAULT_QUALITY,
+                status: record.status,
+            };
+            this._recordOperation(operation);
+        }
+    }
+    startSpan(kind, options = {}) {
+        if (!this.isEnabled(options.minLevel)) {
+            return NOOP_SPAN;
+        }
+        const overheadStart = this._clock.now();
+        try {
+            const current = this._context.getStore();
+            const id = this._nextId("span");
+            const context = {
+                runId: this.runId,
+                ...current,
+                ...options.context,
+                spanId: id,
+            };
+            const span = {
+                id,
+                kind,
+                name: options.name ?? kind,
+                parentId: options.parentId ?? current?.spanId,
+                context,
+                process: options.process ?? this._process,
+                source: options.source,
+                attributes: options.attributes ?? {},
+                quality: { ...DEFAULT_QUALITY, ...options.quality },
+                startMs: this._clock.now(),
+                processCpu: this._clock.cpuUsage(),
+                threadCpu: this.level >= 3 && this._clock.threadCpuUsage ? this._clock.threadCpuUsage() : undefined,
+                eventLoopUtilization: typeof node_perf_hooks_1.performance.eventLoopUtilization === "function"
+                    ? node_perf_hooks_1.performance.eventLoopUtilization()
+                    : undefined,
+                ended: false,
+                childUnionMs: 0,
+                childUnionEndMs: Number.NEGATIVE_INFINITY,
+            };
+            this._openSpans.set(id, span);
+            this._asyncActivity?.startSpan(id);
+            this._registerChildInterval(span);
+            return {
+                id,
+                end: status => this._endSpan(span, status),
+            };
+        }
+        catch (error) {
+            this.recordError("runtime.startSpan", error);
+            return NOOP_SPAN;
+        }
+        finally {
+            this._overheadMs += Math.max(0, this._clock.now() - overheadStart);
+        }
+    }
+    withSpan(kind, options, action) {
+        if (!this.isEnabled(options.minLevel)) {
+            return action();
+        }
+        const span = this.startSpan(kind, options);
+        const context = { ...(this._context.getStore() ?? { runId: this.runId }), spanId: span.id };
+        return this._context.run(context, () => {
+            try {
+                const result = this._asyncActivity ? this._asyncActivity.measureSynchronous(span.id, action) : action();
+                if (isPromiseLike(result)) {
+                    return result.then(value => {
+                        span.end();
+                        return value;
+                    }, error => {
+                        span.end("failed");
+                        throw error;
+                    });
+                }
+                span.end();
+                return result;
+            }
+            catch (error) {
+                span.end("failed");
+                throw error;
+            }
+        });
+    }
+    withContext(context, action) {
+        if (this._stopped) {
+            return action();
+        }
+        return this._context.run({
+            runId: this.runId,
+            ...this._context.getStore(),
+            ...context,
+        }, action);
+    }
+    increment(metric, value = 1, dimensions = {}) {
+        if (!this.isEnabled()) {
+            return;
+        }
+        this._updateMetric(metric, value, dimensions, true);
+    }
+    sample(metric, value, dimensions = {}) {
+        if (!this.isEnabled()) {
+            return;
+        }
+        this._updateMetric(metric, value, dimensions, false);
+    }
+    recordError(stage, error) {
+        if (this._errors.length >= policy_v1_1.RETENTION_POLICY_V1.maxErrors) {
+            return;
+        }
+        const code = readOwnDataProperty(error, "code");
+        const ownMessage = readOwnDataProperty(error, "message");
+        this._errors.push({
+            stage: stage.slice(0, 200),
+            code: typeof code === "string" ? code.slice(0, 100) : undefined,
+            message: (typeof ownMessage === "string" ? ownMessage : safeString(error)).slice(0, 1000),
+        });
+    }
+    recordMeasurement(kind, durationMs, options = {}, status = "completed") {
+        if (!this.isEnabled(options.minLevel) || !Number.isFinite(durationMs) || durationMs < 0) {
+            return;
+        }
+        try {
+            const current = this._context.getStore();
+            const id = this._nextId("measurement");
+            this._recordOperation({
+                id,
+                parentId: options.parentId ?? current?.spanId,
+                kind,
+                name: options.name ?? kind,
+                process: options.process ?? this._process,
+                context: { runId: this.runId, ...current, ...options.context, spanId: id },
+                startOffsetMs: Math.max(0, this._clock.now() - this.originMonotonicMs - durationMs),
+                timing: { wallMs: durationMs },
+                source: options.source,
+                attributes: options.attributes ?? {},
+                quality: { ...DEFAULT_QUALITY, timing: "estimated", ...options.quality },
+                status,
+            });
+        }
+        catch (error) {
+            this.recordError("runtime.recordMeasurement", error);
+        }
+    }
+    closeOpenSpans() {
+        for (const span of [...this._openSpans.values()].reverse()) {
+            this._endSpan(span, "interrupted");
+        }
+    }
+    stop() {
+        if (this._stopped) {
+            return;
+        }
+        this.closeOpenSpans();
+        this._reconcilePendingFragments();
+        this._stopped = true;
+        if (this._sampler) {
+            clearInterval(this._sampler);
+            this._sampler = undefined;
+        }
+        this._eventLoopDelay?.disable();
+        this._eventLoopDelay = undefined;
+        this._asyncActivity?.disable();
+    }
+    snapshot() {
+        const { operations, truncation } = this._operations.snapshot();
+        return {
+            runId: this.runId,
+            level: this.level,
+            originEpochMs: this.originEpochMs,
+            operations,
+            aggregates: this._snapshotAggregates(this._aggregates),
+            metrics: [...this._metrics.values()],
+            errors: [...this._errors],
+            truncation: [
+                ...truncation,
+                ...(this._aggregateIdentityOverflow > 0
+                    ? [
+                        {
+                            collector: "aggregate-identities",
+                            seen: this._aggregateIdentitiesSeen,
+                            retained: this._aggregates.size,
+                            rule: `retain at most ${policy_v1_1.RETENTION_POLICY_V1.maxAggregateIdentities} aggregate identities; merge overflow into <other>`,
+                            truncated: true,
+                        },
+                    ]
+                    : []),
+                ...(this._metricIdentityOverflow > 0
+                    ? [
+                        {
+                            collector: "metric-identities",
+                            seen: this._metricIdentitiesSeen,
+                            retained: this._metrics.size,
+                            rule: `retain at most ${policy_v1_1.RETENTION_POLICY_V1.maxAggregateIdentities} metric identities; merge overflow into profiler.metric.other`,
+                            truncated: true,
+                        },
+                    ]
+                    : []),
+                ...this._externalTruncation.values(),
+            ],
+            overheadMs: this._overheadMs,
+            clock: {
+                maxUncertaintyMs: this._maxClockUncertaintyMs || undefined,
+                unalignedFragments: this._unalignedFragments,
+            },
+        };
+    }
+    takeFragment() {
+        const snapshot = this.snapshot();
+        const retainedOperationIds = new Set(snapshot.operations.map(operation => operation.id));
+        for (const operationId of this._transferredOperationIds) {
+            if (!retainedOperationIds.has(operationId)) {
+                this._transferredOperationIds.delete(operationId);
+            }
+        }
+        const operations = snapshot.operations.filter(operation => {
+            if (this._transferredOperationIds.has(operation.id)) {
+                return false;
+            }
+            this._transferredOperationIds.add(operation.id);
+            return true;
+        });
+        const errors = snapshot.errors.slice(this._transferredErrorCount);
+        this._transferredErrorCount = snapshot.errors.length;
+        const aggregates = this._snapshotAggregates(this._fragmentAggregates);
+        const metrics = [...this._fragmentMetrics.values()];
+        this._fragmentAggregates.clear();
+        this._fragmentMetrics.clear();
+        if (!operations.length && !aggregates.length && !metrics.length && !errors.length) {
+            return null;
+        }
+        return {
+            transportVersion: 1,
+            sequence: ++this._fragmentSequence,
+            sourceRunId: this.runId,
+            level: this.level,
+            originEpochMs: snapshot.originEpochMs,
+            clockUncertaintyMs: this._clockUncertaintyMs,
+            process: this._process,
+            operations,
+            aggregates,
+            metrics,
+            errors,
+            truncation: snapshot.truncation,
+        };
+    }
+    ingestFragment(fragment) {
+        if (!this.isEnabled()) {
+            return;
+        }
+        if (!isProfilerFragmentV1(fragment)) {
+            const transportVersion = readTransportVersion(fragment);
+            if (transportVersion !== 1) {
+                this.recordError("transport.version", new Error(`Unsupported profiler transport version ${safeString(transportVersion)}`));
+            }
+            else {
+                this.recordError("transport.fragment", new Error("Invalid profiler fragment payload"));
+            }
+            return;
+        }
+        if (!this._hasMatchingFragmentLevel(fragment)) {
+            return;
+        }
+        const sourceKey = fragmentSourceKey(fragment);
+        const sequence = readOwnDataProperty(fragment, "sequence");
+        const previousSequence = this._ingestedFragmentSequences.get(sourceKey) ?? 0;
+        if (sequence <= previousSequence) {
+            return;
+        }
+        const existing = this._pendingFragments.get(sourceKey);
+        if (sequence > previousSequence + 1 && existing?.has(sequence)) {
+            return;
+        }
+        let ownedFragment;
+        try {
+            ownedFragment = cloneProfilerFragment(fragment);
+        }
+        catch (error) {
+            this.recordError("transport.fragment", error);
+            return;
+        }
+        if (sequence > previousSequence + 1) {
+            // Dual transport (IPC batch + RPC profileFragment) can deliver out of order.
+            // Buffer until the predecessor arrives; report a real gap only on stop (or when
+            // the per-source pending buffer exceeds the cap — likely a permanent hole).
+            const pending = existing ?? new Map();
+            if (!existing) {
+                this._pendingFragments.set(sourceKey, pending);
+            }
+            const serializedBytes = serializedSize(ownedFragment);
+            pending.set(ownedFragment.sequence, { fragment: ownedFragment, serializedBytes });
+            this._pendingFragmentBytes += serializedBytes;
+            if (pending.size > MAX_PENDING_FRAGMENTS_PER_SOURCE ||
+                this._pendingFragmentBytes > MAX_PENDING_FRAGMENT_BYTES) {
+                this._forceApplyPendingFragments(sourceKey);
+            }
+            return;
+        }
+        this._applyFragmentSafely(sourceKey, ownedFragment, ownedFragment.sequence);
+        this._drainPendingFragments(sourceKey);
+    }
+    _applyFragmentSafely(sourceKey, fragment, expectedSequence) {
+        if (!isProfilerFragmentV1(fragment)) {
+            this.recordError("transport.fragment", new Error("Invalid profiler fragment payload"));
+            return;
+        }
+        if (!this._hasMatchingFragmentLevel(fragment)) {
+            return;
+        }
+        if (fragment.sequence !== expectedSequence || fragmentSourceKey(fragment) !== sourceKey) {
+            this.recordError("transport.fragment", new Error("Profiler fragment identity changed before application"));
+            return;
+        }
+        try {
+            this._applyIngestedFragment(sourceKey, fragment);
+        }
+        catch (error) {
+            this.recordError("transport.fragment", error);
+        }
+    }
+    _hasMatchingFragmentLevel(fragment) {
+        if (fragment.level === this.level) {
+            return true;
+        }
+        this.recordError("transport.level", new Error(`Profiler fragment level ${fragment.level} does not match master level ${this.level}`));
+        return false;
+    }
+    _applyIngestedFragment(sourceKey, fragment) {
+        this._ingestedFragmentSequences.set(sourceKey, fragment.sequence);
+        const epochOffsetMs = fragment.originEpochMs === undefined ? 0 : fragment.originEpochMs - this.originEpochMs;
+        const hasAlignedClock = fragment.originEpochMs !== undefined && Number.isFinite(epochOffsetMs);
+        if (!hasAlignedClock) {
+            this._unalignedFragments += 1;
+        }
+        else {
+            this._maxClockUncertaintyMs = Math.max(this._maxClockUncertaintyMs, fragment.clockUncertaintyMs ?? 5);
+        }
+        const operations = [];
+        for (const sourceOperation of fragment.operations) {
+            if (!isRetainedOperation(sourceOperation)) {
+                this.recordError("transport.operation", new Error("Dropped invalid profiler operation"));
+                continue;
+            }
+            const adjustedStartOffsetMs = (hasAlignedClock ? epochOffsetMs : 0) + sourceOperation.startOffsetMs;
+            if (!Number.isFinite(adjustedStartOffsetMs)) {
+                this.recordError("transport.operation", new Error("Dropped profiler operation with invalid start offset"));
+                continue;
+            }
+            const process = sourceOperation.process.type === "browser" ? sourceOperation.process : fragment.process;
+            const operation = copyDataRecord(sourceOperation, {
+                process,
+                context: copyDataRecord(sourceOperation.context, { runId: this.runId }),
+                startOffsetMs: Math.max(0, adjustedStartOffsetMs),
+            });
+            operations.push(operation);
+        }
+        // Local spans close child-first. Preserve that order after transport snapshots,
+        // which are sorted by start time, so bounded retention can pin a parent on arrival.
+        for (const operation of orderChildrenBeforeParents(operations)) {
+            if (!fragment.aggregates?.length) {
+                this._recordOperation(operation);
+            }
+            else {
+                this._operations.add(operation);
+            }
+        }
+        for (const aggregate of fragment.aggregates ?? []) {
+            if (!this._mergeAggregate(this._aggregates, aggregate.kind, aggregate.name, aggregate.statistics, aggregate.attributes)) {
+                this.recordError("transport.aggregate", new Error(`Dropped overflowing aggregate ${aggregate.kind}`));
+            }
+        }
+        for (const metric of fragment.metrics ?? []) {
+            this._updateMetric(metric.name, metric.value, metric.dimensions, metric.mode === "counter", false);
+        }
+        for (const truncation of fragment.truncation) {
+            const key = `${sourceKey}\0${truncation.collector}`;
+            this._externalTruncation.set(key, { ...truncation });
+        }
+        for (const error of fragment.errors) {
+            this.recordError(`worker.${error.stage}`, error);
+        }
+    }
+    _drainPendingFragments(sourceKey) {
+        const pending = this._pendingFragments.get(sourceKey);
+        if (!pending?.size) {
+            return;
+        }
+        for (;;) {
+            const nextSequence = (this._ingestedFragmentSequences.get(sourceKey) ?? 0) + 1;
+            const fragment = pending.get(nextSequence);
+            if (!fragment) {
+                break;
+            }
+            this._applyFragmentSafely(sourceKey, this._takePendingFragment(pending, nextSequence), nextSequence);
+        }
+        if (!pending.size) {
+            this._pendingFragments.delete(sourceKey);
+        }
+    }
+    _reconcilePendingFragments() {
+        for (const sourceKey of [...this._pendingFragments.keys()]) {
+            this._forceApplyPendingFragments(sourceKey);
+        }
+    }
+    /** Apply buffered fragments for a source, recording transport.gap for any holes. */
+    _forceApplyPendingFragments(sourceKey) {
+        const pending = this._pendingFragments.get(sourceKey);
+        if (!pending?.size) {
+            this._pendingFragments.delete(sourceKey);
+            return;
+        }
+        const sequences = [...pending.keys()].sort((left, right) => left - right);
+        for (const sequence of sequences) {
+            const previousSequence = this._ingestedFragmentSequences.get(sourceKey) ?? 0;
+            if (sequence <= previousSequence) {
+                this._takePendingFragment(pending, sequence);
+                continue;
+            }
+            if (sequence > previousSequence + 1) {
+                const { fragment } = pending.get(sequence);
+                this.recordError("transport.gap", new Error(`Missing profiler fragment sequence ${previousSequence + 1}-${sequence - 1} from ${fragment.sourceRunId}`));
+            }
+            this._applyFragmentSafely(sourceKey, this._takePendingFragment(pending, sequence), sequence);
+        }
+        this._pendingFragments.delete(sourceKey);
+    }
+    _takePendingFragment(pending, sequence) {
+        const current = pending.get(sequence);
+        pending.delete(sequence);
+        this._pendingFragmentBytes = Math.max(0, this._pendingFragmentBytes - current.serializedBytes);
+        return current.fragment;
+    }
+    _endSpan(span, status = "completed") {
+        if (span.ended) {
+            return;
+        }
+        const overheadStart = this._clock.now();
+        try {
+            span.ended = true;
+            this._openSpans.delete(span.id);
+            const endMs = this._clock.now();
+            span.endMs = endMs;
+            const wallMs = Math.max(0, endMs - span.startMs);
+            this._completeChildInterval(span);
+            this._flushOpenChildIntervals(span, endMs);
+            const elu = span.eventLoopUtilization
+                ? node_perf_hooks_1.performance.eventLoopUtilization(span.eventLoopUtilization)
+                : undefined;
+            const threadCpuMs = span.threadCpu && this._clock.threadCpuUsage
+                ? (0, clock_1.cpuUsageToMs)(this._clock.threadCpuUsage(span.threadCpu))
+                : undefined;
+            const measuredActiveJsMs = this._asyncActivity?.finishSpan(span.id);
+            const activeJsMs = measuredActiveJsMs === undefined ? undefined : Math.min(wallMs, measuredActiveJsMs);
+            this._recordOperation({
+                id: span.id,
+                parentId: span.parentId,
+                kind: span.kind,
+                name: span.name,
+                process: span.process,
+                context: span.context,
+                startOffsetMs: Math.max(0, span.startMs - this.originMonotonicMs),
+                timing: {
+                    wallMs,
+                    processCpuMs: (0, clock_1.cpuUsageToMs)(this._clock.cpuUsage(span.processCpu)),
+                    threadCpuMs,
+                    activeJsMs,
+                    waitingMs: activeJsMs === undefined ? undefined : Math.max(0, wallMs - activeJsMs),
+                    eventLoopUtilization: elu?.utilization,
+                    observedChildUnionMs: span.childUnionMs > 0 ? Math.min(wallMs, span.childUnionMs) : undefined,
+                },
+                source: span.source,
+                attributes: span.attributes,
+                quality: {
+                    ...span.quality,
+                    cpu: threadCpuMs === undefined ? span.quality.cpu : "thread",
+                    notes: activeJsMs === undefined
+                        ? span.quality.notes
+                        : [
+                            ...(span.quality.notes ?? []),
+                            "activeJsMs is best-effort async_hooks callback attribution",
+                        ],
+                },
+                status,
+            });
+        }
+        catch (error) {
+            this.recordError("runtime.endSpan", error);
+        }
+        finally {
+            span.childIntervalHead = undefined;
+            span.childIntervalTail = undefined;
+            this._overheadMs += Math.max(0, this._clock.now() - overheadStart);
+        }
+    }
+    _registerChildInterval(span) {
+        if (!span.parentId) {
+            return;
+        }
+        const parent = this._openSpans.get(span.parentId);
+        if (!parent) {
+            return;
+        }
+        if (parent.childIntervalTail) {
+            span.previousSibling = parent.childIntervalTail;
+            parent.childIntervalTail.nextSibling = span;
+        }
+        else {
+            parent.childIntervalHead = span;
+        }
+        parent.childIntervalTail = span;
+    }
+    _completeChildInterval(span) {
+        if (!span.parentId) {
+            return;
+        }
+        const parent = this._openSpans.get(span.parentId);
+        if (!parent) {
+            return;
+        }
+        const previous = span.previousSibling;
+        const next = span.nextSibling;
+        if (previous) {
+            previous.nextSibling = next;
+        }
+        else {
+            parent.childIntervalHead = next;
+            this._mergeChildInterval(parent, span.startMs, span.endMs);
+        }
+        if (next) {
+            next.previousSibling = previous;
+        }
+        else {
+            parent.childIntervalTail = previous;
+        }
+        span.previousSibling = undefined;
+        span.nextSibling = undefined;
+    }
+    _flushOpenChildIntervals(parent, endMs) {
+        let child = parent.childIntervalHead;
+        if (child) {
+            this._mergeChildInterval(parent, child.startMs, endMs);
+        }
+        while (child) {
+            const next = child.nextSibling;
+            child.previousSibling = undefined;
+            child.nextSibling = undefined;
+            child = next;
+        }
+        parent.childIntervalHead = undefined;
+        parent.childIntervalTail = undefined;
+    }
+    // Intervals reach this point in non-decreasing start order, so the running union stays exact in O(1).
+    _mergeChildInterval(parent, startMs, endMs) {
+        if (startMs >= parent.childUnionEndMs) {
+            parent.childUnionMs += Math.max(0, endMs - startMs);
+            parent.childUnionEndMs = endMs;
+        }
+        else {
+            parent.childUnionMs += Math.max(0, endMs - parent.childUnionEndMs);
+            parent.childUnionEndMs = Math.max(parent.childUnionEndMs, endMs);
+        }
+    }
+    _recordOperation(operation) {
+        this._operations.add(operation);
+        if (operation.kind === "test.file.load" && operation.process.type === "master") {
+            this._addLocalAggregate("test.file.load.summary", operation.process.type, operation.timing.wallMs, {
+                process: operation.process.type,
+            });
+        }
+        if (operation.kind === "browser.command") {
+            this._addLocalAggregate("browser.command.cumulative", "<all>", operation.timing.wallMs);
+            const parentKind = operation.parentId ? this._openSpans.get(operation.parentId)?.kind : undefined;
+            if (parentKind !== "browser.command") {
+                this._addLocalAggregate("browser.command.root", "<root>", operation.timing.wallMs);
+            }
+        }
+        this._addLocalAggregate(operation.kind, operation.name, operation.timing.wallMs);
+    }
+    _addLocalAggregate(kind, name, value, attributes) {
+        this._addAggregate(this._aggregates, kind, name, value, true, attributes);
+        this._addAggregate(this._fragmentAggregates, kind, name, value, false, attributes);
+    }
+    _addAggregate(store, kind, name, value, trackIdentity = false, attributes) {
+        if (!this._updateAggregate(store, kind, name, attributes, trackIdentity, statistics => statistics.add(value))) {
+            this.recordError("runtime.aggregate", new Error(`Aggregate ${kind} overflowed`));
+        }
+    }
+    _mergeAggregate(store, kind, name, statistics, attributes) {
+        return this._updateAggregate(store, kind, name, attributes, true, current => current.merge(statistics));
+    }
+    _updateAggregate(store, kind, name, attributes, trackIdentity, update) {
+        let key = `${kind}\0${name}\0${stableAttributesKey(attributes)}`;
+        const isNewIdentity = !store.has(key);
+        let overflowed = false;
+        if (isNewIdentity) {
+            if (store.size >= policy_v1_1.RETENTION_POLICY_V1.maxAggregateIdentities - 1) {
+                overflowed = true;
+                kind = "profiler.aggregate.other";
+                name = "<other>";
+                attributes = undefined;
+                key = `${kind}\0${name}\0`;
+            }
+        }
+        let aggregate = store.get(key);
+        if (!aggregate) {
+            aggregate = {
+                kind,
+                name,
+                attributes: attributes && copyDataRecord(attributes),
+                statistics: new streaming_statistics_1.StreamingStatistics(),
+            };
+        }
+        if (!update(aggregate.statistics)) {
+            return false;
+        }
+        if (!store.has(key)) {
+            store.set(key, aggregate);
+        }
+        if (trackIdentity && isNewIdentity) {
+            this._aggregateIdentitiesSeen += 1;
+            if (overflowed) {
+                this._aggregateIdentityOverflow += 1;
+            }
+        }
+        return true;
+    }
+    _updateMetric(metric, value, dimensions, increment, trackFragment = true) {
+        if (!Number.isFinite(value)) {
+            this.recordError("runtime.metric", new Error(`Metric ${metric} has a non-finite value`));
+            return;
+        }
+        let normalizedDimensions = copyEntriesToDataRecord(Object.entries(dimensions)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, dimension]) => [key.slice(0, 100), dimension]));
+        let normalizedMetric = metric;
+        let key = `${normalizedMetric}\0${stableAttributesKey(normalizedDimensions)}`;
+        const isNewIdentity = !this._metrics.has(key);
+        let overflowed = false;
+        if (isNewIdentity) {
+            if (this._metrics.size >= policy_v1_1.RETENTION_POLICY_V1.maxAggregateIdentities - 1) {
+                overflowed = true;
+                normalizedMetric = "profiler.metric.other";
+                normalizedDimensions = Object.create(null);
+                key = `${normalizedMetric}\0{}`;
+            }
+        }
+        const current = this._metrics.get(key);
+        const nextValue = increment ? (current?.value ?? 0) + value : value;
+        const fragmentCurrent = trackFragment ? this._fragmentMetrics.get(key) : undefined;
+        const nextFragmentValue = increment ? (fragmentCurrent?.value ?? 0) + value : value;
+        if (!Number.isFinite(nextValue) || (trackFragment && !Number.isFinite(nextFragmentValue))) {
+            this.recordError("runtime.metric", new Error(`Metric ${metric} overflowed`));
+            return;
+        }
+        this._metrics.set(key, {
+            name: normalizedMetric,
+            value: nextValue,
+            dimensions: normalizedDimensions,
+            mode: increment ? "counter" : "gauge",
+        });
+        if (isNewIdentity) {
+            this._metricIdentitiesSeen += 1;
+            if (overflowed) {
+                this._metricIdentityOverflow += 1;
+            }
+        }
+        if (trackFragment) {
+            this._fragmentMetrics.set(key, {
+                name: normalizedMetric,
+                value: nextFragmentValue,
+                dimensions: normalizedDimensions,
+                mode: increment ? "counter" : "gauge",
+            });
+        }
+    }
+    _startResourceSampler() {
+        if (typeof node_perf_hooks_1.performance.eventLoopUtilization === "function") {
+            this._lastElu = node_perf_hooks_1.performance.eventLoopUtilization();
+        }
+        try {
+            this._eventLoopDelay = (0, node_perf_hooks_2.monitorEventLoopDelay)({ resolution: EVENT_LOOP_DELAY_RESOLUTION_MS });
+            this._eventLoopDelay.enable();
+        }
+        catch (error) {
+            this.recordError("runtime.eventLoopDelay.setup", error);
+        }
+        if (this._process.type === "master") {
+            this._lastHostCpu = readHostCpu();
+        }
+        this._sampler = setInterval(() => {
+            try {
+                if (this._lastElu) {
+                    const current = node_perf_hooks_1.performance.eventLoopUtilization(this._lastElu);
+                    this._lastElu = node_perf_hooks_1.performance.eventLoopUtilization();
+                    this._recordResourceSample("process.eventLoopUtilization", current.utilization, {
+                        process: this._process.type,
+                    });
+                }
+                const memory = process.memoryUsage();
+                this._recordResourceSample("process.rssBytes", memory.rss, { process: this._process.type });
+                if (this._eventLoopDelay && Number.isFinite(this._eventLoopDelay.percentile(95))) {
+                    this._recordResourceSample("process.eventLoopDelayP95Ms", this._eventLoopDelay.percentile(95) / 1000000, { process: this._process.type });
+                    this._eventLoopDelay.reset();
+                }
+                if (this._process.type === "master" && this._lastHostCpu) {
+                    const hostCpu = readHostCpu();
+                    const totalDelta = hostCpu.total - this._lastHostCpu.total;
+                    const busyDelta = hostCpu.busy - this._lastHostCpu.busy;
+                    this._lastHostCpu = hostCpu;
+                    if (totalDelta > 0) {
+                        this._recordResourceSample("host.cpuUtilization", busyDelta / totalDelta, {
+                            process: "host",
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                this.recordError("runtime.resourceSampler", error);
+            }
+        }, SAMPLING_INTERVAL[this.level]);
+        this._sampler.unref();
+    }
+    _recordResourceSample(metric, value, dimensions) {
+        this.sample(metric, value, dimensions);
+        this._addLocalAggregate("metric.sample", metric, value, dimensions);
+    }
+    _snapshotAggregates(store) {
+        return [...store.values()].map(({ kind, name, attributes, statistics }) => ({
+            kind,
+            name,
+            attributes,
+            statistics: statistics.snapshot(),
+        }));
+    }
+    _nextId(prefix) {
+        this._idSequence += 1;
+        return `${this._operationIdPrefix}:${prefix}:${this._idSequence}`;
+    }
+}
+exports.ProfilerRuntime = ProfilerRuntime;
+function operationIdPrefix(runId, processRef) {
+    if (processRef.type === "master") {
+        return runId;
+    }
+    const processIdentity = processRef.workerInstanceId ??
+        processRef.browserId ??
+        (processRef.pid === undefined ? "unknown" : processRef.pid);
+    return `${runId}:${processRef.type}:${processIdentity}`;
+}
+function fragmentSourceKey(fragment) {
+    const process = readOwnDataProperty(fragment, "process");
+    return [
+        readOwnDataProperty(fragment, "sourceRunId"),
+        readOwnDataProperty(process, "type"),
+        readOwnDataProperty(process, "pid"),
+        readOwnDataProperty(process, "workerInstanceId"),
+        readOwnDataProperty(process, "browserId"),
+    ]
+        .map(keyPart)
+        .join("|");
+}
+function stableAttributesKey(attributes) {
+    if (!attributes) {
+        return "";
+    }
+    return stringifyDataValue(copyEntriesToDataRecord(Object.entries(attributes).sort(([left], [right]) => left.localeCompare(right))));
+}
+function serializedSize(value) {
+    try {
+        return Buffer.byteLength(stringifyDataValue(value));
+    }
+    catch {
+        return MAX_PENDING_FRAGMENT_BYTES + 1;
+    }
+}
+function cloneProfilerFragment(fragment) {
+    const normalized = Object.create(null);
+    for (const key of Object.keys(fragment)) {
+        if (key !== "operations") {
+            normalized[key] = normalizeDataValue(readOwnDataProperty(fragment, key));
+        }
+    }
+    const operations = readOwnDataProperty(fragment, "operations");
+    const operationsLength = readOwnDataProperty(operations, "length");
+    const normalizedOperations = new Array(operationsLength);
+    for (let index = 0; index < operations.length; index += 1) {
+        const operation = readOwnDataProperty(operations, String(index));
+        // Invalid operations are still dropped individually when the fragment is applied.
+        normalizedOperations[index] = isRetainedOperation(operation) ? normalizeDataValue(operation) : null;
+    }
+    normalized.operations = normalizedOperations;
+    const cloned = structuredClone(normalized);
+    if (!isProfilerFragmentV1(cloned)) {
+        throw new Error("Cloned profiler fragment failed validation");
+    }
+    return normalizeDataValue(cloned);
+}
+function copyDataRecord(source, overrides) {
+    const target = Object.create(null);
+    for (const key of Object.keys(source)) {
+        target[key] = normalizeDataValue(readOwnDataProperty(source, key));
+    }
+    for (const key of Object.keys(overrides ?? {})) {
+        target[key] = normalizeDataValue(readOwnDataProperty(overrides, key));
+    }
+    return target;
+}
+function copyEntriesToDataRecord(entries) {
+    const target = Object.create(null);
+    for (const [key, value] of entries) {
+        target[key] = value;
+    }
+    return target;
+}
+function normalizeDataValue(value) {
+    if (Array.isArray(value)) {
+        const length = readOwnDataProperty(value, "length");
+        if (!Number.isSafeInteger(length) || length < 0) {
+            throw new Error("Invalid data array length");
+        }
+        const normalized = new Array(length);
+        for (let index = 0; index < normalized.length; index += 1) {
+            normalized[index] = normalizeDataValue(readOwnDataProperty(value, String(index)));
+        }
+        return normalized;
+    }
+    if (value && typeof value === "object") {
+        return copyDataRecord(value);
+    }
+    return value;
+}
+function stringifyDataValue(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return JSON.stringify(value);
+    }
+    if (value === undefined) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        const entries = [];
+        const length = readOwnDataProperty(value, "length");
+        for (let index = 0; index < length; index += 1) {
+            entries.push(stringifyDataValue(readOwnDataProperty(value, String(index))));
+        }
+        return `[${entries.join(",")}]`;
+    }
+    if (typeof value === "object") {
+        const entries = [];
+        for (const key of Object.keys(value)) {
+            const entry = readOwnDataProperty(value, key);
+            if (entry !== undefined) {
+                entries.push(`${JSON.stringify(key)}:${stringifyDataValue(entry)}`);
+            }
+        }
+        return `{${entries.join(",")}}`;
+    }
+    throw new Error("Unsupported profiler data value");
+}
+function keyPart(value) {
+    if (value === undefined) {
+        return "u";
+    }
+    return typeof value === "number" ? `n${value}` : `s${value.length}:${value}`;
+}
+function orderChildrenBeforeParents(operations) {
+    const byId = new Map(operations.map(operation => [operation.id, operation]));
+    const children = new Map();
+    for (const operation of operations) {
+        if (!operation.parentId || !byId.has(operation.parentId)) {
+            continue;
+        }
+        const siblings = children.get(operation.parentId) ?? [];
+        siblings.push(operation);
+        children.set(operation.parentId, siblings);
+    }
+    const ordered = [];
+    const visited = new Set();
+    const visit = (operation) => {
+        if (visited.has(operation.id)) {
+            return;
+        }
+        visited.add(operation.id);
+        for (const child of children.get(operation.id) ?? []) {
+            visit(child);
+        }
+        ordered.push(operation);
+    };
+    operations.forEach(visit);
+    return ordered;
+}
+function isPromiseLike(value) {
+    return Boolean(value && typeof value.then === "function");
+}
+function readHostCpu() {
+    let busy = 0;
+    let total = 0;
+    for (const cpu of node_os_1.default.cpus()) {
+        const cpuTotal = Object.values(cpu.times).reduce((sum, value) => sum + value, 0);
+        total += cpuTotal;
+        busy += cpuTotal - cpu.times.idle;
+    }
+    return { busy, total };
+}
+const isProcessRef = recordShape({
+    type: oneOf("master", "worker", "browser"),
+    pid: optional(isPositiveSafeInteger),
+    workerInstanceId: optional(isString),
+    browserId: optional(isString),
+});
+const isOperationTiming = recordShape({
+    wallMs: isNonNegativeFiniteNumber,
+    selfWallMs: optional(isNonNegativeFiniteNumber),
+    cumulativeWorkMs: optional(isNonNegativeFiniteNumber),
+    overlapMs: optional(isNonNegativeFiniteNumber),
+    criticalPathMs: optional(isNonNegativeFiniteNumber),
+    observedChildUnionMs: optional(isNonNegativeFiniteNumber),
+    processCpuMs: optional(isNonNegativeFiniteNumber),
+    threadCpuMs: optional(isNonNegativeFiniteNumber),
+    activeJsMs: optional(isNonNegativeFiniteNumber),
+    waitingMs: optional(isNonNegativeFiniteNumber),
+    eventLoopUtilization: optional(isUnitInterval),
+});
+const isCorrelationContext = recordShape({
+    runId: optional(isString),
+    spanId: optional(isString),
+    testId: optional(isString),
+    attemptId: optional(isString),
+    attempt: optional(isNonNegativeSafeInteger),
+    browserId: optional(isString),
+    sessionId: optional(isString),
+    runnableKind: optional(isString),
+});
+const isSourceRef = recordShape({
+    file: optional(isString),
+    line: optional(isFiniteNumber),
+    column: optional(isFiniteNumber),
+    functionName: optional(isString),
+    plugin: optional(isString),
+    confidence: oneOf("high", "medium", "low"),
+});
+const isMeasurementQuality = recordShape({
+    timing: oneOf("exact", "estimated", "sampled"),
+    cpu: oneOf("process-window", "thread", "sampled", "unavailable"),
+    source: optional(oneOf("exact", "partial", "unavailable")),
+    notes: optional(arrayOf(isString)),
+});
+const retainedOperationGuard = recordShape({
+    id: isString,
+    parentId: optional(isString),
+    kind: isString,
+    name: isString,
+    process: isProcessRef,
+    context: isCorrelationContext,
+    startOffsetMs: isNonNegativeFiniteNumber,
+    timing: isOperationTiming,
+    source: optional(isSourceRef),
+    attributes: isProfilerValueRecord,
+    quality: isMeasurementQuality,
+    status: optional(oneOf("completed", "failed", "interrupted")),
+});
+const statisticsSnapshotGuard = recordShape({
+    count: isNonNegativeSafeInteger,
+    sum: isFiniteNumber,
+    min: isFiniteNumber,
+    max: isFiniteNumber,
+    mean: isFiniteNumber,
+    variance: isFiniteNumber,
+    p50: optional(isFiniteNumber),
+    p95: optional(isFiniteNumber),
+    samples: optional(arrayOf(isFiniteNumber)),
+});
+const isRuntimeAggregate = recordShape({
+    kind: isString,
+    name: isString,
+    attributes: optional(isProfilerValueRecord),
+    statistics: isStatisticsSnapshot,
+});
+const isRuntimeMetric = recordShape({
+    name: isString,
+    value: isFiniteNumber,
+    dimensions: isProfilerValueRecord,
+    mode: oneOf("counter", "gauge"),
+});
+const isProfilerError = recordShape({
+    stage: isString,
+    code: optional(isString),
+    message: isString,
+});
+const truncationEntryGuard = recordShape({
+    collector: isString,
+    seen: isNonNegativeSafeInteger,
+    retained: isNonNegativeSafeInteger,
+    rule: isString,
+    truncated: isBoolean,
+});
+const profilerFragmentGuard = recordShape({
+    transportVersion: oneOf(1),
+    sequence: isPositiveSafeInteger,
+    sourceRunId: isString,
+    level: oneOf(1, 2, 3),
+    originEpochMs: optional(isFiniteNumber),
+    clockUncertaintyMs: optional(isNonNegativeFiniteNumber),
+    process: isProcessRef,
+    operations: isDataArray,
+    aggregates: optional(arrayOf(isRuntimeAggregate)),
+    metrics: optional(arrayOf(isRuntimeMetric)),
+    errors: arrayOf(isProfilerError),
+    truncation: arrayOf(isTruncationEntry),
+});
+function isRetainedOperation(value) {
+    try {
+        return retainedOperationGuard(value);
+    }
+    catch {
+        return false;
+    }
+}
+function isProfilerFragmentV1(value) {
+    try {
+        return profilerFragmentGuard(value);
+    }
+    catch {
+        return false;
+    }
+}
+function isStatisticsSnapshot(value) {
+    if (!statisticsSnapshotGuard(value)) {
+        return false;
+    }
+    const count = readOwnDataProperty(value, "count");
+    const sum = readOwnDataProperty(value, "sum");
+    const min = readOwnDataProperty(value, "min");
+    const max = readOwnDataProperty(value, "max");
+    const mean = readOwnDataProperty(value, "mean");
+    const variance = readOwnDataProperty(value, "variance");
+    const p50 = readOwnDataProperty(value, "p50");
+    const p95 = readOwnDataProperty(value, "p95");
+    const samples = readOwnDataProperty(value, "samples") ?? [];
+    if (!count) {
+        return (sum === 0 &&
+            min === 0 &&
+            max === 0 &&
+            mean === 0 &&
+            variance === 0 &&
+            p50 === undefined &&
+            p95 === undefined &&
+            !samples.length);
+    }
+    if (sum < 0 ||
+        min < 0 ||
+        min > mean ||
+        mean > max ||
+        variance < 0 ||
+        samples.length > count ||
+        samples.length > streaming_statistics_1.DEFAULT_STATISTICS_RESERVOIR_SIZE ||
+        ((count === 1 || min === max) && variance !== 0)) {
+        return false;
+    }
+    const lowerSum = min * count;
+    const upperSum = max * count;
+    if (!Number.isFinite(lowerSum) || !Number.isFinite(upperSum)) {
+        return false;
+    }
+    const tolerance = Math.max(1, Math.abs(sum), Math.abs(lowerSum), Math.abs(upperSum)) * 1e-9;
+    const expectedMean = sum / count;
+    const meanTolerance = Math.max(1, Math.abs(mean), Math.abs(expectedMean)) * 1e-9;
+    if (sum < lowerSum - tolerance || sum > upperSum + tolerance || Math.abs(mean - expectedMean) > meanTolerance) {
+        return false;
+    }
+    const m2 = variance * (count - 1);
+    if (!Number.isFinite(m2)) {
+        return false;
+    }
+    const maxM2 = count * (mean - min) * (max - mean);
+    if (Number.isFinite(maxM2)) {
+        const m2Tolerance = Math.max(1, Math.abs(m2), Math.abs(maxM2)) * 1e-9;
+        if (m2 > maxM2 + m2Tolerance) {
+            return false;
+        }
+    }
+    const inRange = (entry) => entry === undefined || (entry >= min && entry <= max);
+    if (!inRange(p50) || !inRange(p95) || (p50 !== undefined && p95 !== undefined && p50 > p95)) {
+        return false;
+    }
+    for (let index = 0; index < samples.length; index += 1) {
+        if (!inRange(samples[index]) || (index > 0 && samples[index - 1] > samples[index])) {
+            return false;
+        }
+    }
+    if (!samples.length) {
+        return p50 === undefined && p95 === undefined;
+    }
+    if (p50 !== sampleQuantile(samples, 0.5) || p95 !== sampleQuantile(samples, 0.95)) {
+        return false;
+    }
+    if (samples.length === count) {
+        const completeStatistics = new streaming_statistics_1.StreamingStatistics(streaming_statistics_1.DEFAULT_STATISTICS_RESERVOIR_SIZE, () => 0);
+        for (const sample of samples) {
+            if (!completeStatistics.add(sample)) {
+                return false;
+            }
+        }
+        const completeSnapshot = completeStatistics.snapshot();
+        return (min === completeSnapshot.min &&
+            max === completeSnapshot.max &&
+            approximatelyEqual(sum, completeSnapshot.sum) &&
+            approximatelyEqual(mean, completeSnapshot.mean) &&
+            approximatelyEqual(variance, completeSnapshot.variance));
+    }
+    return true;
+}
+function isTruncationEntry(value) {
+    return (truncationEntryGuard(value) &&
+        readOwnDataProperty(value, "retained") <= readOwnDataProperty(value, "seen"));
+}
+function readTransportVersion(value) {
+    try {
+        if (!value || typeof value !== "object" || (0, types_1.isProxy)(value)) {
+            return;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(value, "transportVersion");
+        return descriptor && "value" in descriptor ? descriptor.value : undefined;
+    }
+    catch {
+        return;
+    }
+}
+function safeString(value) {
+    switch (typeof value) {
+        case "string":
+        case "number":
+        case "boolean":
+        case "undefined":
+        case "bigint":
+            return String(value);
+        default:
+            return value === null ? "null" : `<${typeof value}>`;
+    }
+}
+function isProfilerValueRecord(value) {
+    return isPlainRecord(value) && Object.keys(value).every(key => isProfilerValue(readOwnDataProperty(value, key)));
+}
+function isProfilerValue(value) {
+    return value === null || typeof value === "string" || typeof value === "boolean" || isFiniteNumber(value);
+}
+function isPlainRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value) || (0, types_1.isProxy)(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return (prototype === Object.prototype || prototype === null) && hasOnlyDataProperties(value, true);
+}
+function recordShape(fields) {
+    const entries = Object.entries(fields);
+    const allowed = new Set(Object.keys(fields));
+    return (value) => isPlainRecord(value) &&
+        Object.keys(value).every(key => allowed.has(key)) &&
+        entries.every(([key, guard]) => guard(readOwnDataProperty(value, key)));
+}
+function optional(guard) {
+    return (value) => value === undefined || guard(value);
+}
+function oneOf(...allowed) {
+    return (value) => allowed.includes(value);
+}
+function arrayOf(guard) {
+    return (value) => isDataArray(value) && Array.prototype.every.call(value, guard);
+}
+function isString(value) {
+    return typeof value === "string";
+}
+function isBoolean(value) {
+    return typeof value === "boolean";
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function isNonNegativeFiniteNumber(value) {
+    return isFiniteNumber(value) && value >= 0;
+}
+function isUnitInterval(value) {
+    return isNonNegativeFiniteNumber(value) && value <= 1;
+}
+function isPositiveSafeInteger(value) {
+    return isFiniteNumber(value) && Number.isSafeInteger(value) && value > 0;
+}
+function isNonNegativeSafeInteger(value) {
+    return isFiniteNumber(value) && Number.isSafeInteger(value) && value >= 0;
+}
+function isDataArray(value) {
+    if (!Array.isArray(value) || (0, types_1.isProxy)(value) || Object.getPrototypeOf(value) !== Array.prototype) {
+        return false;
+    }
+    const keys = Reflect.ownKeys(value);
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+    if (!lengthDescriptor ||
+        !("value" in lengthDescriptor) ||
+        !Number.isSafeInteger(lengthDescriptor.value) ||
+        lengthDescriptor.value < 0 ||
+        !lengthDescriptor.writable ||
+        lengthDescriptor.enumerable ||
+        lengthDescriptor.configurable) {
+        return false;
+    }
+    const length = lengthDescriptor.value;
+    return (keys.length === length + 1 &&
+        keys.every((key, index) => {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            return index === length
+                ? key === "length" &&
+                    "value" in descriptor &&
+                    descriptor.value === length &&
+                    descriptor.writable &&
+                    !descriptor.enumerable &&
+                    !descriptor.configurable
+                : key === String(index) &&
+                    "value" in descriptor &&
+                    descriptor.writable &&
+                    descriptor.enumerable &&
+                    descriptor.configurable;
+        }));
+}
+function hasOnlyDataProperties(value, enumerable = false) {
+    return Reflect.ownKeys(value).every(key => {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        return "value" in descriptor && (!enumerable || (typeof key === "string" && descriptor.enumerable));
+    });
+}
+function readOwnDataProperty(value, key) {
+    if (!value || (typeof value !== "object" && typeof value !== "function") || (0, types_1.isProxy)(value)) {
+        return;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor && "value" in descriptor ? descriptor.value : undefined;
+}
+function sampleQuantile(values, percentile) {
+    if (!values.length) {
+        return;
+    }
+    return values[Math.min(values.length - 1, Math.floor((values.length - 1) * percentile))];
+}
+function approximatelyEqual(left, right) {
+    const tolerance = Math.max(1, Math.abs(left), Math.abs(right)) * 1e-9;
+    return Math.abs(left - right) <= tolerance;
+}
+//# sourceMappingURL=runtime.js.map