@tickernelz/paperclip-pro-server 2026.1018.0 → 2026.1022.0

package/node_modules/@opentelemetry/api/dist/experimental/trace/SugaredOptions.d.mts

@@ -0,0 +1,17 @@
+import { Span } from "../../trace/span.mjs";
+import { SpanOptions } from "../../trace/SpanOptions.mjs";
+//#region src/experimental/trace/SugaredOptions.d.ts
+/**
+ * Options needed for span creation
+ */
+interface SugaredSpanOptions extends SpanOptions {
+  /**
+   * function to overwrite default exception behavior to record the exception. No exceptions should be thrown in the function.
+   * @param e Error which triggered this exception
+   * @param span current span from context
+   */
+  onException?: (e: Error, span: Span) => void;
+}
+//#endregion
+export { SugaredSpanOptions };
+//# sourceMappingURL=SugaredOptions.d.mts.map

package/node_modules/@opentelemetry/api/dist/experimental/trace/SugaredOptions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SugaredOptions.d.mts","names":[],"sources":["../../../src/experimental/trace/SugaredOptions.d.ts"],"mappings":";;;;;;UAIiB,2BAA2B;;;;;;EAMxC,eAAe,GAAG,OAAO,MAAM"}

package/node_modules/@opentelemetry/api/dist/experimental/trace/SugaredTracer.cjs

@@ -0,0 +1,88 @@
+require("../../trace/status.cjs");
+const require_context_api = require("../../context-api.cjs");
+//#region src/experimental/trace/SugaredTracer.ts
+const defaultOnException = (e, span) => {
+	span.recordException(e);
+	span.setStatus({ code: 2 });
+};
+/**
+* return a new SugaredTracer created from the supplied one
+* @param tracer
+*/
+function wrapTracer(tracer) {
+	return new SugaredTracer(tracer);
+}
+var SugaredTracer = class {
+	constructor(tracer) {
+		this._tracer = tracer;
+		this.startSpan = tracer.startSpan.bind(this._tracer);
+		this.startActiveSpan = tracer.startActiveSpan.bind(this._tracer);
+	}
+	withActiveSpan(name, arg2, arg3, arg4) {
+		const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);
+		return this._tracer.startActiveSpan(name, opts, ctx, (span) => handleFn(span, opts, fn));
+	}
+	withSpan(name, arg2, arg3, arg4) {
+		const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);
+		return handleFn(this._tracer.startSpan(name, opts, ctx), opts, fn);
+	}
+};
+/**
+* Massages parameters of withSpan and withActiveSpan to allow signature overwrites
+* @param arg
+* @param arg2
+* @param arg3
+*/
+function massageParams(arg, arg2, arg3) {
+	var _opts, _ctx;
+	let opts;
+	let ctx;
+	let fn;
+	if (!arg2 && !arg3) fn = arg;
+	else if (!arg3) {
+		opts = arg;
+		fn = arg2;
+	} else {
+		opts = arg;
+		ctx = arg2;
+		fn = arg3;
+	}
+	opts = (_opts = opts) !== null && _opts !== void 0 ? _opts : {};
+	ctx = (_ctx = ctx) !== null && _ctx !== void 0 ? _ctx : require_context_api.context.active();
+	return {
+		opts,
+		ctx,
+		fn
+	};
+}
+/**
+* Executes fn, returns results and runs onException in the case of exception to allow overwriting of error handling
+* @param span
+* @param opts
+* @param fn
+*/
+function handleFn(span, opts, fn) {
+	var _opts$onException;
+	const onException = (_opts$onException = opts.onException) !== null && _opts$onException !== void 0 ? _opts$onException : defaultOnException;
+	const errorHandler = (e) => {
+		onException(e, span);
+		span.end();
+		throw e;
+	};
+	try {
+		const ret = fn(span);
+		if (typeof (ret === null || ret === void 0 ? void 0 : ret.then) === "function") return ret.then((val) => {
+			span.end();
+			return val;
+		}, errorHandler);
+		span.end();
+		return ret;
+	} catch (e) {
+		throw errorHandler(e);
+	}
+}
+//#endregion
+exports.SugaredTracer = SugaredTracer;
+exports.wrapTracer = wrapTracer;
+
+//# sourceMappingURL=SugaredTracer.cjs.map

