abxbus 2.5.6 → 2.5.11

package/src/BaseEvent.ts

@@ -151,8 +151,7 @@ type EventPayloadShape<TShape extends z.ZodRawShape> = {
 }
 type EventPayload<TShape extends z.ZodRawShape> =
   EventPayloadShape<TShape> extends Record<string, never> ? {} : z.infer<z.ZodObject<EventPayloadShape<TShape>>>
-type EventFactoryMetadataFieldName =
-  | 'class'
+type EventClassMetadataFieldName =
   | 'fromJSON'
   | 'prototype'
   | 'event_schema'
@@ -165,7 +164,7 @@ type EventModelFields<TShape extends z.ZodRawShape> = {
   readonly [K in keyof TShape]: TShape[K]
 }
 type StaticEventDefaultValues<TShape extends z.ZodRawShape> = {
-  readonly [K in keyof TShape as K extends EventFactoryMetadataFieldName
+  readonly [K in keyof TShape as K extends EventClassMetadataFieldName
     ? never
     : TShape[K] extends StaticDefaultSchema
       ? K
@@ -243,7 +242,7 @@ type ShortcutZodModelFields<TShape> = {
   [K in keyof ShortcutModelFields<TShape>]: ShortcutModelFields<TShape>[K] extends z.ZodTypeAny ? ShortcutModelFields<TShape>[K] : never
 }
 type ShortcutStaticDefaultValues<TShape, TModelFields extends z.ZodRawShape> = StaticEventDefaultValues<TModelFields> & {
-  readonly [K in keyof TShape as K extends EventFactoryMetadataFieldName ? never : TShape[K] extends z.ZodTypeAny ? never : K]: TShape[K]
+  readonly [K in keyof TShape as K extends EventClassMetadataFieldName ? never : TShape[K] extends z.ZodTypeAny ? never : K]: TShape[K]
 }
 export type EventResultInclude<TEvent extends BaseEvent> = (
   result: EventResult<TEvent>['result'],
@@ -271,45 +270,22 @@ type EventResultUpdateOptions<TEvent extends BaseEvent> = {
 
 const ROOT_EVENTBUS_ID = '00000000-0000-0000-0000-000000000000'
 
-export type EventFactoryClass<TShape extends z.ZodRawShape, TResult = unknown> = (new (
-  ...args: OptionalFactoryArgs<EventInit<TShape>>
-) => EventWithResultSchema<TResult> & EventPayload<TShape>) &
-  StaticEventDefaultValues<TShape> & {
-    event_schema: EventSchema<TShape>
-    model_fields: EventModelFields<TShape>
-  }
-
-export type EventFactory<
-  TShape extends z.ZodRawShape,
-  TResult = unknown,
-  TStaticFields = StaticEventDefaultValues<TShape>,
+export type EventClass<
+  TEvent extends BaseEvent = BaseEvent,
+  TInit = never,
+  TSchema extends z.ZodTypeAny = AnyEventSchema,
+  TModelFields extends z.ZodRawShape = z.ZodRawShape,
+  TResultSchema extends z.ZodTypeAny | undefined = z.ZodTypeAny | undefined,
+  TStaticFields = {},
 > = TStaticFields & {
-  (...args: OptionalFactoryArgs<EventInit<TShape>>): EventWithResultSchema<TResult> & EventPayload<TShape>
-  new (...args: OptionalFactoryArgs<EventInit<TShape>>): EventWithResultSchema<TResult> & EventPayload<TShape>
-  event_schema: EventSchema<TShape>
-  model_fields: EventModelFields<TShape>
-  class: EventFactoryClass<TShape, TResult>
-  event_type: string
-  event_version: string
-  event_result_type: ResultTypeSchemaFromShape<TShape>
-  fromJSON: (data: unknown) => EventWithResultSchema<TResult> & EventPayload<TShape>
-}
-
-export type SchemaEventFactoryClass<TSchema extends AnyEventSchema, TResult = unknown> = (new (
-  ...args: OptionalFactoryArgs<EventInitFromSchema<TSchema>>
-) => EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>) &
-  StaticEventDefaultValuesFromSchema<TSchema> & { event_schema: TSchema; model_fields: EventModelFieldsFromSchema<TSchema> }
-
-export type SchemaEventFactory<TSchema extends AnyEventSchema, TResult = unknown> = StaticEventDefaultValuesFromSchema<TSchema> & {
-  (...args: OptionalFactoryArgs<EventInitFromSchema<TSchema>>): EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>
-  new (...args: OptionalFactoryArgs<EventInitFromSchema<TSchema>>): EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>
+  (...args: OptionalFactoryArgs<TInit>): TEvent
+  new (...args: OptionalFactoryArgs<TInit>): TEvent
   event_schema: TSchema
-  model_fields: EventModelFieldsFromSchema<TSchema>
-  class: SchemaEventFactoryClass<TSchema, TResult>
+  model_fields: TModelFields
   event_type: string
   event_version: string
-  event_result_type: ResultTypeSchemaFromEventSchema<TSchema>
-  fromJSON: (data: unknown) => EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>
+  event_result_type: TResultSchema
+  fromJSON: (data: unknown) => TEvent
 }
 
 type ZodShapeFrom<TShape extends Record<string, unknown>> = {
@@ -680,20 +656,56 @@ export class BaseEvent {
   static extend<TSchema extends z.ZodObject<z.ZodRawShape>>(
     event_type: string,
     event_schema: TSchema
-  ): SchemaEventFactory<TSchema, ResultSchemaFromEventSchema<TSchema>>
+  ): EventClass<
+    EventWithResultSchema<ResultSchemaFromEventSchema<TSchema>> & EventPayloadFromSchema<TSchema>,
+    EventInitFromSchema<TSchema>,
+    TSchema,
+    EventModelFieldsFromSchema<TSchema>,
+    ResultTypeSchemaFromEventSchema<TSchema>,
+    StaticEventDefaultValuesFromSchema<TSchema>
+  >
   static extend<const TShape extends Record<string, unknown>>(
     event_type: string,
     shape?: TShape
-  ): EventFactory<
-    ShortcutZodModelFields<TShape>,
-    ResultSchemaFromShape<ShortcutZodModelFields<TShape>>,
+  ): EventClass<
+    EventWithResultSchema<ResultSchemaFromShape<ShortcutZodModelFields<TShape>>> & EventPayload<ShortcutZodModelFields<TShape>>,
+    EventInit<ShortcutZodModelFields<TShape>>,
+    EventSchema<ShortcutZodModelFields<TShape>>,
+    EventModelFields<ShortcutZodModelFields<TShape>>,
+    ResultTypeSchemaFromShape<ShortcutZodModelFields<TShape>>,
     ShortcutStaticDefaultValues<TShape, ShortcutZodModelFields<TShape>>
   >
-  static extend<TShape extends z.ZodRawShape>(event_type: string, shape?: TShape): EventFactory<TShape, ResultSchemaFromShape<TShape>>
+  static extend<TShape extends z.ZodRawShape>(
+    event_type: string,
+    shape?: TShape
+  ): EventClass<
+    EventWithResultSchema<ResultSchemaFromShape<TShape>> & EventPayload<TShape>,
+    EventInit<TShape>,
+    EventSchema<TShape>,
+    EventModelFields<TShape>,
+    ResultTypeSchemaFromShape<TShape>,
+    StaticEventDefaultValues<TShape>
+  >
   static extend<const TShape extends Record<string, unknown>>(
     event_type: string,
     shape?: TShape
-  ): EventFactory<ZodShapeFrom<TShape>, ResultSchemaFromShape<TShape>> | SchemaEventFactory<AnyEventSchema, unknown> {
+  ):
+    | EventClass<
+        EventWithResultSchema<ResultSchemaFromShape<ZodShapeFrom<TShape>>> & EventPayload<ZodShapeFrom<TShape>>,
+        EventInit<ZodShapeFrom<TShape>>,
+        EventSchema<ZodShapeFrom<TShape>>,
+        EventModelFields<ZodShapeFrom<TShape>>,
+        ResultTypeSchemaFromShape<ZodShapeFrom<TShape>>,
+        StaticEventDefaultValues<ZodShapeFrom<TShape>>
+      >
+    | EventClass<
+        EventWithResultSchema<ResultSchemaFromEventSchema<AnyEventSchema>> & EventPayloadFromSchema<AnyEventSchema>,
+        EventInitFromSchema<AnyEventSchema>,
+        AnyEventSchema,
+        EventModelFieldsFromSchema<AnyEventSchema>,
+        ResultTypeSchemaFromEventSchema<AnyEventSchema>,
+        StaticEventDefaultValuesFromSchema<AnyEventSchema>
+      > {
     const built = buildFullEventSchema(event_type, shape ?? {})
     const full_schema = built.event_schema
     const event_parse_schema = built.event_parse_schema
@@ -701,41 +713,47 @@ export class BaseEvent {
     const event_result_type = built.event_result_type
     const event_version = built.event_version
 
-    // create a new event class that extends BaseEvent and adds the custom fields
-    class ExtendedEvent extends BaseEvent {
-      static event_schema = full_schema
-      static model_fields = full_schema.shape
-      static _event_parse_schema = event_parse_schema
-      static event_type = event_type
-      static event_version = event_version ?? BaseEvent.event_version
-      static event_result_type = event_result_type
-
-      constructor(data?: EventInit<ZodShapeFrom<TShape>> | EventInitFromSchema<AnyEventSchema>) {
-        super(data as BaseEventInit<Record<string, unknown>>)
+    const EventClass = class extends BaseEvent {
+      static override event_schema = full_schema as EventSchema<ZodShapeFrom<TShape>>
+      static override model_fields = full_schema.shape as EventModelFields<ZodShapeFrom<TShape>>
+      static override _event_parse_schema = event_parse_schema
+      static override event_type = event_type
+      static override event_version = event_version ?? BaseEvent.event_version
+      static override event_result_type = event_result_type
+
+      constructor(data?: EventInit<ZodShapeFrom<TShape>>) {
+        super(data)
       }
     }
 
-    type FactoryResult = EventWithResultSchema<ResultSchemaFromShape<TShape>> & EventPayload<ZodShapeFrom<TShape>>
-
-    function EventFactory(data?: EventInit<ZodShapeFrom<TShape>>): FactoryResult {
-      return new ExtendedEvent(data) as FactoryResult
-    }
+    Object.defineProperty(EventClass, 'name', { value: event_type, configurable: true })
+    defineStaticEventFields(EventClass, static_field_defaults)
 
-    EventFactory.event_schema = full_schema as EventSchema<ZodShapeFrom<TShape>>
-    EventFactory.model_fields = EventFactory.event_schema.shape as EventModelFields<ZodShapeFrom<TShape>>
-    EventFactory.event_type = event_type
-    EventFactory.event_version = event_version ?? BaseEvent.event_version
-    EventFactory.event_result_type = event_result_type
-    EventFactory.class = ExtendedEvent as unknown as new (
-      data: EventInit<ZodShapeFrom<TShape>>
-    ) => EventWithResultSchema<ResultSchemaFromShape<TShape>> & EventPayload<ZodShapeFrom<TShape>>
-    EventFactory.fromJSON = (data: unknown) => ExtendedEvent.fromJSON(data) as FactoryResult
-    EventFactory.prototype = ExtendedEvent.prototype
-    defineStaticEventFields(ExtendedEvent, static_field_defaults)
-    defineStaticEventFields(EventFactory, static_field_defaults)
-    EVENT_TYPE_REGISTRY.set(event_type, ExtendedEvent)
+    let CallableEventClass: typeof EventClass
+    CallableEventClass = new Proxy(EventClass, {
+      apply(target, _this_arg, args) {
+        return Reflect.construct(target, args, target)
+      },
+      construct(target, args, new_target) {
+        return Reflect.construct(target, args, new_target === CallableEventClass ? target : new_target)
+      },
+    })
 
-    return EventFactory as unknown as EventFactory<ZodShapeFrom<TShape>, ResultSchemaFromShape<TShape>>
+    Object.defineProperty(EventClass.prototype, 'constructor', {
+      value: CallableEventClass,
+      writable: true,
+      configurable: true,
+    })
+    EVENT_TYPE_REGISTRY.set(event_type, CallableEventClass as unknown as typeof BaseEvent)
+
+    return CallableEventClass as unknown as EventClass<
+      EventWithResultSchema<ResultSchemaFromShape<ZodShapeFrom<TShape>>> & EventPayload<ZodShapeFrom<TShape>>,
+      EventInit<ZodShapeFrom<TShape>>,
+      EventSchema<ZodShapeFrom<TShape>>,
+      EventModelFields<ZodShapeFrom<TShape>>,
+      ResultTypeSchemaFromShape<ZodShapeFrom<TShape>>,
+      StaticEventDefaultValues<ZodShapeFrom<TShape>>
+    >
   }
 
   static fromJSON<T extends typeof BaseEvent>(this: T, data: unknown): InstanceType<T> {

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

@@ -19,8 +19,9 @@ type RetryDecorator = {
   (target: object, property_key: string | symbol, descriptor: LegacyMethodDescriptor): LegacyMethodDescriptor
 }
 
-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 +45,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 +242,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 +250,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 +283,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 +389,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 +487,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 +554,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 +568,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 +636,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),
@@ -667,6 +760,18 @@ async function importNodeModule(specifier: string): Promise<any> {
   return dynamic_import(specifier) as Promise<any>
 }
 
+function resolveMultiprocessSemaphoreDirectory(path: any, os: any): string {
+  const configured = process.env.ABXBUS_MULTIPROCESS_SEMAPHORE_DIR
+  if (configured) return path.resolve(configured.replace(/^~(?=$|[/\\])/, os.homedir()))
+
+  const runtime_dir = process.env.XDG_RUNTIME_DIR
+  if (runtime_dir) return path.join(path.resolve(runtime_dir.replace(/^~(?=$|[/\\])/, os.homedir())), 'abxbus', 'semaphores')
+
+  const cache_home = process.env.XDG_CACHE_HOME
+  const cache_dir = cache_home ? path.resolve(cache_home.replace(/^~(?=$|[/\\])/, os.homedir())) : path.join(os.homedir(), '.cache')
+  return path.join(cache_dir, 'abxbus', 'semaphores')
+}
+
 async function acquireMultiprocessSemaphore(
   scoped_key: string,
   semaphore_limit: number,
@@ -679,7 +784,7 @@ async function acquireMultiprocessSemaphore(
     importNodeModule('node:os'),
     importNodeModule('node:path'),
   ])
-  const semaphore_directory = path.join(os.tmpdir(), MULTIPROCESS_SEMAPHORE_DIRNAME)
+  const semaphore_directory = resolveMultiprocessSemaphoreDirectory(path, os)
   const lock_prefix = crypto.createHash('sha256').update(scoped_key).digest('hex').slice(0, 40)
   fs.mkdirSync(semaphore_directory, { recursive: true })
 
@@ -777,7 +882,7 @@ function acquireMultiprocessSemaphoreSync(
   const fs = importNodeModuleSync('node:fs')
   const os = importNodeModuleSync('node:os')
   const path = importNodeModuleSync('node:path')
-  const semaphore_directory = path.join(os.tmpdir(), MULTIPROCESS_SEMAPHORE_DIRNAME)
+  const semaphore_directory = resolveMultiprocessSemaphoreDirectory(path, os)
   const lock_prefix = crypto.createHash('sha256').update(scoped_key).digest('hex').slice(0, 40)
   fs.mkdirSync(semaphore_directory, { recursive: true })
 

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'