@atlaspack/profiler 2.14.1-canary.43 → 2.14.1-canary.431

package/dist/Trace.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chrome_trace_event_1 = require("chrome-trace-event");
+class Trace {
+    constructor() {
+        this.tracer = new chrome_trace_event_1.Tracer();
+        this.tid = 0;
+        this.eventId = 0;
+    }
+    getEventId() {
+        return this.eventId++;
+    }
+    init(ts) {
+        this.tracer.instantEvent({
+            name: 'TracingStartedInPage',
+            id: this.getEventId(),
+            ts,
+            cat: ['disabled-by-default-devtools.timeline'],
+            args: {
+                data: {
+                    sessionId: '-1',
+                    page: '0xfff',
+                    frames: [
+                        {
+                            frame: '0xfff',
+                            url: 'parcel',
+                            name: '',
+                        },
+                    ],
+                },
+            },
+        });
+        this.tracer.instantEvent({
+            name: 'TracingStartedInBrowser',
+            id: this.getEventId(),
+            ts,
+            cat: ['disabled-by-default-devtools.timeline'],
+            args: {
+                data: {
+                    sessionId: '-1',
+                },
+            },
+        });
+    }
+    addCPUProfile(name, profile) {
+        if (this.eventId === 0) {
+            this.init(profile.startTime);
+        }
+        const trace = this.tracer;
+        const tid = this.tid;
+        this.tid++;
+        const cpuStartTime = profile.startTime;
+        const cpuEndTime = profile.endTime;
+        trace.instantEvent({
+            tid,
+            id: this.getEventId(),
+            cat: ['toplevel'],
+            name: 'TaskQueueManager::ProcessTaskFromWorkQueue',
+            args: {
+                src_file: '../../ipc/ipc_moji_bootstrap.cc',
+                src_func: 'Accept',
+            },
+            ts: cpuStartTime,
+        });
+        trace.completeEvent({
+            tid,
+            name: 'EvaluateScript',
+            id: this.getEventId(),
+            cat: ['devtools.timeline'],
+            ts: cpuStartTime,
+            dur: cpuEndTime - cpuStartTime,
+            args: {
+                data: {
+                    url: 'parcel',
+                    lineNumber: 1,
+                    columnNumber: 1,
+                    frame: '0xFFF',
+                },
+            },
+        });
+        trace.instantEvent({
+            tid,
+            ts: 0,
+            ph: 'M',
+            cat: ['__metadata'],
+            name: 'thread_name',
+            args: { name },
+        });
+        trace.instantEvent({
+            tid,
+            name: 'CpuProfile',
+            id: this.getEventId(),
+            cat: ['disabled-by-default-devtools.timeline'],
+            ts: cpuEndTime,
+            args: {
+                data: {
+                    cpuProfile: profile,
+                },
+            },
+        });
+    }
+    pipe(writable) {
+        return this.tracer.pipe(writable);
+    }
+    flush() {
+        this.tracer.push(null);
+    }
+}
+exports.default = Trace;

package/dist/Tracer.js