package/node_modules/@opentelemetry/api/dist/experimental/trace/SugaredTracer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SugaredTracer.cjs","names":["contextApi"],"sources":["../../../src/experimental/trace/SugaredTracer.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nimport type { SugaredSpanOptions } from './SugaredOptions';\nimport type { Context, Span, Tracer } from '../../';\nimport { context as contextApi, SpanStatusCode } from '../../';\n\nconst defaultOnException = (e: Error, span: Span) => {\n  span.recordException(e);\n  span.setStatus({\n    code: SpanStatusCode.ERROR,\n  });\n};\n\n/**\n * return a new SugaredTracer created from the supplied one\n * @param tracer\n */\nexport function wrapTracer(tracer: Tracer): SugaredTracer {\n  return new SugaredTracer(tracer);\n}\n\nexport class SugaredTracer implements Tracer {\n  private readonly _tracer: Tracer;\n\n  constructor(tracer: Tracer) {\n    this._tracer = tracer;\n    this.startSpan = tracer.startSpan.bind(this._tracer);\n    this.startActiveSpan = tracer.startActiveSpan.bind(this._tracer);\n  }\n\n  startActiveSpan: Tracer['startActiveSpan'];\n  startSpan: Tracer['startSpan'];\n\n  /**\n   * Starts a new {@link Span} and calls the given function passing it the\n   * created span as first argument.\n   * Additionally, the new span gets set in context and this context is activated\n   * for the duration of the function call.\n   * The span will be closed after the function has executed.\n   * If an exception occurs, it is recorded, the status is set to ERROR and the exception is rethrown.\n   *\n   * @param name The name of the span\n   * @param [options] SugaredSpanOptions used for span creation\n   * @param [context] Context to use to extract parent\n   * @param fn function called in the context of the span and receives the newly created span as an argument\n   * @returns return value of fn\n   * @example\n   *     const something = tracer.withActiveSpan('op', span => {\n   *      // do some work\n   *     });\n   * @example\n   *     const something = await tracer.withActiveSpan('op', span => {\n   *      // do some async work\n   *     });\n   */\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    arg2: F | SugaredSpanOptions,\n    arg3?: F | Context,\n    arg4?: F\n  ): ReturnType<F> {\n    const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);\n\n    return this._tracer.startActiveSpan(name, opts, ctx, (span: Span) =>\n      handleFn(span, opts, fn)\n    ) as ReturnType<F>;\n  }\n\n  /**\n   * Starts a new {@link Span} and ends it after execution of fn without setting it on context.\n   * The span will be closed after the function has executed.\n   * If an exception occurs, it is recorded, the status is et to ERROR and rethrown.\n   *\n   * This method does NOT modify the current Context.\n   *\n   * @param name The name of the span\n   * @param [options] SugaredSpanOptions used for span creation\n   * @param [context] Context to use to extract parent\n   * @param fn function called in the context of the span and receives the newly created span as an argument\n   * @returns Span The newly created span\n   * @example\n   *     const something = tracer.withSpan('op', span => {\n   *      // do some work\n   *     });\n   * @example\n   *     const something = await tracer.withSpan('op', span => {\n   *      // do some async work\n   *     });\n   */\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    arg2: SugaredSpanOptions | F,\n    arg3?: Context | F,\n    arg4?: F\n  ): ReturnType<F> {\n    const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);\n\n    const span = this._tracer.startSpan(name, opts, ctx);\n    return handleFn(span, opts, fn) as ReturnType<F>;\n  }\n}\n\n/**\n * Massages parameters of withSpan and withActiveSpan to allow signature overwrites\n * @param arg\n * @param arg2\n * @param arg3\n */\nfunction massageParams<F extends (span: Span) => ReturnType<F>>(\n  arg: F | SugaredSpanOptions,\n  arg2?: F | Context,\n  arg3?: F\n) {\n  let opts: SugaredSpanOptions | undefined;\n  let ctx: Context | undefined;\n  let fn: F;\n\n  if (!arg2 && !arg3) {\n    fn = arg as F;\n  } else if (!arg3) {\n    opts = arg as SugaredSpanOptions;\n    fn = arg2 as F;\n  } else {\n    opts = arg as SugaredSpanOptions;\n    ctx = arg2 as Context;\n    fn = arg3 as F;\n  }\n  opts = opts ?? {};\n  ctx = ctx ?? contextApi.active();\n\n  return { opts, ctx, fn };\n}\n\n/**\n * Executes fn, returns results and runs onException in the case of exception to allow overwriting of error handling\n * @param span\n * @param opts\n * @param fn\n */\nfunction handleFn<F extends (span: Span) => ReturnType<F>>(\n  span: Span,\n  opts: SugaredSpanOptions,\n  fn: F\n): ReturnType<F> {\n  const onException = opts.onException ?? defaultOnException;\n  const errorHandler = (e: Error) => {\n    onException(e, span);\n    span.end();\n    throw e;\n  };\n\n  try {\n    const ret = fn(span) as Promise<ReturnType<F>>;\n    // if fn is an async function, attach a recordException and spanEnd callback to the promise\n    if (typeof ret?.then === 'function') {\n      return ret.then(val => {\n        span.end();\n        return val;\n      }, errorHandler) as ReturnType<F>;\n    }\n    span.end();\n    return ret as ReturnType<F>;\n  } catch (e) {\n    // add throw to signal the compiler that this will throw in the inner scope\n    throw errorHandler(e);\n  }\n}\n"],"mappings":";;;AAQA,MAAM,sBAAsB,GAAU,SAAe;CACnD,KAAK,gBAAgB,CAAC;CACtB,KAAK,UAAU,EACb,MAAA,EACF,CAAC;AACH;;;;;AAMA,SAAgB,WAAW,QAA+B;CACxD,OAAO,IAAI,cAAc,MAAM;AACjC;AAEA,IAAa,gBAAb,MAA6C;CAG3C,YAAY,QAAgB;EAC1B,KAAK,UAAU;EACf,KAAK,YAAY,OAAO,UAAU,KAAK,KAAK,OAAO;EACnD,KAAK,kBAAkB,OAAO,gBAAgB,KAAK,KAAK,OAAO;CACjE;CA0CA,eACE,MACA,MACA,MACA,MACe;EACf,MAAM,EAAE,MAAM,KAAK,OAAO,cAAc,MAAM,MAAM,IAAI;EAExD,OAAO,KAAK,QAAQ,gBAAgB,MAAM,MAAM,MAAM,SACpD,SAAS,MAAM,MAAM,EAAE,CACzB;CACF;CA4CA,SACE,MACA,MACA,MACA,MACe;EACf,MAAM,EAAE,MAAM,KAAK,OAAO,cAAc,MAAM,MAAM,IAAI;EAGxD,OAAO,SADM,KAAK,QAAQ,UAAU,MAAM,MAAM,GAC7B,GAAG,MAAM,EAAE;CAChC;AACF;;;;;;;AAQA,SAAS,cACP,KACA,MACA,MACA;;CACA,IAAI;CACJ,IAAI;CACJ,IAAI;CAEJ,IAAI,CAAC,QAAQ,CAAC,MACZ,KAAK;MACA,IAAI,CAAC,MAAM;EAChB,OAAO;EACP,KAAK;CACP,OAAO;EACL,OAAO;EACP,MAAM;EACN,KAAK;CACP;CACA,QAAA,QAAO,UAAA,QAAA,UAAA,KAAA,IAAA,QAAQ,CAAC;CAChB,OAAA,OAAM,SAAA,QAAA,SAAA,KAAA,IAAA,OAAOA,oBAAAA,QAAW,OAAO;CAE/B,OAAO;EAAE;EAAM;EAAK;CAAG;AACzB;;;;;;;AAQA,SAAS,SACP,MACA,MACA,IACe;;CACf,MAAM,eAAA,oBAAc,KAAK,iBAAA,QAAA,sBAAA,KAAA,IAAA,oBAAe;CACxC,MAAM,gBAAgB,MAAa;EACjC,YAAY,GAAG,IAAI;EACnB,KAAK,IAAI;EACT,MAAM;CACR;CAEA,IAAI;EACF,MAAM,MAAM,GAAG,IAAI;EAEnB,IAAI,QAAA,QAAA,QAAA,QAAA,KAAA,IAAA,KAAA,IAAO,IAAK,UAAS,YACvB,OAAO,IAAI,MAAK,QAAO;GACrB,KAAK,IAAI;GACT,OAAO;EACT,GAAG,YAAY;EAEjB,KAAK,IAAI;EACT,OAAO;CACT,SAAS,GAAG;EAEV,MAAM,aAAa,CAAC;CACtB;AACF"}

package/node_modules/@opentelemetry/api/dist/experimental/trace/SugaredTracer.d.cts

@@ -0,0 +1,69 @@
+import { Context } from "../../context/types.cjs";
+import { Span } from "../../trace/span.cjs";
+import { Tracer } from "../../trace/tracer.cjs";
+import { SugaredSpanOptions } from "./SugaredOptions.cjs";
+//#region src/experimental/trace/SugaredTracer.d.ts
+/**
+ * return a new SugaredTracer created from the supplied one
+ * @param tracer
+ */
+declare function wrapTracer(tracer: Tracer): SugaredTracer;
+declare class SugaredTracer implements Tracer {
+  private readonly _tracer;
+  constructor(tracer: Tracer);
+  startActiveSpan: Tracer['startActiveSpan'];
+  startSpan: Tracer['startSpan'];
+  /**
+   * Starts a new {@link Span} and calls the given function passing it the
+   * created span as first argument.
+   * Additionally, the new span gets set in context and this context is activated
+   * for the duration of the function call.
+   * The span will be closed after the function has executed.
+   * If an exception occurs, it is recorded, the status is set to ERROR and the exception is rethrown.
+   *
+   * @param name The name of the span
+   * @param [options] SugaredSpanOptions used for span creation
+   * @param [context] Context to use to extract parent
+   * @param fn function called in the context of the span and receives the newly created span as an argument
+   * @returns return value of fn
+   * @example
+   *     const something = tracer.withActiveSpan('op', span => {
+   *      // do some work
+   *     });
+   * @example
+   *     const something = await tracer.withActiveSpan('op', span => {
+   *      // do some async work
+   *     });
+   */
+  withActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, fn: F): ReturnType<F>;
+  withActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, fn: F): ReturnType<F>;
+  withActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType<F>;
+  /**
+   * Starts a new {@link Span} and ends it after execution of fn without setting it on context.
+   * The span will be closed after the function has executed.
+   * If an exception occurs, it is recorded, the status is et to ERROR and rethrown.
+   *
+   * This method does NOT modify the current Context.
+   *
+   * @param name The name of the span
+   * @param [options] SugaredSpanOptions used for span creation
+   * @param [context] Context to use to extract parent
+   * @param fn function called in the context of the span and receives the newly created span as an argument
+   * @returns Span The newly created span
+   * @example
+   *     const something = tracer.withSpan('op', span => {
+   *      // do some work
+   *     });
+   * @example
+   *     const something = await tracer.withSpan('op', span => {
+   *      // do some async work
+   *     });
+   */
+  withSpan<F extends (span: Span) => ReturnType<F>>(name: string, fn: F): ReturnType<F>;
+  withSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, fn: F): ReturnType<F>;
+  withSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType<F>;
+  withSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType<F>;
+}
+//#endregion
+export { SugaredTracer, wrapTracer };
+//# sourceMappingURL=SugaredTracer.d.cts.map

