abxbus 2.5.6 → 2.5.9

package/src/LockManager.ts

@@ -283,7 +283,7 @@ export class LockManager {
       this.idle_waiters.push(finish)
       this.scheduleIdleCheck()
 
-      if (timeout_seconds === null || timeout_seconds === undefined) {
+      if (timeout_seconds === null || timeout_seconds === undefined || timeout_seconds <= 0) {
         return
       }
 

package/src/events_suck.ts

@@ -3,28 +3,22 @@ import { BaseEvent } from './BaseEvent.js'
 
 import type { EventClass, EventResultType } from './types.js'
 
-type EventMap = Record<string, EventClass<BaseEvent>>
-type AnyFn = (...args: any[]) => any
-type FunctionMap = Record<string, AnyFn>
+type EventMap = Record<string, EventClass<BaseEvent, never>>
+type FunctionMap = Record<string, (...args: never[]) => unknown>
 type ExtraDict = Record<string, unknown>
 
-type EventFieldsFromFn<TFunc extends AnyFn> =
-  Parameters<TFunc> extends [infer TArg] ? (TArg extends Record<string, unknown> ? TArg : ExtraDict) : ExtraDict
-
-type GeneratedEvent<TFunc extends AnyFn> = {
-  (
-    data: EventFieldsFromFn<TFunc> & ExtraDict
-  ): BaseEvent & EventFieldsFromFn<TFunc> & { __event_result_type__?: Awaited<ReturnType<TFunc>> }
-  new (
-    data: EventFieldsFromFn<TFunc> & ExtraDict
-  ): BaseEvent & EventFieldsFromFn<TFunc> & { __event_result_type__?: Awaited<ReturnType<TFunc>> }
-  event_type?: string
-}
+type EventFieldsFromFn<TFunc extends FunctionMap[string]> =
+  Parameters<TFunc> extends [infer TArg, ...unknown[]] ? (TArg extends Record<string, unknown> ? TArg : ExtraDict) : ExtraDict
+
+type EventFromFn<TFunc extends FunctionMap[string]> = BaseEvent &
+  EventFieldsFromFn<TFunc> & {
+    __event_result_type__?: Awaited<ReturnType<TFunc>>
+  }
 
 export type GeneratedEvents<TEvents extends FunctionMap> = {
-  by_name: { [K in keyof TEvents]: GeneratedEvent<TEvents[K]> }
+  by_name: { [K in keyof TEvents]: EventClass<EventFromFn<TEvents[K]>, EventFieldsFromFn<TEvents[K]> & ExtraDict> }
 } & {
-  [K in keyof TEvents]: GeneratedEvent<TEvents[K]>
+  [K in keyof TEvents]: EventClass<EventFromFn<TEvents[K]>, EventFieldsFromFn<TEvents[K]> & ExtraDict>
 }
 
 type EventInit<TEventClass extends EventClass<BaseEvent>> = [ConstructorParameters<TEventClass>[0]] extends [undefined]
@@ -51,12 +45,12 @@ type DynamicWrappedClient = {
 } & Record<string, (...args: unknown[]) => Promise<unknown>>
 
 export const make_events = <TEvents extends FunctionMap>(events: TEvents): GeneratedEvents<TEvents> => {
-  const by_name = {} as { [K in keyof TEvents]: GeneratedEvent<TEvents[K]> }
+  const by_name = {} as GeneratedEvents<TEvents>['by_name']
   for (const [event_name] of Object.entries(events) as Array<[keyof TEvents, TEvents[keyof TEvents]]>) {
     if (!/^[A-Za-z_$][\w$]*$/.test(String(event_name))) {
       throw new Error(`Invalid event name: ${String(event_name)}`)
     }
-    by_name[event_name] = BaseEvent.extend(String(event_name), {}) as unknown as GeneratedEvent<TEvents[keyof TEvents]>
+    by_name[event_name] = BaseEvent.extend(String(event_name), {}) as unknown as GeneratedEvents<TEvents>['by_name'][typeof event_name]
   }
   return Object.assign({ by_name }, by_name) as GeneratedEvents<TEvents>
 }
@@ -76,7 +70,10 @@ export const wrap = <TEvents extends EventMap>(class_name: string, methods: TEve
     Object.defineProperty(WrappedClient.prototype, method_name, {
       value: async function (this: DynamicWrappedClient, init?: Record<string, unknown>, extra?: Record<string, unknown>) {
         const payload = { ...(init ?? {}), ...(extra ?? {}) }
-        return await this.bus.emit(new EventCtor(payload)).now({ first_result: true }).eventResult()
+        return await this.bus
+          .emit((EventCtor as EventClass<BaseEvent, Record<string, unknown>>)(payload))
+          .now({ first_result: true })
+          .eventResult()
       },
       writable: true,
       configurable: true,

package/src/retry.ts

@@ -21,6 +21,8 @@ type RetryDecorator = {
 
 const MULTIPROCESS_SEMAPHORE_DIRNAME = 'browser_use_semaphores'
 const MULTIPROCESS_STALE_LOCK_MS = 5 * 60 * 1000
+const RETRY_SLOW_WARNING_THROTTLE_MS = 2000
+const RETRY_SLOW_WARNING_ARGS_MAX_LENGTH = 80
 
 let multiprocess_fallback_reason_logged: string | null = null
 
@@ -44,6 +46,9 @@ export interface RetryOptions {
   /** Per-attempt timeout in seconds. Default: undefined (no per-attempt timeout) */
   timeout?: number | null
 
+  /** Emit a warning when a decorated call exceeds this many seconds. Default: undefined (disabled) */
+  slow_timeout?: number | null
+
   /** Maximum concurrent executions sharing this semaphore. Default: undefined (no concurrency limit) */
   semaphore_limit?: number | null
 
@@ -238,6 +243,7 @@ export function retry(options: RetryOptions = {}): RetryDecorator {
     retry_backoff_factor = 1.0,
     retry_on_errors,
     timeout,
+    slow_timeout,
     semaphore_limit,
     semaphore_name: semaphore_name_option,
     semaphore_lax = true,
@@ -245,10 +251,13 @@ export function retry(options: RetryOptions = {}): RetryDecorator {
     semaphore_timeout,
   } = options
 
-  const decorateFunction = <T extends AnyFunction>(target: T, _context?: ClassMethodDecoratorContext): T => {
-    const fn_name = target.name || (_context?.name as string) || 'anonymous'
+  const decorateFunction = <T extends AnyFunction>(target: T, _context?: ClassMethodDecoratorContext, owner_name?: string | null): T => {
+    const base_fn_name = target.name || (_context?.name as string) || 'anonymous'
+    let fn_name = owner_name ? `${owner_name}.${base_fn_name}` : base_fn_name
     const effective_max_attempts = Math.max(1, max_attempts)
     const effective_retry_after = Math.max(0, retry_after)
+    const effective_slow_timeout_ms = slow_timeout != null && slow_timeout > 0 ? slow_timeout * 1000 : null
+    let last_slow_warning_at = 0
 
     const shouldRetry = (error: unknown): boolean => {
       if (!retry_on_errors || retry_on_errors.length === 0) return true
@@ -275,6 +284,14 @@ export function retry(options: RetryOptions = {}): RetryDecorator {
       }
     }
 
+    const emitSlowWarningIfDue = (args: any[], start_time: number): void => {
+      if (effective_slow_timeout_ms == null) return
+      const now = Date.now()
+      if (now - last_slow_warning_at < RETRY_SLOW_WARNING_THROTTLE_MS) return
+      last_slow_warning_at = now
+      console.warn(`Warning: ${fn_name}(${formatRetrySlowWarningArgs(args)}) slow (${((now - start_time) / 1000).toFixed(1)}s)`)
+    }
+
     const runRetryLoopFromThenable = async (
       this_arg: any,
       args: any[],
@@ -373,26 +390,45 @@ export function retry(options: RetryOptions = {}): RetryDecorator {
 
       // ── Retry loop (runs inside the semaphore and re-entrancy context) ──
       const runRetryLoop = async (): Promise<any> => {
-        for (let attempt = 1; attempt <= effective_max_attempts; attempt++) {
-          try {
-            if (timeout != null && timeout > 0) {
-              return await _runWithTimeout(() => Promise.resolve(target.apply(this, args)), timeout * 1000, attempt)
-            } else {
-              return await Promise.resolve(target.apply(this, args))
-            }
-          } catch (error) {
-            if (!shouldRetry(error)) throw error
+        const call_started_at = Date.now()
+        const warning_args = [...args]
+        const slow_warning_timer =
+          effective_slow_timeout_ms == null
+            ? null
+            : setTimeout(() => emitSlowWarningIfDue(warning_args, call_started_at), effective_slow_timeout_ms)
+        const finishSlowWarning = (): void => {
+          if (slow_warning_timer !== null) {
+            clearTimeout(slow_warning_timer)
+          }
+          if (effective_slow_timeout_ms != null && Date.now() - call_started_at >= effective_slow_timeout_ms) {
+            emitSlowWarningIfDue(warning_args, call_started_at)
+          }
+        }
 
-            // Last attempt: rethrow
-            if (attempt >= effective_max_attempts) throw error
+        try {
+          for (let attempt = 1; attempt <= effective_max_attempts; attempt++) {
+            try {
+              if (timeout != null && timeout > 0) {
+                return await _runWithTimeout(() => Promise.resolve(target.apply(this, args)), timeout * 1000, attempt)
+              } else {
+                return await Promise.resolve(target.apply(this, args))
+              }
+            } catch (error) {
+              if (!shouldRetry(error)) throw error
+
+              // Last attempt: rethrow
+              if (attempt >= effective_max_attempts) throw error
 
-            // Wait before next attempt with exponential backoff
-            await asyncRetryDelay(attempt)
+              // Wait before next attempt with exponential backoff
+              await asyncRetryDelay(attempt)
+            }
           }
-        }
 
-        // Unreachable, but satisfies the type checker
-        throw new Error(`retry(${fn_name}): unexpected end of retry loop`)
+          // Unreachable, but satisfies the type checker
+          throw new Error(`retry(${fn_name}): unexpected end of retry loop`)
+        } finally {
+          finishSlowWarning()
+        }
       }
 
       try {
@@ -452,27 +488,52 @@ export function retry(options: RetryOptions = {}): RetryDecorator {
       }
 
       const runRetryLoop = (): any => {
-        for (let attempt = 1; attempt <= effective_max_attempts; attempt++) {
-          const attempt_started_at = Date.now()
-          try {
-            const result = target.apply(this, args)
-            if (isThenable(result)) {
-              return runRetryLoopFromThenable(this, args, result, attempt)
-            }
-            if (timeout != null && timeout > 0 && Date.now() - attempt_started_at > timeout * 1000) {
-              throw new RetryTimeoutError(`Timed out after ${timeout}s (attempt ${attempt})`, {
-                timeout_seconds: timeout,
-                attempt,
-              })
+        const call_started_at = Date.now()
+        const warning_args = [...args]
+        const slow_warning_timer =
+          effective_slow_timeout_ms == null
+            ? null
+            : setTimeout(() => emitSlowWarningIfDue(warning_args, call_started_at), effective_slow_timeout_ms)
+        const finishSlowWarning = (): void => {
+          if (slow_warning_timer !== null) {
+            clearTimeout(slow_warning_timer)
+          }
+          if (effective_slow_timeout_ms != null && Date.now() - call_started_at >= effective_slow_timeout_ms) {
+            emitSlowWarningIfDue(warning_args, call_started_at)
+          }
+        }
+
+        let finish_on_return = true
+        try {
+          for (let attempt = 1; attempt <= effective_max_attempts; attempt++) {
+            const attempt_started_at = Date.now()
+            try {
+              const result = target.apply(this, args)
+              if (isThenable(result)) {
+                finish_on_return = false
+                return runRetryLoopFromThenable(this, args, result, attempt).finally(finishSlowWarning)
+              }
+              if (timeout != null && timeout > 0 && Date.now() - attempt_started_at > timeout * 1000) {
+                throw new RetryTimeoutError(`Timed out after ${timeout}s (attempt ${attempt})`, {
+                  timeout_seconds: timeout,
+                  attempt,
+                })
+              }
+              return result
+            } catch (error) {
+              if (!shouldRetry(error)) throw error
+              if (attempt >= effective_max_attempts) {
+                throw error
+              }
+              syncRetryDelay(attempt)
             }
-            return result
-          } catch (error) {
-            if (!shouldRetry(error)) throw error
-            if (attempt >= effective_max_attempts) throw error
-            syncRetryDelay(attempt)
+          }
+          throw new Error(`retry(${fn_name}): unexpected end of retry loop`)
+        } finally {
+          if (finish_on_return) {
+            finishSlowWarning()
           }
         }
-        throw new Error(`retry(${fn_name}): unexpected end of retry loop`)
       }
 
       try {
@@ -494,7 +555,8 @@ export function retry(options: RetryOptions = {}): RetryDecorator {
       _context.addInitializer(function (this: unknown) {
         const owner_name = findDecoratedMethodOwnerName(this, _context, retryWrapper)
         if (owner_name) {
-          Object.defineProperty(retryWrapper, 'name', { value: `${owner_name}.${fn_name}`, configurable: true })
+          fn_name = `${owner_name}.${target.name || (_context.name as string) || 'anonymous'}`
+          Object.defineProperty(retryWrapper, 'name', { value: fn_name, configurable: true })
         }
       })
     }
@@ -507,7 +569,13 @@ export function retry(options: RetryOptions = {}): RetryDecorator {
     descriptor?: LegacyMethodDescriptor
   ): T | LegacyMethodDescriptor {
     if (descriptor?.value && typeof descriptor.value === 'function') {
-      descriptor.value = decorateFunction(descriptor.value)
+      const owner_name =
+        target && (typeof target === 'object' || typeof target === 'function')
+          ? typeof target === 'function'
+            ? target.name
+            : (target as { constructor?: { name?: string } }).constructor?.name
+          : null
+      descriptor.value = decorateFunction(descriptor.value, undefined, owner_name)
       return descriptor
     }
     if (typeof target === 'function') {
@@ -569,6 +637,32 @@ function isThenable(value: unknown): value is PromiseLike<unknown> {
   )
 }
 
+function formatRetrySlowWarningArgs(args: any[]): string {
+  const preview = args.map(formatRetrySlowWarningValue).join(', ')
+  if (preview.length > RETRY_SLOW_WARNING_ARGS_MAX_LENGTH) {
+    return `${preview.slice(0, RETRY_SLOW_WARNING_ARGS_MAX_LENGTH - 3).replace(/,?\s*$/, '')}...`
+  }
+  return preview
+}
+
+function formatRetrySlowWarningValue(value: unknown): string {
+  let text: string
+  if (typeof value === 'string') {
+    text = value
+  } else if (value === null || value === undefined) {
+    text = String(value)
+  } else if (typeof value === 'object') {
+    try {
+      text = JSON.stringify(value)
+    } catch {
+      text = String(value)
+    }
+  } else {
+    text = String(value)
+  }
+  return text.replace(/['"]/g, '').slice(0, 3)
+}
+
 /**
  * Try to acquire a semaphore within a timeout. Returns true if acquired, false if timed out.
  * If the semaphore is acquired after the timeout (due to the waiter remaining queued),

package/src/types.ts

@@ -1,12 +1,11 @@
 import { z } from 'zod'
-import type { BaseEvent } from './BaseEvent.js'
+import type { BaseEvent, EventClass as BaseEventClass } from './BaseEvent.js'
 import { fromJsonSchema, isJsonSchema, type JsonSchema } from './jsonschema.js'
 
 export type EventStatus = 'pending' | 'started' | 'completed'
+export type { EventClass } from './BaseEvent.js'
 
-export type EventClass<T extends BaseEvent = BaseEvent> = { event_type?: string } & (new (...args: any[]) => T)
-
-export type EventPattern<T extends BaseEvent = BaseEvent> = string | EventClass<T>
+export type EventPattern<T extends BaseEvent = BaseEvent> = string | BaseEventClass<T>
 
 export type EventWithResultSchema<TResult> = BaseEvent & { __event_result_type__?: TResult }
 
@@ -75,7 +74,7 @@ export const normalizeEventPattern = (event_pattern: EventPattern | '*'): string
   } catch {
     preview = String(event_pattern).slice(0, 30)
   }
-  throw new Error('bus.on(match_pattern, ...) must be a string event type, "*", or a BaseEvent class, got: ' + preview)
+  throw new Error('bus.on(match_pattern, ...) must be a string event type, "*", or a BaseEvent.extend() event class, got: ' + preview)
 }
 
 export const isZodSchema = (value: unknown): value is z.ZodTypeAny => !!value && typeof (value as z.ZodTypeAny).safeParse === 'function'

package/dist/cjs/bridge_ipc.d.ts

@@ -1,45 +0,0 @@
-import { BaseEvent } from './base_event.js';
-import { EventBus } from './event_bus.js';
-import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
-type EndpointScheme = 'unix' | 'http' | 'https';
-type ParsedEndpoint = {
-    raw: string;
-    scheme: EndpointScheme;
-    host?: string;
-    port?: number;
-    path?: string;
-};
-export type HTTPEventBridgeOptions = {
-    send_to?: string | null;
-    listen_on?: string | null;
-    name?: string;
-};
-export declare class EventBridge {
-    readonly send_to: ParsedEndpoint | null;
-    readonly listen_on: ParsedEndpoint | null;
-    readonly name: string;
-    protected readonly inbound_bus: EventBus;
-    private start_promise;
-    private node_server;
-    constructor(send_to?: string | null, listen_on?: string | null, name?: string);
-    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
-    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
-    emit<T extends BaseEvent>(event: T): Promise<void>;
-    dispatch<T extends BaseEvent>(event: T): Promise<void>;
-    start(): Promise<void>;
-    close(): Promise<void>;
-    private ensureListenerStarted;
-    private handleIncomingPayload;
-    private sendHttp;
-    private sendUnix;
-    private startHttpListener;
-    private startUnixListener;
-}
-export declare class HTTPEventBridge extends EventBridge {
-    constructor(send_to?: string | null, listen_on?: string | null, name?: string);
-    constructor(options?: HTTPEventBridgeOptions);
-}
-export declare class SocketEventBridge extends EventBridge {
-    constructor(path?: string | null, name?: string);
-}
-export {};

package/dist/cjs/middleware_otel_tracing.d.ts

@@ -1,49 +0,0 @@
-import { trace, type Span, type SpanAttributes, type SpanContext, type TimeInput, type Tracer } from '@opentelemetry/api';
-import type { BaseEvent } from './base_event.js';
-import type { EventBus } from './event_bus.js';
-import type { EventResult } from './event_result.js';
-import type { EventBusMiddleware } from './middlewares.js';
-import type { EventStatus } from './types.js';
-type OpenTelemetryTraceApi = Pick<typeof trace, 'getTracer' | 'setSpan'> & Partial<Pick<typeof trace, 'setSpanContext'>>;
-export type OtelTracingSpanFactoryInput = {
-    name: string;
-    span_context: SpanContext;
-    parent_span_context?: SpanContext;
-    attributes: SpanAttributes;
-    start_time?: TimeInput;
-};
-export type OtelTracingSpanFactory = (input: OtelTracingSpanFactoryInput) => Span;
-export type OtelTracingSpanProvider = object;
-export type OtelTracingMiddlewareOptions = {
-    tracer?: Tracer;
-    trace_api?: OpenTelemetryTraceApi;
-    span_provider?: OtelTracingSpanProvider;
-    span_factory?: OtelTracingSpanFactory;
-    otlp_endpoint?: string;
-    service_name?: string;
-    instrumentation_name?: string;
-    root_span_attributes?: SpanAttributes | ((eventbus: EventBus, event: BaseEvent) => SpanAttributes);
-};
-export declare class OtelTracingMiddleware implements EventBusMiddleware {
-    private readonly tracer;
-    private readonly trace_api;
-    private readonly span_factory?;
-    private readonly span_provider?;
-    private readonly root_span_attributes;
-    private readonly event_spans;
-    private readonly event_contexts;
-    private readonly handler_spans;
-    private readonly handler_contexts;
-    constructor(options?: OtelTracingMiddlewareOptions);
-    onEventChange(eventbus: EventBus, event: BaseEvent, status: EventStatus): void;
-    onEventResultChange(eventbus: EventBus, event: BaseEvent, event_result: EventResult, status: EventStatus): void;
-    private startEventSpan;
-    private completeEventSpan;
-    private startHandlerSpan;
-    private completeHandlerSpan;
-    private parentContextForEvent;
-    private completeEventSpanWithFactory;
-    private exportEventTreeWithFactory;
-    private exportHandlerSpanWithFactory;
-}
-export {};

package/dist/types/bridge_ipc.d.ts

@@ -1,45 +0,0 @@
-import { BaseEvent } from './base_event.js';
-import { EventBus } from './event_bus.js';
-import type { EventClass, EventHandlerCallable, UntypedEventHandlerFunction } from './types.js';
-type EndpointScheme = 'unix' | 'http' | 'https';
-type ParsedEndpoint = {
-    raw: string;
-    scheme: EndpointScheme;
-    host?: string;
-    port?: number;
-    path?: string;
-};
-export type HTTPEventBridgeOptions = {
-    send_to?: string | null;
-    listen_on?: string | null;
-    name?: string;
-};
-export declare class EventBridge {
-    readonly send_to: ParsedEndpoint | null;
-    readonly listen_on: ParsedEndpoint | null;
-    readonly name: string;
-    protected readonly inbound_bus: EventBus;
-    private start_promise;
-    private node_server;
-    constructor(send_to?: string | null, listen_on?: string | null, name?: string);
-    on<T extends BaseEvent>(event_pattern: EventClass<T>, handler: EventHandlerCallable<T>): void;
-    on<T extends BaseEvent>(event_pattern: string | '*', handler: UntypedEventHandlerFunction<T>): void;
-    emit<T extends BaseEvent>(event: T): Promise<void>;
-    dispatch<T extends BaseEvent>(event: T): Promise<void>;
-    start(): Promise<void>;
-    close(): Promise<void>;
-    private ensureListenerStarted;
-    private handleIncomingPayload;
-    private sendHttp;
-    private sendUnix;
-    private startHttpListener;
-    private startUnixListener;
-}
-export declare class HTTPEventBridge extends EventBridge {
-    constructor(send_to?: string | null, listen_on?: string | null, name?: string);
-    constructor(options?: HTTPEventBridgeOptions);
-}
-export declare class SocketEventBridge extends EventBridge {
-    constructor(path?: string | null, name?: string);
-}
-export {};

package/dist/types/middleware_otel_tracing.d.ts

@@ -1,49 +0,0 @@
-import { trace, type Span, type SpanAttributes, type SpanContext, type TimeInput, type Tracer } from '@opentelemetry/api';
-import type { BaseEvent } from './base_event.js';
-import type { EventBus } from './event_bus.js';
-import type { EventResult } from './event_result.js';
-import type { EventBusMiddleware } from './middlewares.js';
-import type { EventStatus } from './types.js';
-type OpenTelemetryTraceApi = Pick<typeof trace, 'getTracer' | 'setSpan'> & Partial<Pick<typeof trace, 'setSpanContext'>>;
-export type OtelTracingSpanFactoryInput = {
-    name: string;
-    span_context: SpanContext;
-    parent_span_context?: SpanContext;
-    attributes: SpanAttributes;
-    start_time?: TimeInput;
-};
-export type OtelTracingSpanFactory = (input: OtelTracingSpanFactoryInput) => Span;
-export type OtelTracingSpanProvider = object;
-export type OtelTracingMiddlewareOptions = {
-    tracer?: Tracer;
-    trace_api?: OpenTelemetryTraceApi;
-    span_provider?: OtelTracingSpanProvider;
-    span_factory?: OtelTracingSpanFactory;
-    otlp_endpoint?: string;
-    service_name?: string;
-    instrumentation_name?: string;
-    root_span_attributes?: SpanAttributes | ((eventbus: EventBus, event: BaseEvent) => SpanAttributes);
-};
-export declare class OtelTracingMiddleware implements EventBusMiddleware {
-    private readonly tracer;
-    private readonly trace_api;
-    private readonly span_factory?;
-    private readonly span_provider?;
-    private readonly root_span_attributes;
-    private readonly event_spans;
-    private readonly event_contexts;
-    private readonly handler_spans;
-    private readonly handler_contexts;
-    constructor(options?: OtelTracingMiddlewareOptions);
-    onEventChange(eventbus: EventBus, event: BaseEvent, status: EventStatus): void;
-    onEventResultChange(eventbus: EventBus, event: BaseEvent, event_result: EventResult, status: EventStatus): void;
-    private startEventSpan;
-    private completeEventSpan;
-    private startHandlerSpan;
-    private completeHandlerSpan;
-    private parentContextForEvent;
-    private completeEventSpanWithFactory;
-    private exportEventTreeWithFactory;
-    private exportHandlerSpanWithFactory;
-}
-export {};