@@ -0,0 +1,132 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TraceMeasurement_active, _TraceMeasurement_name, _TraceMeasurement_pid, _TraceMeasurement_tid, _TraceMeasurement_start, _TraceMeasurement_data, _Tracer_traceEmitter, _Tracer_enabled;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginTracer = exports.tracer = void 0;
+const events_1 = require("@atlaspack/events");
+const perf_hooks_1 = require("perf_hooks");
+// @ts-expect-error TS7034
+let tid;
+try {
+    tid = require('worker_threads').threadId;
+}
+catch {
+    tid = 0;
+}
+const pid = process.pid;
+class TraceMeasurement {
+    constructor(tracer, name, pid, tid, data) {
+        _TraceMeasurement_active.set(this, true);
+        _TraceMeasurement_name.set(this, void 0);
+        _TraceMeasurement_pid.set(this, void 0);
+        _TraceMeasurement_tid.set(this, void 0);
+        _TraceMeasurement_start.set(this, void 0);
+        _TraceMeasurement_data.set(this, void 0);
+        __classPrivateFieldSet(this, _TraceMeasurement_name, name, "f");
+        __classPrivateFieldSet(this, _TraceMeasurement_pid, pid, "f");
+        __classPrivateFieldSet(this, _TraceMeasurement_tid, tid, "f");
+        __classPrivateFieldSet(this, _TraceMeasurement_start, perf_hooks_1.performance.now(), "f");
+        __classPrivateFieldSet(this, _TraceMeasurement_data, data, "f");
+    }
+    end() {
+        if (!__classPrivateFieldGet(this, _TraceMeasurement_active, "f"))
+            return;
+        const duration = perf_hooks_1.performance.now() - __classPrivateFieldGet(this, _TraceMeasurement_start, "f");
+        exports.tracer.trace({
+            type: 'trace',
+            name: __classPrivateFieldGet(this, _TraceMeasurement_name, "f"),
+            pid: __classPrivateFieldGet(this, _TraceMeasurement_pid, "f"),
+            tid: __classPrivateFieldGet(this, _TraceMeasurement_tid, "f"),
+            duration,
+            ts: __classPrivateFieldGet(this, _TraceMeasurement_start, "f"),
+            ...__classPrivateFieldGet(this, _TraceMeasurement_data, "f"),
+        });
+        __classPrivateFieldSet(this, _TraceMeasurement_active, false, "f");
+    }
+}
+_TraceMeasurement_active = new WeakMap(), _TraceMeasurement_name = new WeakMap(), _TraceMeasurement_pid = new WeakMap(), _TraceMeasurement_tid = new WeakMap(), _TraceMeasurement_start = new WeakMap(), _TraceMeasurement_data = new WeakMap();
+class Tracer {
+    constructor() {
+        _Tracer_traceEmitter.set(this, new events_1.ValueEmitter());
+        _Tracer_enabled.set(this, false);
+    }
+    onTrace(cb) {
+        return __classPrivateFieldGet(this, _Tracer_traceEmitter, "f").addListener(cb);
+    }
+    async wrap(name, fn) {
+        let measurement = this.createMeasurement(name);
+        try {
+            await fn();
+        }
+        finally {
+            measurement && measurement.end();
+        }
+    }
+    createMeasurement(name, category = 'Core', argumentName, otherArgs) {
+        if (!this.enabled)
+            return null;
+        // We create `args` in a fairly verbose way to avoid object
+        // allocation where not required.
+        let args;
+        if (typeof argumentName === 'string') {
+            args = { name: argumentName };
+        }
+        if (typeof otherArgs === 'object') {
+            // @ts-expect-error TS2454
+            if (typeof args == 'undefined') {
+                args = {};
+            }
+            for (const [k, v] of Object.entries(otherArgs)) {
+                args[k] = v;
+            }
+        }
+        const data = {
+            categories: [category],
+            // @ts-expect-error TS2454
+            args,
+        };
+        // @ts-expect-error TS7005
+        return new TraceMeasurement(this, name, pid, tid, data);
+    }
+    get enabled() {
+        return __classPrivateFieldGet(this, _Tracer_enabled, "f");
+    }
+    enable() {
+        __classPrivateFieldSet(this, _Tracer_enabled, true, "f");
+    }
+    disable() {
+        __classPrivateFieldSet(this, _Tracer_enabled, false, "f");
+    }
+    trace(event) {
+        if (!__classPrivateFieldGet(this, _Tracer_enabled, "f"))
+            return;
+        __classPrivateFieldGet(this, _Tracer_traceEmitter, "f").emit(event);
+    }
+}
+_Tracer_traceEmitter = new WeakMap(), _Tracer_enabled = new WeakMap();
+exports.default = Tracer;
+exports.tracer = new Tracer();
+class PluginTracer {
+    /** @private */
+    constructor(opts) {
+        this.origin = opts.origin;
+        this.category = opts.category;
+    }
+    get enabled() {
+        return exports.tracer.enabled;
+    }
+    createMeasurement(name, category, argumentName, otherArgs) {
+        return exports.tracer.createMeasurement(name, `${this.category}:${this.origin}${typeof category === 'string' ? `:${category}` : ''}`, argumentName, otherArgs);
+    }
+}
+exports.PluginTracer = PluginTracer;

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeProfiler = exports.PluginTracer = exports.tracer = exports.Trace = exports.SamplingProfiler = void 0;
+var SamplingProfiler_1 = require("./SamplingProfiler");
+Object.defineProperty(exports, "SamplingProfiler", { enumerable: true, get: function () { return __importDefault(SamplingProfiler_1).default; } });
+var Trace_1 = require("./Trace");
+Object.defineProperty(exports, "Trace", { enumerable: true, get: function () { return __importDefault(Trace_1).default; } });
+var Tracer_1 = require("./Tracer");
+Object.defineProperty(exports, "tracer", { enumerable: true, get: function () { return Tracer_1.tracer; } });
+Object.defineProperty(exports, "PluginTracer", { enumerable: true, get: function () { return Tracer_1.PluginTracer; } });
+var NativeProfiler_1 = require("./NativeProfiler");
+Object.defineProperty(exports, "NativeProfiler", { enumerable: true, get: function () { return __importDefault(NativeProfiler_1).default; } });

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/NativeProfiler.js