package/node_modules/@opentelemetry/api/dist/experimental/trace/SugaredTracer.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SugaredTracer.d.cts","names":[],"sources":["../../../src/experimental/trace/SugaredTracer.d.ts"],"mappings":";;;;;;;;;iBAMwB,WAAW,QAAQ,SAAS;cAC/B,yBAAyB;mBACzB;EACjB,YAAY,QAAQ;EACpB,iBAAiB;EACjB,WAAW;;;;;;;;;;;;;;;;;;;;;;;EAuBX,eAAe,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,IAAI,IAAI,WAAW;EACzF,eAAe,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,SAAS,oBAAoB,IAAI,IAAI,WAAW;EACtH,eAAe,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,SAAS,oBAAoB,SAAS,SAAS,IAAI,IAAI,WAAW;;;;;;;;;;;;;;;;;;;;;;EAsBxI,SAAS,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,IAAI,IAAI,WAAW;EACnF,SAAS,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,SAAS,oBAAoB,IAAI,IAAI,WAAW;EAChH,SAAS,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,SAAS,oBAAoB,SAAS,SAAS,IAAI,IAAI,WAAW;EAClI,SAAS,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,SAAS,oBAAoB,SAAS,SAAS,IAAI,IAAI,WAAW"}

package/node_modules/@opentelemetry/api/dist/experimental/trace/SugaredTracer.d.mts

@@ -0,0 +1,69 @@
+import { Context } from "../../context/types.mjs";
+import { Span } from "../../trace/span.mjs";
+import { Tracer } from "../../trace/tracer.mjs";
+import { SugaredSpanOptions } from "./SugaredOptions.mjs";
+//#region src/experimental/trace/SugaredTracer.d.ts
+/**
+ * return a new SugaredTracer created from the supplied one
+ * @param tracer
+ */
+declare function wrapTracer(tracer: Tracer): SugaredTracer;
+declare class SugaredTracer implements Tracer {
+  private readonly _tracer;
+  constructor(tracer: Tracer);
+  startActiveSpan: Tracer['startActiveSpan'];
+  startSpan: Tracer['startSpan'];
+  /**
+   * Starts a new {@link Span} and calls the given function passing it the
+   * created span as first argument.
+   * Additionally, the new span gets set in context and this context is activated
+   * for the duration of the function call.
+   * The span will be closed after the function has executed.
+   * If an exception occurs, it is recorded, the status is set to ERROR and the exception is rethrown.
+   *
+   * @param name The name of the span
+   * @param [options] SugaredSpanOptions used for span creation
+   * @param [context] Context to use to extract parent
+   * @param fn function called in the context of the span and receives the newly created span as an argument
+   * @returns return value of fn
+   * @example
+   *     const something = tracer.withActiveSpan('op', span => {
+   *      // do some work
+   *     });
+   * @example
+   *     const something = await tracer.withActiveSpan('op', span => {
+   *      // do some async work
+   *     });
+   */
+  withActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, fn: F): ReturnType<F>;
+  withActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, fn: F): ReturnType<F>;
+  withActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType<F>;
+  /**
+   * Starts a new {@link Span} and ends it after execution of fn without setting it on context.
+   * The span will be closed after the function has executed.
+   * If an exception occurs, it is recorded, the status is et to ERROR and rethrown.
+   *
+   * This method does NOT modify the current Context.
+   *
+   * @param name The name of the span
+   * @param [options] SugaredSpanOptions used for span creation
+   * @param [context] Context to use to extract parent
+   * @param fn function called in the context of the span and receives the newly created span as an argument
+   * @returns Span The newly created span
+   * @example
+   *     const something = tracer.withSpan('op', span => {
+   *      // do some work
+   *     });
+   * @example
+   *     const something = await tracer.withSpan('op', span => {
+   *      // do some async work
+   *     });
+   */
+  withSpan<F extends (span: Span) => ReturnType<F>>(name: string, fn: F): ReturnType<F>;
+  withSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, fn: F): ReturnType<F>;
+  withSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType<F>;
+  withSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType<F>;
+}
+//#endregion
+export { SugaredTracer, wrapTracer };
+//# sourceMappingURL=SugaredTracer.d.mts.map

package/node_modules/@opentelemetry/api/dist/experimental/trace/SugaredTracer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SugaredTracer.d.mts","names":[],"sources":["../../../src/experimental/trace/SugaredTracer.d.ts"],"mappings":";;;;;;;;;iBAMwB,WAAW,QAAQ,SAAS;cAC/B,yBAAyB;mBACzB;EACjB,YAAY,QAAQ;EACpB,iBAAiB;EACjB,WAAW;;;;;;;;;;;;;;;;;;;;;;;EAuBX,eAAe,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,IAAI,IAAI,WAAW;EACzF,eAAe,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,SAAS,oBAAoB,IAAI,IAAI,WAAW;EACtH,eAAe,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,SAAS,oBAAoB,SAAS,SAAS,IAAI,IAAI,WAAW;;;;;;;;;;;;;;;;;;;;;;EAsBxI,SAAS,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,IAAI,IAAI,WAAW;EACnF,SAAS,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,SAAS,oBAAoB,IAAI,IAAI,WAAW;EAChH,SAAS,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,SAAS,oBAAoB,SAAS,SAAS,IAAI,IAAI,WAAW;EAClI,SAAS,WAAW,MAAM,SAAS,WAAW,IAAI,cAAc,SAAS,oBAAoB,SAAS,SAAS,IAAI,IAAI,WAAW"}

package/node_modules/@opentelemetry/api/dist/experimental/trace/SugaredTracer.mjs

@@ -0,0 +1,87 @@
+import "../../trace/status.mjs";
+import { context } from "../../context-api.mjs";
+//#region src/experimental/trace/SugaredTracer.ts
+const defaultOnException = (e, span) => {
+	span.recordException(e);
+	span.setStatus({ code: 2 });
+};
+/**
+* return a new SugaredTracer created from the supplied one
+* @param tracer
+*/
+function wrapTracer(tracer) {
+	return new SugaredTracer(tracer);
+}
+var SugaredTracer = class {
+	constructor(tracer) {
+		this._tracer = tracer;
+		this.startSpan = tracer.startSpan.bind(this._tracer);
+		this.startActiveSpan = tracer.startActiveSpan.bind(this._tracer);
+	}
+	withActiveSpan(name, arg2, arg3, arg4) {
+		const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);
+		return this._tracer.startActiveSpan(name, opts, ctx, (span) => handleFn(span, opts, fn));
+	}
+	withSpan(name, arg2, arg3, arg4) {
+		const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);
+		return handleFn(this._tracer.startSpan(name, opts, ctx), opts, fn);
+	}
+};
+/**
+* Massages parameters of withSpan and withActiveSpan to allow signature overwrites
+* @param arg
+* @param arg2
+* @param arg3
+*/
+function massageParams(arg, arg2, arg3) {
+	var _opts, _ctx;
+	let opts;
+	let ctx;
+	let fn;
+	if (!arg2 && !arg3) fn = arg;
+	else if (!arg3) {
+		opts = arg;
+		fn = arg2;
+	} else {
+		opts = arg;
+		ctx = arg2;
+		fn = arg3;
+	}
+	opts = (_opts = opts) !== null && _opts !== void 0 ? _opts : {};
+	ctx = (_ctx = ctx) !== null && _ctx !== void 0 ? _ctx : context.active();
+	return {
+		opts,
+		ctx,
+		fn
+	};
+}
+/**
+* Executes fn, returns results and runs onException in the case of exception to allow overwriting of error handling
+* @param span
+* @param opts
+* @param fn
+*/
+function handleFn(span, opts, fn) {
+	var _opts$onException;
+	const onException = (_opts$onException = opts.onException) !== null && _opts$onException !== void 0 ? _opts$onException : defaultOnException;
+	const errorHandler = (e) => {
+		onException(e, span);
+		span.end();
+		throw e;
+	};
+	try {
+		const ret = fn(span);
+		if (typeof (ret === null || ret === void 0 ? void 0 : ret.then) === "function") return ret.then((val) => {
+			span.end();
+			return val;
+		}, errorHandler);
+		span.end();
+		return ret;
+	} catch (e) {
+		throw errorHandler(e);
+	}
+}
+//#endregion
+export { SugaredTracer, wrapTracer };
+
+//# sourceMappingURL=SugaredTracer.mjs.map