@@ -0,0 +1,235 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _readline() {
+  const data = _interopRequireDefault(require("readline"));
+  _readline = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _child_process() {
+  const data = require("child_process");
+  _child_process = function () {
+    return data;
+  };
+  return data;
+}
+function _util() {
+  const data = require("util");
+  _util = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const execAsync = (0, _util().promisify)(_child_process().exec);
+class NativeProfiler {
+  startProfiling(profilerType) {
+    const pid = process.pid;
+    const timeId = (0, _utils().getTimeId)();
+    let filename;
+    let command;
+    _logger().default.info({
+      origin: '@atlaspack/profiler',
+      message: 'Starting native profiling...'
+    });
+    if (profilerType === 'instruments') {
+      filename = `native-profile-${timeId}.trace`;
+      command = `xcrun xctrace record --template "CPU Profiler" --output ${filename} --attach ${pid}`;
+    } else {
+      filename = `native-profile-${timeId}.json`;
+      command = `samply record --save-only --output ${filename} --pid ${pid}`;
+    }
+
+    // Display banner with PID and command
+    // Strip ANSI codes for length calculation
+    // eslint-disable-next-line no-control-regex
+    const stripAnsi = str => str.replace(/\u001b\[[0-9;]*m/g, '');
+    const boxWidth = Math.max(60, stripAnsi(command).length + 6);
+    const title = 'Native Profiling';
+    const titlePadding = Math.floor((boxWidth - title.length - 2) / 2);
+    const isTTY = process.stdin.isTTY;
+    const maxWaitTime = 30; // seconds
+
+    const padLine = content => {
+      const contentLength = stripAnsi(content).length;
+      const padding = Math.max(0, boxWidth - contentLength - 2);
+      return _chalk().default.blue('│') + ' ' + content + ' '.repeat(padding) + ' ' + _chalk().default.blue('│');
+    };
+
+    // Make the command visually distinct and easy to copy
+    // Note: Hyperlinks can cause issues with commands (words become separate links)
+    // So we just make it visually prominent with colors
+    const makeCommandDisplay = cmd => {
+      return _chalk().default.cyan.bold(cmd);
+    };
+
+    // Contextual message based on TTY
+    const continueMessage = isTTY ? 'Press Enter or start the profiler to continue' : `Build will continue when profiler has started, or after ${maxWaitTime}s`;
+    const banner = ['', _chalk().default.blue('┌' + '─'.repeat(boxWidth) + '┐'), _chalk().default.blue('│') + ' '.repeat(titlePadding) + _chalk().default.blue.bold(title) + ' '.repeat(boxWidth - title.length - titlePadding) + _chalk().default.blue('│'), _chalk().default.blue('├' + '─'.repeat(boxWidth) + '┤'), padLine(`${_chalk().default.gray('PID:')} ${_chalk().default.white.bold(String(pid))}`), padLine(''), padLine(_chalk().default.gray('Command:')), padLine(makeCommandDisplay(command)), padLine(''), padLine(_chalk().default.gray('Run the command above to start profiling.')), padLine(_chalk().default.gray(continueMessage)), _chalk().default.blue('└' + '─'.repeat(boxWidth) + '┘'), ''].join('\n');
+
+    // eslint-disable-next-line no-console
+    console.log(banner);
+
+    // In both interactive and non-interactive mode, detect when profiler is running
+    // In interactive mode, also allow user to press Enter to continue
+    if (!process.stdin.isTTY) {
+      return this.waitForProfiler(profilerType, pid);
+    }
+
+    // Interactive mode: wait for either user to press Enter OR profiler to be detected
+    return new Promise(resolve => {
+      let resolved = false;
+      const doResolve = () => {
+        if (resolved) return;
+        resolved = true;
+        _logger().default.info({
+          origin: '@atlaspack/profiler',
+          message: 'Native profiling setup complete'
+        });
+        resolve();
+      };
+      const rl = _readline().default.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+
+      // User presses Enter
+      rl.on('line', () => {
+        rl.close();
+        doResolve();
+      });
+
+      // Also poll for profiler in the background
+      this.pollForProfiler(profilerType, pid, doResolve);
+    });
+  }
+  waitForProfiler(profilerType, pid) {
+    _logger().default.info({
+      origin: '@atlaspack/profiler',
+      message: 'Non-interactive mode: waiting for profiler to attach...'
+    });
+    return new Promise(resolve => {
+      this.pollForProfiler(profilerType, pid, () => {
+        _logger().default.info({
+          origin: '@atlaspack/profiler',
+          message: 'Native profiling setup complete'
+        });
+        resolve();
+      });
+    });
+  }
+  async pollForProfiler(profilerType, pid, onDetected) {
+    const maxAttempts = 60; // 60 attempts * 500ms = 30 seconds max
+    const pollInterval = 500; // 500ms between checks
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const isRunning = await this.checkProfilerRunning(profilerType, pid);
+      if (isRunning) {
+        // Instruments takes longer to start up (~5s), samply needs ~1s
+        const waitTime = profilerType === 'instruments' ? 5000 : 1000;
+        _logger().default.info({
+          origin: '@atlaspack/profiler',
+          message: `Profiler detected, waiting ${waitTime}ms before continuing...`
+        });
+        await new Promise(resolve => setTimeout(resolve, waitTime));
+        onDetected();
+        return;
+      }
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+
+    // If we couldn't detect the profiler after 30 seconds, log a warning and continue anyway
+    _logger().default.warn({
+      origin: '@atlaspack/profiler',
+      message: 'Could not detect profiler after 30 seconds, continuing anyway...'
+    });
+    onDetected();
+  }
+  async checkProfilerRunning(profilerType, pid) {
+    try {
+      // Get all processes and filter in JavaScript
+      const {
+        stdout
+      } = await execAsync('ps aux');
+      const lines = stdout.split('\n').filter(line => line.trim().length > 0);
+
+      // Use word boundaries to match the PID as a complete number
+      const pidRegex = new RegExp(`\\b${pid}\\b`);
+
+      // Determine the profiler process name to look for
+      const profilerName = profilerType === 'instruments' ? 'xctrace' : 'samply';
+      for (const line of lines) {
+        const lowerLine = line.toLowerCase();
+
+        // Skip lines that are part of our own process checking (avoid false positives)
+        // Skip lines containing "ps aux" or "grep" to avoid matching our own commands
+        if (lowerLine.includes('ps aux') || lowerLine.includes(' grep ')) {
+          continue;
+        }
+
+        // Skip our own process (the Atlaspack process itself)
+        // The PID column is the second field in ps aux output
+        const fields = line.trim().split(/\s+/);
+        if (fields.length >= 2 && fields[1] === String(pid)) {
+          continue;
+        }
+
+        // Check if this line contains the profiler name as a command
+        const profilerRegex = new RegExp(`\\b${profilerName}\\b`);
+        if (!profilerRegex.test(lowerLine)) {
+          continue;
+        }
+
+        // Now check if our PID appears in the command arguments (not in the PID column)
+        // The PID should appear after the profiler command, typically as --pid <pid> or --attach <pid>
+        // We need to check the command portion, which starts around column 11 in ps aux
+        // For safety, check if PID appears after the profiler name in the line
+        const profilerIndex = lowerLine.indexOf(profilerName);
+        if (profilerIndex === -1) {
+          continue;
+        }
+
+        // Check if PID appears in the command portion (after the profiler name)
+        const commandPortion = line.substring(profilerIndex);
+        if (pidRegex.test(commandPortion)) {
+          return true;
+        }
+      }
+      return false;
+    } catch (error) {
+      // If the command fails, log and return false
+      _logger().default.warn({
+        origin: '@atlaspack/profiler',
+        message: `Error checking profiler status: ${error.message}`
+      });
+      return false;
+    }
+  }
+}
+exports.default = NativeProfiler;

package/lib/SamplingProfiler.js

@@ -20,10 +20,16 @@ function _diagnostic() {
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-Profile
+
 // https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-ProfileNode
+
 // https://chromedevtools.github.io/devtools-protocol/tot/Runtime#type-CallFrame
+
 // https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-PositionTickInfo
+
 class SamplingProfiler {
+  // @ts-expect-error not initialized
+
   startProfiling() {
     let inspector;
     try {

package/lib/Tracer.js

@@ -18,7 +18,7 @@ function _perf_hooks() {
   };
   return data;
 }
-// @ts-ignore
+// @ts-expect-error TS7034
 let tid;
 try {
   tid = require('worker_threads').threadId;
@@ -32,7 +32,6 @@ class TraceMeasurement {
   #pid;
   #tid;
   #start;
-  // $FlowFixMe
   #data;
   constructor(tracer, name, pid, tid, data) {
     this.#name = name;
@@ -82,6 +81,7 @@ class Tracer {
       };
     }
     if (typeof otherArgs === 'object') {
+      // @ts-expect-error TS2454
       if (typeof args == 'undefined') {
         args = {};
       }
@@ -91,8 +91,11 @@ class Tracer {
     }
     const data = {
       categories: [category],
+      // @ts-expect-error TS2454
       args
     };
+
+    // @ts-expect-error TS7005
     return new TraceMeasurement(this, name, pid, tid, data);
   }
   get enabled() {

package/lib/index.js

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "NativeProfiler", {
+  enumerable: true,
+  get: function () {
+    return _NativeProfiler.default;
+  }
+});
 Object.defineProperty(exports, "PluginTracer", {
   enumerable: true,
   get: function () {
@@ -30,4 +36,5 @@ Object.defineProperty(exports, "tracer", {
 var _SamplingProfiler = _interopRequireDefault(require("./SamplingProfiler"));
 var _Trace = _interopRequireDefault(require("./Trace"));
 var _Tracer = require("./Tracer");
+var _NativeProfiler = _interopRequireDefault(require("./NativeProfiler"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib/types/NativeProfiler.d.ts

@@ -0,0 +1,7 @@
+export type NativeProfilerType = 'instruments' | 'samply';
+export default class NativeProfiler {
+    startProfiling(profilerType: NativeProfilerType): Promise<void>;
+    private waitForProfiler;
+    private pollForProfiler;
+    private checkProfilerRunning;
+}

package/lib/{SamplingProfiler.d.ts → types/SamplingProfiler.d.ts}

@@ -1,4 +1,4 @@
-import type { Session } from "inspector";
+import type { Session } from 'inspector';
 export type Profile = {
     nodes: Array<ProfileNode>;
     startTime: number;
@@ -28,7 +28,7 @@ type PositionTickInfo = {
 export default class SamplingProfiler {
     session: Session;
     startProfiling(): Promise<unknown>;
-    sendCommand(method: string, params?: unknown): Promise<{
+    sendCommand(method: string, params?: any): Promise<{
         profile: Profile;
     }>;
     destroy(): void;

package/lib/{Trace.d.ts → types/Trace.d.ts}

@@ -1,6 +1,6 @@
-import type { Profile } from "./SamplingProfiler";
-import type { Writable } from "stream";
-import { Tracer } from "chrome-trace-event";
+import type { Profile } from './SamplingProfiler';
+import type { Writable } from 'stream';
+import { Tracer } from 'chrome-trace-event';
 export default class Trace {
     tracer: Tracer;
     tid: number;

package/lib/{Tracer.d.ts → types/Tracer.d.ts}

@@ -1,10 +1,12 @@
-import type { TraceEvent, IDisposable, PluginTracer as IPluginTracer } from "@atlaspack/types";
-import type { TraceMeasurement as ITraceMeasurement } from "./types";
+import type { TraceEvent, IDisposable, PluginTracer as IPluginTracer } from '@atlaspack/types-internal';
+import type { TraceMeasurement as ITraceMeasurement } from './types';
 export default class Tracer {
-
+    #private;
     onTrace(cb: (event: TraceEvent) => unknown): IDisposable;
     wrap(name: string, fn: () => unknown): Promise<void>;
-    createMeasurement(name: string, category?: string, argumentName?: string, otherArgs?: Record<string, unknown>): ITraceMeasurement | null;
+    createMeasurement(name: string, category?: string, argumentName?: string, otherArgs?: {
+        [key: string]: unknown;
+    }): ITraceMeasurement | null;
     get enabled(): boolean;
     enable(): void;
     disable(): void;
@@ -23,6 +25,8 @@ export declare class PluginTracer implements IPluginTracer {
     /** @private */
     constructor(opts: TracerOpts);
     get enabled(): boolean;
-    createMeasurement(name: string, category?: string, argumentName?: string, otherArgs?: Record<string, unknown>): ITraceMeasurement | null;
+    createMeasurement(name: string, category?: string, argumentName?: string, otherArgs?: {
+        [key: string]: unknown;
+    }): ITraceMeasurement | null;
 }
 export {};

package/lib/types/index.d.ts

@@ -0,0 +1,6 @@
+export { default as SamplingProfiler } from './SamplingProfiler';
+export { default as Trace } from './Trace';
+export { tracer, PluginTracer } from './Tracer';
+export type { TraceMeasurement, TraceMeasurementData } from './types';
+export { default as NativeProfiler } from './NativeProfiler';
+export type { NativeProfilerType } from './NativeProfiler';

package/lib/types/types.d.ts

@@ -0,0 +1,7 @@
+export type { TraceMeasurement } from '@atlaspack/types-internal';
+export type TraceMeasurementData = {
+    readonly categories: string[];
+    readonly args?: {
+        [key: string]: unknown;
+    };
+};