package/node_modules/@opentelemetry/api/dist/experimental/trace/SugaredTracer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SugaredTracer.mjs","names":["contextApi"],"sources":["../../../src/experimental/trace/SugaredTracer.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nimport type { SugaredSpanOptions } from './SugaredOptions';\nimport type { Context, Span, Tracer } from '../../';\nimport { context as contextApi, SpanStatusCode } from '../../';\n\nconst defaultOnException = (e: Error, span: Span) => {\n  span.recordException(e);\n  span.setStatus({\n    code: SpanStatusCode.ERROR,\n  });\n};\n\n/**\n * return a new SugaredTracer created from the supplied one\n * @param tracer\n */\nexport function wrapTracer(tracer: Tracer): SugaredTracer {\n  return new SugaredTracer(tracer);\n}\n\nexport class SugaredTracer implements Tracer {\n  private readonly _tracer: Tracer;\n\n  constructor(tracer: Tracer) {\n    this._tracer = tracer;\n    this.startSpan = tracer.startSpan.bind(this._tracer);\n    this.startActiveSpan = tracer.startActiveSpan.bind(this._tracer);\n  }\n\n  startActiveSpan: Tracer['startActiveSpan'];\n  startSpan: Tracer['startSpan'];\n\n  /**\n   * Starts a new {@link Span} and calls the given function passing it the\n   * created span as first argument.\n   * Additionally, the new span gets set in context and this context is activated\n   * for the duration of the function call.\n   * The span will be closed after the function has executed.\n   * If an exception occurs, it is recorded, the status is set to ERROR and the exception is rethrown.\n   *\n   * @param name The name of the span\n   * @param [options] SugaredSpanOptions used for span creation\n   * @param [context] Context to use to extract parent\n   * @param fn function called in the context of the span and receives the newly created span as an argument\n   * @returns return value of fn\n   * @example\n   *     const something = tracer.withActiveSpan('op', span => {\n   *      // do some work\n   *     });\n   * @example\n   *     const something = await tracer.withActiveSpan('op', span => {\n   *      // do some async work\n   *     });\n   */\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    arg2: F | SugaredSpanOptions,\n    arg3?: F | Context,\n    arg4?: F\n  ): ReturnType<F> {\n    const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);\n\n    return this._tracer.startActiveSpan(name, opts, ctx, (span: Span) =>\n      handleFn(span, opts, fn)\n    ) as ReturnType<F>;\n  }\n\n  /**\n   * Starts a new {@link Span} and ends it after execution of fn without setting it on context.\n   * The span will be closed after the function has executed.\n   * If an exception occurs, it is recorded, the status is et to ERROR and rethrown.\n   *\n   * This method does NOT modify the current Context.\n   *\n   * @param name The name of the span\n   * @param [options] SugaredSpanOptions used for span creation\n   * @param [context] Context to use to extract parent\n   * @param fn function called in the context of the span and receives the newly created span as an argument\n   * @returns Span The newly created span\n   * @example\n   *     const something = tracer.withSpan('op', span => {\n   *      // do some work\n   *     });\n   * @example\n   *     const something = await tracer.withSpan('op', span => {\n   *      // do some async work\n   *     });\n   */\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    arg2: SugaredSpanOptions | F,\n    arg3?: Context | F,\n    arg4?: F\n  ): ReturnType<F> {\n    const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);\n\n    const span = this._tracer.startSpan(name, opts, ctx);\n    return handleFn(span, opts, fn) as ReturnType<F>;\n  }\n}\n\n/**\n * Massages parameters of withSpan and withActiveSpan to allow signature overwrites\n * @param arg\n * @param arg2\n * @param arg3\n */\nfunction massageParams<F extends (span: Span) => ReturnType<F>>(\n  arg: F | SugaredSpanOptions,\n  arg2?: F | Context,\n  arg3?: F\n) {\n  let opts: SugaredSpanOptions | undefined;\n  let ctx: Context | undefined;\n  let fn: F;\n\n  if (!arg2 && !arg3) {\n    fn = arg as F;\n  } else if (!arg3) {\n    opts = arg as SugaredSpanOptions;\n    fn = arg2 as F;\n  } else {\n    opts = arg as SugaredSpanOptions;\n    ctx = arg2 as Context;\n    fn = arg3 as F;\n  }\n  opts = opts ?? {};\n  ctx = ctx ?? contextApi.active();\n\n  return { opts, ctx, fn };\n}\n\n/**\n * Executes fn, returns results and runs onException in the case of exception to allow overwriting of error handling\n * @param span\n * @param opts\n * @param fn\n */\nfunction handleFn<F extends (span: Span) => ReturnType<F>>(\n  span: Span,\n  opts: SugaredSpanOptions,\n  fn: F\n): ReturnType<F> {\n  const onException = opts.onException ?? defaultOnException;\n  const errorHandler = (e: Error) => {\n    onException(e, span);\n    span.end();\n    throw e;\n  };\n\n  try {\n    const ret = fn(span) as Promise<ReturnType<F>>;\n    // if fn is an async function, attach a recordException and spanEnd callback to the promise\n    if (typeof ret?.then === 'function') {\n      return ret.then(val => {\n        span.end();\n        return val;\n      }, errorHandler) as ReturnType<F>;\n    }\n    span.end();\n    return ret as ReturnType<F>;\n  } catch (e) {\n    // add throw to signal the compiler that this will throw in the inner scope\n    throw errorHandler(e);\n  }\n}\n"],"mappings":";;;AAQA,MAAM,sBAAsB,GAAU,SAAe;CACnD,KAAK,gBAAgB,CAAC;CACtB,KAAK,UAAU,EACb,MAAA,EACF,CAAC;AACH;;;;;AAMA,SAAgB,WAAW,QAA+B;CACxD,OAAO,IAAI,cAAc,MAAM;AACjC;AAEA,IAAa,gBAAb,MAA6C;CAG3C,YAAY,QAAgB;EAC1B,KAAK,UAAU;EACf,KAAK,YAAY,OAAO,UAAU,KAAK,KAAK,OAAO;EACnD,KAAK,kBAAkB,OAAO,gBAAgB,KAAK,KAAK,OAAO;CACjE;CA0CA,eACE,MACA,MACA,MACA,MACe;EACf,MAAM,EAAE,MAAM,KAAK,OAAO,cAAc,MAAM,MAAM,IAAI;EAExD,OAAO,KAAK,QAAQ,gBAAgB,MAAM,MAAM,MAAM,SACpD,SAAS,MAAM,MAAM,EAAE,CACzB;CACF;CA4CA,SACE,MACA,MACA,MACA,MACe;EACf,MAAM,EAAE,MAAM,KAAK,OAAO,cAAc,MAAM,MAAM,IAAI;EAGxD,OAAO,SADM,KAAK,QAAQ,UAAU,MAAM,MAAM,GAC7B,GAAG,MAAM,EAAE;CAChC;AACF;;;;;;;AAQA,SAAS,cACP,KACA,MACA,MACA;;CACA,IAAI;CACJ,IAAI;CACJ,IAAI;CAEJ,IAAI,CAAC,QAAQ,CAAC,MACZ,KAAK;MACA,IAAI,CAAC,MAAM;EAChB,OAAO;EACP,KAAK;CACP,OAAO;EACL,OAAO;EACP,MAAM;EACN,KAAK;CACP;CACA,QAAA,QAAO,UAAA,QAAA,UAAA,KAAA,IAAA,QAAQ,CAAC;CAChB,OAAA,OAAM,SAAA,QAAA,SAAA,KAAA,IAAA,OAAOA,QAAW,OAAO;CAE/B,OAAO;EAAE;EAAM;EAAK;CAAG;AACzB;;;;;;;AAQA,SAAS,SACP,MACA,MACA,IACe;;CACf,MAAM,eAAA,oBAAc,KAAK,iBAAA,QAAA,sBAAA,KAAA,IAAA,oBAAe;CACxC,MAAM,gBAAgB,MAAa;EACjC,YAAY,GAAG,IAAI;EACnB,KAAK,IAAI;EACT,MAAM;CACR;CAEA,IAAI;EACF,MAAM,MAAM,GAAG,IAAI;EAEnB,IAAI,QAAA,QAAA,QAAA,QAAA,KAAA,IAAA,KAAA,IAAO,IAAK,UAAS,YACvB,OAAO,IAAI,MAAK,QAAO;GACrB,KAAK,IAAI;GACT,OAAO;EACT,GAAG,YAAY;EAEjB,KAAK,IAAI;EACT,OAAO;CACT,SAAS,GAAG;EAEV,MAAM,aAAa,CAAC;CACtB;AACF"}

package/node_modules/@opentelemetry/api/dist/index.cjs

@@ -0,0 +1,71 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_types = require("./diag/types.cjs");
+const require_utils = require("./baggage/utils.cjs");
+const require_context = require("./context/context.cjs");
+const require_consoleLogger = require("./diag/consoleLogger.cjs");
+const require_NoopMeter = require("./metrics/NoopMeter.cjs");
+const require_Metric = require("./metrics/Metric.cjs");
+const require_NoopLogger = require("./logs/NoopLogger.cjs");
+const require_LogRecord = require("./logs/LogRecord.cjs");
+const require_TextMapPropagator = require("./propagation/TextMapPropagator.cjs");
+const require_trace_flags = require("./trace/trace_flags.cjs");
+const require_invalid_span_constants = require("./trace/invalid-span-constants.cjs");
+const require_spancontext_utils = require("./trace/spancontext-utils.cjs");
+const require_ProxyTracer = require("./trace/ProxyTracer.cjs");
+const require_span_kind = require("./trace/span_kind.cjs");
+const require_status = require("./trace/status.cjs");
+const require_utils$1 = require("./trace/internal/utils.cjs");
+const require_ProxyTracerProvider = require("./trace/ProxyTracerProvider.cjs");
+const require_SamplingResult = require("./trace/SamplingResult.cjs");
+const require_context_api = require("./context-api.cjs");
+const require_diag_api = require("./diag-api.cjs");
+const require_logs_api = require("./logs-api.cjs");
+const require_metrics_api = require("./metrics-api.cjs");
+const require_propagation_api = require("./propagation-api.cjs");
+const require_trace_api = require("./trace-api.cjs");
+//#region src/index.ts
+var src_default = {
+	context: require_context_api.context,
+	diag: require_diag_api.diag,
+	logs: require_logs_api.logs,
+	metrics: require_metrics_api.metrics,
+	propagation: require_propagation_api.propagation,
+	trace: require_trace_api.trace
+};
+//#endregion
+exports.DiagConsoleLogger = require_consoleLogger.DiagConsoleLogger;
+exports.DiagLogLevel = require_types.DiagLogLevel;
+exports.INVALID_SPANID = require_invalid_span_constants.INVALID_SPANID;
+exports.INVALID_SPAN_CONTEXT = require_invalid_span_constants.INVALID_SPAN_CONTEXT;
+exports.INVALID_TRACEID = require_invalid_span_constants.INVALID_TRACEID;
+exports.ProxyTracer = require_ProxyTracer.ProxyTracer;
+exports.ProxyTracerProvider = require_ProxyTracerProvider.ProxyTracerProvider;
+exports.ROOT_CONTEXT = require_context.ROOT_CONTEXT;
+exports.SamplingDecision = require_SamplingResult.SamplingDecision;
+exports.SeverityNumber = require_LogRecord.SeverityNumber;
+exports.SpanKind = require_span_kind.SpanKind;
+exports.SpanStatusCode = require_status.SpanStatusCode;
+exports.TraceFlags = require_trace_flags.TraceFlags;
+exports.ValueType = require_Metric.ValueType;
+exports.baggageEntryMetadataFromString = require_utils.baggageEntryMetadataFromString;
+exports.context = require_context_api.context;
+exports.createContextKey = require_context.createContextKey;
+exports.createNoopLogger = require_NoopLogger.createNoopLogger;
+exports.createNoopMeter = require_NoopMeter.createNoopMeter;
+exports.createTraceState = require_utils$1.createTraceState;
+exports.default = src_default;
+exports.defaultTextMapGetter = require_TextMapPropagator.defaultTextMapGetter;
+exports.defaultTextMapSetter = require_TextMapPropagator.defaultTextMapSetter;
+exports.diag = require_diag_api.diag;
+exports.isSpanContextValid = require_spancontext_utils.isSpanContextValid;
+exports.isValidSpanId = require_spancontext_utils.isValidSpanId;
+exports.isValidTraceId = require_spancontext_utils.isValidTraceId;
+exports.logs = require_logs_api.logs;
+exports.metrics = require_metrics_api.metrics;
+exports.propagation = require_propagation_api.propagation;
+exports.trace = require_trace_api.trace;
+
+//# sourceMappingURL=index.cjs.map

package/node_modules/@opentelemetry/api/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @module @opentelemetry/api\n */\n\nexport type {\n  BaggageEntry,\n  BaggageEntryMetadata,\n  Baggage,\n} from './baggage/types';\nexport { baggageEntryMetadataFromString } from './baggage/utils';\nexport type { Exception } from './common/Exception';\nexport type { HrTime, TimeInput } from './common/Time';\nexport type { AnyValue } from './common/AnyValue';\nexport type { Attributes, AttributeValue } from './common/Attributes';\n\n// Context APIs\nexport { createContextKey, ROOT_CONTEXT } from './context/context';\nexport type {\n  Context,\n  ContextManager,\n  ContextManagementToken,\n} from './context/types';\nexport type { ContextAPI } from './api/context';\n\n// Diag APIs\nexport { DiagConsoleLogger } from './diag/consoleLogger';\nexport { DiagLogLevel } from './diag/types';\nexport type {\n  DiagLogFunction,\n  DiagLogger,\n  ComponentLoggerOptions,\n  DiagLoggerOptions,\n} from './diag/types';\nexport type { DiagAPI } from './api/diag';\n\n// Metrics APIs\nexport { createNoopMeter } from './metrics/NoopMeter';\nexport type { MeterOptions, Meter } from './metrics/Meter';\nexport type { MeterProvider } from './metrics/MeterProvider';\nexport { ValueType } from './metrics/Metric';\nexport type {\n  Counter,\n  Gauge,\n  Histogram,\n  MetricOptions,\n  UpDownCounter,\n  MetricAdvice,\n  MetricAttributes,\n  MetricAttributeValue,\n  Observable,\n  ObservableCounter,\n  ObservableGauge,\n  ObservableUpDownCounter,\n  BatchObservableCallback,\n  ObservableCallback,\n  BatchObservableResult,\n  ObservableResult,\n} from './metrics/Metric';\nexport type { MetricsAPI } from './api/metrics';\n\n// Logs APIs\nexport { createNoopLogger } from './logs/NoopLogger';\nexport { SeverityNumber } from './logs/LogRecord';\nexport type { LogRecord } from './logs/LogRecord';\nexport type { Logger } from './logs/Logger';\nexport type { LoggerOptions } from './logs/LoggerOptions';\nexport type { LoggerProvider } from './logs/LoggerProvider';\n\n// Propagation APIs\nexport {\n  defaultTextMapGetter,\n  defaultTextMapSetter,\n} from './propagation/TextMapPropagator';\nexport type {\n  TextMapPropagator,\n  TextMapSetter,\n  TextMapGetter,\n} from './propagation/TextMapPropagator';\nexport type { PropagationAPI } from './api/propagation';\n\n// Trace APIs\nexport type { Link } from './trace/link';\nexport { ProxyTracer, type TracerDelegator } from './trace/ProxyTracer';\nexport type { SpanContext } from './trace/span_context';\nexport { SpanKind } from './trace/span_kind';\nexport type { Span } from './trace/span';\nexport type { SpanOptions } from './trace/SpanOptions';\nexport { type SpanStatus, SpanStatusCode } from './trace/status';\nexport { TraceFlags } from './trace/trace_flags';\nexport type { TraceState } from './trace/trace_state';\nexport { createTraceState } from './trace/internal/utils';\nexport type { TracerProvider } from './trace/tracer_provider';\nexport type { Tracer } from './trace/tracer';\nexport type { TracerOptions } from './trace/tracer_options';\nexport {\n  isSpanContextValid,\n  isValidTraceId,\n  isValidSpanId,\n} from './trace/spancontext-utils';\nexport {\n  INVALID_SPANID,\n  INVALID_TRACEID,\n  INVALID_SPAN_CONTEXT,\n} from './trace/invalid-span-constants';\nexport type { TraceAPI } from './api/trace';\n\n// Deprecated Trace APIs\nexport type { SpanAttributes, SpanAttributeValue } from './trace/attributes';\n// TODO: Remove ProxyTracerProvider export in the next major version.\nexport { ProxyTracerProvider } from './trace/ProxyTracerProvider';\nexport type { Sampler } from './trace/Sampler';\nexport { SamplingDecision, type SamplingResult } from './trace/SamplingResult';\n\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { context } from './context-api';\nimport { diag } from './diag-api';\nimport { logs } from './logs-api';\nimport { metrics } from './metrics-api';\nimport { propagation } from './propagation-api';\nimport { trace } from './trace-api';\n\n// Named export.\nexport { context, diag, logs, metrics, propagation, trace };\n// Default export.\nexport default {\n  context,\n  diag,\n  logs,\n  metrics,\n  propagation,\n  trace,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkIA,IAAA,cAAe;CACb,SAAA,oBAAA;CACA,MAAA,iBAAA;CACA,MAAA,iBAAA;CACA,SAAA,oBAAA;CACA,aAAA,wBAAA;CACA,OAAA,kBAAA;AACF"}

package/node_modules/@opentelemetry/api/dist/index.d.cts

@@ -0,0 +1,63 @@
+import { Context, ContextManagementToken, ContextManager } from "./context/types.cjs";
+import { ContextAPI } from "./api/context.cjs";
+import { ComponentLoggerOptions, DiagLogFunction, DiagLogLevel, DiagLogger, DiagLoggerOptions } from "./diag/types.cjs";
+import { DiagAPI } from "./api/diag.cjs";
+import { AnyValue } from "./common/AnyValue.cjs";
+import { AttributeValue, Attributes } from "./common/Attributes.cjs";
+import { HrTime, TimeInput } from "./common/Time.cjs";
+import { LogRecord, SeverityNumber } from "./logs/LogRecord.cjs";
+import { Logger } from "./logs/Logger.cjs";
+import { LoggerOptions } from "./logs/LoggerOptions.cjs";
+import { LoggerProvider } from "./logs/LoggerProvider.cjs";
+import { LogsAPI } from "./api/logs.cjs";
+import { BatchObservableCallback, BatchObservableResult, Counter, Gauge, Histogram, MetricAdvice, MetricAttributeValue, MetricAttributes, MetricOptions, Observable, ObservableCallback, ObservableCounter, ObservableGauge, ObservableResult, ObservableUpDownCounter, UpDownCounter, ValueType } from "./metrics/Metric.cjs";
+import { Meter, MeterOptions } from "./metrics/Meter.cjs";
+import { MeterProvider } from "./metrics/MeterProvider.cjs";
+import { MetricsAPI } from "./api/metrics.cjs";
+import { TextMapGetter, TextMapPropagator, TextMapSetter, defaultTextMapGetter, defaultTextMapSetter } from "./propagation/TextMapPropagator.cjs";
+import { Baggage, BaggageEntry, BaggageEntryMetadata } from "./baggage/types.cjs";
+import { baggageEntryMetadataFromString } from "./baggage/utils.cjs";
+import { PropagationAPI } from "./api/propagation.cjs";
+import { Exception } from "./common/Exception.cjs";
+import { SpanAttributeValue, SpanAttributes } from "./trace/attributes.cjs";
+import { TraceState } from "./trace/trace_state.cjs";
+import { SpanContext } from "./trace/span_context.cjs";
+import { SpanStatus, SpanStatusCode } from "./trace/status.cjs";
+import { Link } from "./trace/link.cjs";
+import { Span } from "./trace/span.cjs";
+import { isSpanContextValid, isValidSpanId, isValidTraceId } from "./trace/spancontext-utils.cjs";
+import { SpanKind } from "./trace/span_kind.cjs";
+import { SpanOptions } from "./trace/SpanOptions.cjs";
+import { Tracer } from "./trace/tracer.cjs";
+import { TracerOptions } from "./trace/tracer_options.cjs";
+import { TracerProvider } from "./trace/tracer_provider.cjs";
+import { TraceAPI } from "./api/trace.cjs";
+import { ROOT_CONTEXT, createContextKey } from "./context/context.cjs";
+import { DiagConsoleLogger } from "./diag/consoleLogger.cjs";
+import { createNoopMeter } from "./metrics/NoopMeter.cjs";
+import { createNoopLogger } from "./logs/NoopLogger.cjs";
+import { ProxyTracer, TracerDelegator } from "./trace/ProxyTracer.cjs";
+import { TraceFlags } from "./trace/trace_flags.cjs";
+import { createTraceState } from "./trace/internal/utils.cjs";
+import { INVALID_SPANID, INVALID_SPAN_CONTEXT, INVALID_TRACEID } from "./trace/invalid-span-constants.cjs";
+import { ProxyTracerProvider } from "./trace/ProxyTracerProvider.cjs";
+import { SamplingDecision, SamplingResult } from "./trace/SamplingResult.cjs";
+import { Sampler } from "./trace/Sampler.cjs";
+import { context } from "./context-api.cjs";
+import { diag } from "./diag-api.cjs";
+import { logs } from "./logs-api.cjs";
+import { metrics } from "./metrics-api.cjs";
+import { propagation } from "./propagation-api.cjs";
+import { trace } from "./trace-api.cjs";
+//#region src/index.d.ts
+declare const _default: {
+  context: ContextAPI;
+  diag: DiagAPI;
+  logs: LogsAPI;
+  metrics: MetricsAPI;
+  propagation: PropagationAPI;
+  trace: TraceAPI;
+};
+//#endregion
+export { type AnyValue, type AttributeValue, type Attributes, type Baggage, type BaggageEntry, type BaggageEntryMetadata, type BatchObservableCallback, type BatchObservableResult, type ComponentLoggerOptions, type Context, type ContextAPI, type ContextManagementToken, type ContextManager, type Counter, type DiagAPI, DiagConsoleLogger, type DiagLogFunction, DiagLogLevel, type DiagLogger, type DiagLoggerOptions, type Exception, type Gauge, type Histogram, type HrTime, INVALID_SPANID, INVALID_SPAN_CONTEXT, INVALID_TRACEID, type Link, type LogRecord, type Logger, type LoggerOptions, type LoggerProvider, type Meter, type MeterOptions, type MeterProvider, type MetricAdvice, type MetricAttributeValue, type MetricAttributes, type MetricOptions, type MetricsAPI, type Observable, type ObservableCallback, type ObservableCounter, type ObservableGauge, type ObservableResult, type ObservableUpDownCounter, type PropagationAPI, ProxyTracer, ProxyTracerProvider, ROOT_CONTEXT, type Sampler, SamplingDecision, type SamplingResult, SeverityNumber, type Span, type SpanAttributeValue, type SpanAttributes, type SpanContext, SpanKind, type SpanOptions, type SpanStatus, SpanStatusCode, type TextMapGetter, type TextMapPropagator, type TextMapSetter, type TimeInput, type TraceAPI, TraceFlags, type TraceState, type Tracer, type TracerDelegator, type TracerOptions, type TracerProvider, type UpDownCounter, ValueType, baggageEntryMetadataFromString, context, createContextKey, createNoopLogger, createNoopMeter, createTraceState, _default as default, defaultTextMapGetter, defaultTextMapSetter, diag, isSpanContextValid, isValidSpanId, isValidTraceId, logs, metrics, propagation, trace };
+//# sourceMappingURL=index.d.cts.map

package/node_modules/@opentelemetry/api/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.d.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0Dc;EACV,SADU;EAEV,MADiC;EAEjC,MAD2B;EAE3B,SAD2B;EAE3B,aADiC;EAEjC,OADyC"}

package/node_modules/@opentelemetry/api/dist/index.d.mts

@@ -0,0 +1,63 @@
+import { Context, ContextManagementToken, ContextManager } from "./context/types.mjs";
+import { ContextAPI } from "./api/context.mjs";
+import { ComponentLoggerOptions, DiagLogFunction, DiagLogLevel, DiagLogger, DiagLoggerOptions } from "./diag/types.mjs";
+import { DiagAPI } from "./api/diag.mjs";
+import { AnyValue } from "./common/AnyValue.mjs";
+import { AttributeValue, Attributes } from "./common/Attributes.mjs";
+import { HrTime, TimeInput } from "./common/Time.mjs";
+import { LogRecord, SeverityNumber } from "./logs/LogRecord.mjs";
+import { Logger } from "./logs/Logger.mjs";
+import { LoggerOptions } from "./logs/LoggerOptions.mjs";
+import { LoggerProvider } from "./logs/LoggerProvider.mjs";
+import { LogsAPI } from "./api/logs.mjs";
+import { BatchObservableCallback, BatchObservableResult, Counter, Gauge, Histogram, MetricAdvice, MetricAttributeValue, MetricAttributes, MetricOptions, Observable, ObservableCallback, ObservableCounter, ObservableGauge, ObservableResult, ObservableUpDownCounter, UpDownCounter, ValueType } from "./metrics/Metric.mjs";
+import { Meter, MeterOptions } from "./metrics/Meter.mjs";
+import { MeterProvider } from "./metrics/MeterProvider.mjs";
+import { MetricsAPI } from "./api/metrics.mjs";
+import { TextMapGetter, TextMapPropagator, TextMapSetter, defaultTextMapGetter, defaultTextMapSetter } from "./propagation/TextMapPropagator.mjs";
+import { Baggage, BaggageEntry, BaggageEntryMetadata } from "./baggage/types.mjs";
+import { baggageEntryMetadataFromString } from "./baggage/utils.mjs";
+import { PropagationAPI } from "./api/propagation.mjs";
+import { Exception } from "./common/Exception.mjs";
+import { SpanAttributeValue, SpanAttributes } from "./trace/attributes.mjs";
+import { TraceState } from "./trace/trace_state.mjs";
+import { SpanContext } from "./trace/span_context.mjs";
+import { SpanStatus, SpanStatusCode } from "./trace/status.mjs";
+import { Link } from "./trace/link.mjs";
+import { Span } from "./trace/span.mjs";
+import { isSpanContextValid, isValidSpanId, isValidTraceId } from "./trace/spancontext-utils.mjs";
+import { SpanKind } from "./trace/span_kind.mjs";
+import { SpanOptions } from "./trace/SpanOptions.mjs";
+import { Tracer } from "./trace/tracer.mjs";
+import { TracerOptions } from "./trace/tracer_options.mjs";
+import { TracerProvider } from "./trace/tracer_provider.mjs";
+import { TraceAPI } from "./api/trace.mjs";
+import { ROOT_CONTEXT, createContextKey } from "./context/context.mjs";
+import { DiagConsoleLogger } from "./diag/consoleLogger.mjs";
+import { createNoopMeter } from "./metrics/NoopMeter.mjs";
+import { createNoopLogger } from "./logs/NoopLogger.mjs";
+import { ProxyTracer, TracerDelegator } from "./trace/ProxyTracer.mjs";
+import { TraceFlags } from "./trace/trace_flags.mjs";
+import { createTraceState } from "./trace/internal/utils.mjs";
+import { INVALID_SPANID, INVALID_SPAN_CONTEXT, INVALID_TRACEID } from "./trace/invalid-span-constants.mjs";
+import { ProxyTracerProvider } from "./trace/ProxyTracerProvider.mjs";
+import { SamplingDecision, SamplingResult } from "./trace/SamplingResult.mjs";
+import { Sampler } from "./trace/Sampler.mjs";
+import { context } from "./context-api.mjs";
+import { diag } from "./diag-api.mjs";
+import { logs } from "./logs-api.mjs";
+import { metrics } from "./metrics-api.mjs";
+import { propagation } from "./propagation-api.mjs";
+import { trace } from "./trace-api.mjs";
+//#region src/index.d.ts
+declare const _default: {
+  context: ContextAPI;
+  diag: DiagAPI;
+  logs: LogsAPI;
+  metrics: MetricsAPI;
+  propagation: PropagationAPI;
+  trace: TraceAPI;
+};
+//#endregion
+export { type AnyValue, type AttributeValue, type Attributes, type Baggage, type BaggageEntry, type BaggageEntryMetadata, type BatchObservableCallback, type BatchObservableResult, type ComponentLoggerOptions, type Context, type ContextAPI, type ContextManagementToken, type ContextManager, type Counter, type DiagAPI, DiagConsoleLogger, type DiagLogFunction, DiagLogLevel, type DiagLogger, type DiagLoggerOptions, type Exception, type Gauge, type Histogram, type HrTime, INVALID_SPANID, INVALID_SPAN_CONTEXT, INVALID_TRACEID, type Link, type LogRecord, type Logger, type LoggerOptions, type LoggerProvider, type Meter, type MeterOptions, type MeterProvider, type MetricAdvice, type MetricAttributeValue, type MetricAttributes, type MetricOptions, type MetricsAPI, type Observable, type ObservableCallback, type ObservableCounter, type ObservableGauge, type ObservableResult, type ObservableUpDownCounter, type PropagationAPI, ProxyTracer, ProxyTracerProvider, ROOT_CONTEXT, type Sampler, SamplingDecision, type SamplingResult, SeverityNumber, type Span, type SpanAttributeValue, type SpanAttributes, type SpanContext, SpanKind, type SpanOptions, type SpanStatus, SpanStatusCode, type TextMapGetter, type TextMapPropagator, type TextMapSetter, type TimeInput, type TraceAPI, TraceFlags, type TraceState, type Tracer, type TracerDelegator, type TracerOptions, type TracerProvider, type UpDownCounter, ValueType, baggageEntryMetadataFromString, context, createContextKey, createNoopLogger, createNoopMeter, createTraceState, _default as default, defaultTextMapGetter, defaultTextMapSetter, diag, isSpanContextValid, isValidSpanId, isValidTraceId, logs, metrics, propagation, trace };
+//# sourceMappingURL=index.d.mts.map

package/node_modules/@opentelemetry/api/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.d.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0Dc;EACV,SADU;EAEV,MADiC;EAEjC,MAD2B;EAE3B,SAD2B;EAE3B,aADiC;EAEjC,OADyC"}