abxbus 2.5.4 → 2.5.9

package/src/BaseEvent.ts

@@ -13,7 +13,8 @@ import {
   withResolvers,
 } from './LockManager.js'
 import { _runWithTimeout } from './timing.js'
-import { isZodSchema, normalizeEventResultType, toJsonSchema } from './types.js'
+import { toJsonSchema, type JsonSchema } from './jsonschema.js'
+import { isZodSchema, normalizeEventResultType } from './types.js'
 import type { EventHandlerCallable, EventResultType } from './types.js'
 import { monotonicDatetime } from './helpers.js'
 
@@ -103,7 +104,17 @@ export const BaseEventSchema = z
   .loose()
 
 const KNOWN_BASE_EVENT_FIELDS = new Set(Object.keys(BaseEventSchema.shape))
-type AnyEventSchema = z.ZodTypeAny
+const EVENT_FACTORY_METADATA_FIELDS = new Set([
+  'class',
+  'fromJSON',
+  'prototype',
+  'event_schema',
+  'model_fields',
+  'event_type',
+  'event_version',
+  'event_result_type',
+])
+type AnyEventSchema = z.ZodObject<z.ZodRawShape>
 
 export type BaseEventData = z.infer<typeof BaseEventSchema>
 export type BaseEventJSON = BaseEventData & Record<string, unknown>
@@ -135,33 +146,104 @@ export type BaseEventInit<TFields extends Record<string, unknown>> = TFields & P
 
 type BaseEventSchemaShape = typeof BaseEventSchema.shape
 export type EventSchema<TShape extends z.ZodRawShape> = z.ZodObject<BaseEventSchemaShape & TShape>
-type EventPayload<TShape extends z.ZodRawShape> = TShape extends Record<string, never> ? {} : z.infer<z.ZodObject<TShape>>
+type EventPayloadShape<TShape extends z.ZodRawShape> = {
+  [K in keyof TShape as K extends BaseEventFieldName ? never : K]: TShape[K]
+}
+type EventPayload<TShape extends z.ZodRawShape> =
+  EventPayloadShape<TShape> extends Record<string, never> ? {} : z.infer<z.ZodObject<EventPayloadShape<TShape>>>
+type EventClassMetadataFieldName =
+  | 'fromJSON'
+  | 'prototype'
+  | 'event_schema'
+  | 'model_fields'
+  | 'event_type'
+  | 'event_version'
+  | 'event_result_type'
+type StaticDefaultSchema = z.ZodDefault<z.ZodTypeAny> | z.ZodPrefault<z.ZodTypeAny> | z.ZodCatch<z.ZodTypeAny>
+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 EventClassMetadataFieldName
+    ? never
+    : TShape[K] extends StaticDefaultSchema
+      ? K
+      : never]: z.output<TShape[K]>
+}
+type StaticEventDefaultValuesFromSchema<TSchema extends AnyEventSchema> =
+  TSchema extends z.ZodObject<infer TShape> ? StaticEventDefaultValues<TShape> : {}
+type EventModelFieldsFromSchema<TSchema extends AnyEventSchema> =
+  TSchema extends z.ZodObject<infer TShape> ? TSchema['shape'] & EventModelFields<TShape> : {}
+type OptionalFactoryArgs<TData> = {} extends TData ? [data?: TData] : [data: TData]
 
 type EventInput<TShape extends z.ZodRawShape> = z.input<EventSchema<TShape>>
 export type EventInit<TShape extends z.ZodRawShape> = Omit<EventInput<TShape>, keyof BaseEventFields> & Partial<BaseEventFields>
-type EventPayloadFromSchema<TSchema extends AnyEventSchema> = z.output<TSchema> extends Record<string, unknown> ? z.output<TSchema> : {}
+type EventPayloadFromSchema<TSchema extends AnyEventSchema> =
+  z.output<TSchema> extends Record<string, unknown> ? Omit<z.output<TSchema>, keyof BaseEventFields> : {}
 type EventInputFromSchema<TSchema extends AnyEventSchema> = z.input<TSchema> extends Record<string, unknown> ? z.input<TSchema> : never
 export type EventInitFromSchema<TSchema extends AnyEventSchema> = Omit<EventInputFromSchema<TSchema>, keyof BaseEventFields> &
   Partial<BaseEventFields>
 
 type EventWithResultSchema<TResult> = BaseEvent & { __event_result_type__?: TResult }
+type NormalizedEventResultSchema<TInput> = TInput extends z.ZodTypeAny
+  ? TInput
+  : TInput extends z.core.$ZodType
+    ? z.ZodType<z.output<TInput>>
+    : TInput extends StringConstructor
+      ? z.ZodString
+      : TInput extends NumberConstructor
+        ? z.ZodNumber
+        : TInput extends BooleanConstructor
+          ? z.ZodBoolean
+          : TInput extends ArrayConstructor
+            ? z.ZodArray<z.ZodUnknown>
+            : TInput extends ObjectConstructor
+              ? z.ZodRecord<z.ZodString, z.ZodUnknown>
+              : TInput extends JsonSchema
+                ? z.ZodTypeAny
+                : z.ZodTypeAny
+type ResultTypeSchemaFromShape<TShape> = TShape extends { event_result_type: infer S }
+  ? NormalizedEventResultSchema<S>
+  : z.ZodTypeAny | undefined
+type ResultTypeSchemaFromEventSchema<TSchema> =
+  TSchema extends z.ZodObject<infer TShape> ? ResultTypeSchemaFromShape<TShape> : z.ZodTypeAny | undefined
 
 type ResultTypeFromEventResultTypeInput<TInput> = TInput extends z.ZodTypeAny
   ? z.infer<TInput>
-  : TInput extends StringConstructor
-    ? string
-    : TInput extends NumberConstructor
-      ? number
-      : TInput extends BooleanConstructor
-        ? boolean
-        : TInput extends ArrayConstructor
-          ? unknown[]
-          : TInput extends ObjectConstructor
-            ? Record<string, unknown>
-            : unknown
+  : TInput extends z.core.$ZodType
+    ? z.output<TInput>
+    : TInput extends StringConstructor
+      ? string
+      : TInput extends NumberConstructor
+        ? number
+        : TInput extends BooleanConstructor
+          ? boolean
+          : TInput extends ArrayConstructor
+            ? unknown[]
+            : TInput extends ObjectConstructor
+              ? Record<string, unknown>
+              : TInput extends JsonSchema
+                ? unknown
+                : unknown
 
 type ResultSchemaFromShape<TShape> = TShape extends { event_result_type: infer S } ? ResultTypeFromEventResultTypeInput<S> : unknown
 type ResultSchemaFromEventSchema<TSchema> = TSchema extends z.ZodObject<infer TShape> ? ResultSchemaFromShape<TShape> : unknown
+type ZodLiteralValue = string | number | bigint | boolean | null | undefined
+type SeenShortcutLiteralPairs = WeakMap<object, WeakSet<object>>
+type ShortcutDefaultModelField<K, TValue> = K extends keyof BaseEventSchemaShape
+  ? z.ZodDefault<BaseEventSchemaShape[K]>
+  : z.ZodDefault<TValue extends ZodLiteralValue ? z.ZodLiteral<TValue> : z.ZodType<TValue>>
+type ShortcutModelFields<TShape> = {
+  [K in keyof TShape as K extends 'event_result_type' ? never : K]: TShape[K] extends z.ZodTypeAny
+    ? TShape[K]
+    : ShortcutDefaultModelField<K, TShape[K]>
+} & (TShape extends { event_result_type: infer TResultType } ? { event_result_type: NormalizedEventResultSchema<TResultType> } : {})
+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 EventClassMetadataFieldName ? never : TShape[K] extends z.ZodTypeAny ? never : K]: TShape[K]
+}
 export type EventResultInclude<TEvent extends BaseEvent> = (
   result: EventResult<TEvent>['result'],
   event_result: EventResult<TEvent>
@@ -188,26 +270,22 @@ type EventResultUpdateOptions<TEvent extends BaseEvent> = {
 
 const ROOT_EVENTBUS_ID = '00000000-0000-0000-0000-000000000000'
 
-export type EventFactory<TShape extends z.ZodRawShape, TResult = unknown> = {
-  (data: EventInit<TShape>): EventWithResultSchema<TResult> & EventPayload<TShape>
-  new (data: EventInit<TShape>): EventWithResultSchema<TResult> & EventPayload<TShape>
-  event_schema: EventSchema<TShape>
-  class?: new (data: EventInit<TShape>) => EventWithResultSchema<TResult> & EventPayload<TShape>
-  event_type?: string
-  event_version?: string
-  event_result_type?: z.ZodTypeAny
-  fromJSON?: (data: unknown) => EventWithResultSchema<TResult> & EventPayload<TShape>
-}
-
-export type SchemaEventFactory<TSchema extends AnyEventSchema, TResult = unknown> = {
-  (data: EventInitFromSchema<TSchema>): EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>
-  new (data: EventInitFromSchema<TSchema>): EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>
+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<TInit>): TEvent
+  new (...args: OptionalFactoryArgs<TInit>): TEvent
   event_schema: TSchema
-  class?: new (data: EventInitFromSchema<TSchema>) => EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>
-  event_type?: string
-  event_version?: string
-  event_result_type?: z.ZodTypeAny
-  fromJSON?: (data: unknown) => EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>
+  model_fields: TModelFields
+  event_type: string
+  event_version: string
+  event_result_type: TResultSchema
+  fromJSON: (data: unknown) => TEvent
 }
 
 type ZodShapeFrom<TShape extends Record<string, unknown>> = {
@@ -247,15 +325,72 @@ function missingBaseFields(event_type: string, user_shape: z.ZodRawShape): z.Zod
   return Object.fromEntries(Object.entries(baseEventDefaultShape(event_type)).filter(([key]) => !(key in user_shape))) as z.ZodRawShape
 }
 
-type ZodSchemaWithPrefault = z.ZodTypeAny & {
-  prefault: (value: unknown) => z.ZodTypeAny
+function isZodLiteralValue(value: unknown): value is ZodLiteralValue {
+  return value === null || value === undefined || ['string', 'number', 'bigint', 'boolean'].includes(typeof value)
+}
+
+function isPlainShortcutLiteralObject(value: unknown): value is Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return false
+  }
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}
+
+function alreadyComparedShortcutLiteralPair(left: object, right: object, seen: SeenShortcutLiteralPairs): boolean {
+  let right_values = seen.get(left)
+  if (right_values?.has(right)) {
+    return true
+  }
+  if (!right_values) {
+    right_values = new WeakSet<object>()
+    seen.set(left, right_values)
+  }
+  right_values.add(right)
+  return false
+}
+
+function shortcutLiteralValuesEqual(left: unknown, right: unknown, seen: SeenShortcutLiteralPairs = new WeakMap()): boolean {
+  if (Object.is(left, right)) {
+    return true
+  }
+  if (typeof left !== 'object' || left === null || typeof right !== 'object' || right === null) {
+    return false
+  }
+  if (alreadyComparedShortcutLiteralPair(left, right, seen)) {
+    return true
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+      return false
+    }
+    return left.every((item, index) => shortcutLiteralValuesEqual(item, right[index], seen))
+  }
+  if (!isPlainShortcutLiteralObject(left) || !isPlainShortcutLiteralObject(right)) {
+    return false
+  }
+  const left_keys = Object.keys(left)
+  const right_keys = Object.keys(right)
+  if (left_keys.length !== right_keys.length) {
+    return false
+  }
+  return left_keys.every((key) =>
+    Object.prototype.hasOwnProperty.call(right, key) ? shortcutLiteralValuesEqual(left[key], right[key], seen) : false
+  )
+}
+
+function shortcutLiteralSchema<TValue>(value: TValue): z.ZodType<TValue> {
+  if (isZodLiteralValue(value)) {
+    return z.literal(value) as z.ZodType<TValue>
+  }
+  return z.custom<TValue>((candidate) => shortcutLiteralValuesEqual(candidate, value), 'Invalid literal value')
 }
 
 function shortcutDefaultSchema(base_field_schema: z.ZodTypeAny | undefined, value: unknown): z.ZodTypeAny {
   if (!base_field_schema) {
-    return z.unknown().optional().default(value)
+    return shortcutLiteralSchema(value).default(value)
   }
-  return (base_field_schema as ZodSchemaWithPrefault).prefault(base_field_schema.parse(value))
+  return base_field_schema.default(base_field_schema.parse(value))
 }
 
 function schemaDefaultsForShortcut(event_type: string, raw_shape: Record<string, unknown>): z.ZodRawShape {
@@ -281,16 +416,54 @@ function zodFieldsForShortcut(raw_shape: Record<string, unknown>): z.ZodRawShape
   return fields
 }
 
+function modelFieldsForShortcut(raw_shape: Record<string, unknown>, shortcut_shape: z.ZodRawShape): z.ZodRawShape {
+  const event_result_type = normalizeEventResultType(raw_shape.event_result_type)
+  return event_result_type ? { ...shortcut_shape, event_result_type } : shortcut_shape
+}
+
+function staticEventDefaultsFromModelFields(model_fields: z.ZodRawShape): Record<string, unknown> {
+  const fields: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(model_fields)) {
+    if (EVENT_FACTORY_METADATA_FIELDS.has(key)) {
+      continue
+    }
+    const parsed = (value as z.ZodTypeAny).safeParse(undefined)
+    if (parsed.success && parsed.data !== undefined) {
+      fields[key] = parsed.data
+    }
+  }
+  return fields
+}
+
+function defineStaticEventFields(target: object, fields: Record<string, unknown>): void {
+  for (const [key, value] of Object.entries(fields)) {
+    Object.defineProperty(target, key, {
+      value,
+      writable: false,
+      enumerable: true,
+      configurable: true,
+    })
+  }
+}
+
 function eventResultTypeFromObjectSchema(schema: z.ZodObject<z.ZodRawShape>): z.ZodTypeAny | undefined {
   const raw_event_result_type = schema.shape.event_result_type
   return raw_event_result_type === undefined ? undefined : normalizeEventResultType(raw_event_result_type)
 }
 
+function eventParseSchemaFromEventSchema(schema: z.ZodObject<z.ZodRawShape>): z.ZodObject<z.ZodRawShape> {
+  return schema.safeExtend({
+    event_result_type: z.unknown().optional(),
+  })
+}
+
 function buildFullEventSchema(
   event_type: string,
   spec: unknown
 ): {
-  event_schema: AnyEventSchema
+  event_schema: z.ZodObject<z.ZodRawShape>
+  event_parse_schema: z.ZodObject<z.ZodRawShape>
+  static_field_defaults: Record<string, unknown>
   event_result_type?: z.ZodTypeAny
   event_version?: string
 } {
@@ -300,11 +473,12 @@ function buildFullEventSchema(
     assertNoUnknownEventPrefixedFields(user_shape, `BaseEvent.extend(${event_type})`)
     assertNoModelPrefixedFields(user_shape, `BaseEvent.extend(${event_type})`)
     const full_schema = spec.safeExtend({
-      event_result_type: z.unknown().optional(),
       ...missingBaseFields(event_type, user_shape),
     })
     return {
       event_schema: full_schema,
+      event_parse_schema: eventParseSchemaFromEventSchema(full_schema),
+      static_field_defaults: staticEventDefaultsFromModelFields(full_schema.shape),
       event_result_type: eventResultTypeFromObjectSchema(spec),
     }
   }
@@ -317,9 +491,12 @@ function buildFullEventSchema(
     ...schemaDefaultsForShortcut(event_type, raw_shape),
     ...zodFieldsForShortcut(raw_shape),
   }
-  const full_schema = z.object(shortcut_shape).safeExtend(missingBaseFields(event_type, shortcut_shape)).loose()
+  const model_fields = modelFieldsForShortcut(raw_shape, shortcut_shape)
+  const full_schema = z.object(model_fields).safeExtend(missingBaseFields(event_type, model_fields)).loose()
   return {
     event_schema: full_schema,
+    event_parse_schema: eventParseSchemaFromEventSchema(full_schema),
+    static_field_defaults: staticEventDefaultsFromModelFields(full_schema.shape),
     event_result_type: normalizeEventResultType(raw_shape.event_result_type),
     event_version: typeof raw_shape.event_version === 'string' ? raw_shape.event_version : undefined,
   }
@@ -365,11 +542,14 @@ export class BaseEvent {
   event_handler_concurrency?: EventHandlerConcurrencyMode | null // concurrency mode for the handlers within the event
   event_handler_completion?: EventHandlerCompletionMode | null // completion strategy: 'all' (default) waits for every handler, 'first' returns earliest non-undefined result and cancels the rest
   event_schema?: z.ZodTypeAny
+  _event_parse_schema?: z.ZodTypeAny
 
   static event_type?: string // class name of the event, e.g. BaseEvent.extend("MyEvent").event_type === "MyEvent"
   static event_version = '0.0.1'
   static event_result_type?: z.ZodTypeAny
   static event_schema: AnyEventSchema = BaseEventSchema // generated Zod schema for local TS event data validation; never sent over the wire
+  static model_fields: z.ZodRawShape = BaseEventSchema.shape
+  static _event_parse_schema: AnyEventSchema = BaseEventSchema
 
   // internal runtime state
   event_bus?: EventBus // bus that dispatched this event, also used by event.emit(child)
@@ -387,6 +567,7 @@ export class BaseEvent {
       event_version?: string
       event_result_type?: z.ZodTypeAny
       event_schema?: AnyEventSchema
+      _event_parse_schema?: AnyEventSchema
     }
     const explicit_event_fields = new Set(Object.keys(data ?? {}))
     const merged_data = { ...data } as BaseEventInit<Record<string, unknown>>
@@ -396,6 +577,7 @@ export class BaseEvent {
     const event_result_type = normalizeEventResultType(raw_event_result_type)
 
     const event_schema = ctor.event_schema ?? BaseEventSchema
+    const event_parse_schema = ctor._event_parse_schema ?? event_schema
     const base_data: Record<string, unknown> = {
       ...merged_data,
       event_id: merged_data.event_id ?? uuidv7(),
@@ -404,12 +586,12 @@ export class BaseEvent {
       event_version,
       event_result_type,
     }
-    if (event_schema === BaseEventSchema) {
+    if (event_parse_schema === BaseEventSchema) {
       base_data.event_timeout ??= null
       base_data.event_blocks_parent_completion ??= false
     }
 
-    const parsed = decodeEventSchema(event_schema, base_data) as BaseEventData & Record<string, unknown>
+    const parsed = decodeEventSchema(event_parse_schema, base_data) as BaseEventData & Record<string, unknown>
 
     Object.assign(this, parsed)
     Object.defineProperty(this, 'event_schema', {
@@ -418,13 +600,18 @@ export class BaseEvent {
       enumerable: false,
       configurable: true,
     })
+    Object.defineProperty(this, '_event_parse_schema', {
+      value: event_parse_schema,
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    })
     Object.defineProperty(this, '_event_fields_set', {
       value: explicit_event_fields,
       writable: true,
       enumerable: false,
       configurable: true,
     })
-
     const parsed_path = (parsed as { event_path?: string[] }).event_path
     this.event_path = Array.isArray(parsed_path) ? [...parsed_path] : []
     this.event_created_at = monotonicDatetime(parsed.event_created_at)
@@ -469,57 +656,110 @@ export class BaseEvent {
   static extend<TSchema extends z.ZodObject<z.ZodRawShape>>(
     event_type: string,
     event_schema: TSchema
-  ): SchemaEventFactory<TSchema, ResultSchemaFromEventSchema<TSchema>>
-  static extend<TShape extends z.ZodRawShape>(event_type: string, shape?: TShape): EventFactory<TShape, ResultSchemaFromShape<TShape>>
-  static extend<TShape extends Record<string, unknown>>(
+  ): 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
+  ): 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<ZodShapeFrom<TShape>, ResultSchemaFromShape<TShape>>
-  static extend<TShape extends Record<string, unknown>>(
+  ): 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
+    const static_field_defaults = built.static_field_defaults
     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 event_type = event_type
-      static event_version = event_version ?? BaseEvent.event_version
-      static event_result_type = event_result_type
+    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>> | EventInitFromSchema<AnyEventSchema>) {
-        super(data as BaseEventInit<Record<string, unknown>>)
+      constructor(data?: EventInit<ZodShapeFrom<TShape>>) {
+        super(data)
       }
     }
 
-    type FactoryResult = EventWithResultSchema<ResultSchemaFromShape<TShape>> & EventPayload<ZodShapeFrom<TShape>>
+    Object.defineProperty(EventClass, 'name', { value: event_type, configurable: true })
+    defineStaticEventFields(EventClass, static_field_defaults)
 
-    function EventFactory(data: EventInit<ZodShapeFrom<TShape>>): FactoryResult {
-      return new ExtendedEvent(data) as FactoryResult
-    }
+    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)
+      },
+    })
 
-    EventFactory.event_schema = full_schema as EventSchema<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
-    EVENT_TYPE_REGISTRY.set(event_type, ExtendedEvent)
+    Object.defineProperty(EventClass.prototype, 'constructor', {
+      value: CallableEventClass,
+      writable: true,
+      configurable: true,
+    })
+    EVENT_TYPE_REGISTRY.set(event_type, CallableEventClass as unknown as typeof BaseEvent)
 
-    return EventFactory as unknown as EventFactory<ZodShapeFrom<TShape>, ResultSchemaFromShape<TShape>>
+    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> {
     if (!data || typeof data !== 'object') {
-      const event_schema = this.event_schema ?? BaseEventSchema
-      const parsed = decodeEventSchema(event_schema, data)
+      const event_parse_schema = this._event_parse_schema ?? this.event_schema ?? BaseEventSchema
+      const parsed = decodeEventSchema(event_parse_schema, data)
       return new this(parsed) as InstanceType<T>
     }
     const record = { ...(data as Record<string, unknown>) }
@@ -536,9 +776,6 @@ export class BaseEvent {
     if (this !== BaseEvent && ctor.event_result_type && record.event_result_type !== undefined) {
       delete record.event_result_type
     }
-    if (record.event_result_type !== undefined && record.event_result_type !== null) {
-      record.event_result_type = normalizeEventResultType(record.event_result_type)
-    }
     return new this(record as BaseEventInit<Record<string, unknown>>) as InstanceType<T>
   }
 
@@ -567,8 +804,12 @@ export class BaseEvent {
       Array.from(this.event_results.entries()).map(([handler_id, result]) => [handler_id, result.toJSON()])
     )
 
-    const event_schema = ((this.constructor as typeof BaseEvent).event_schema ?? this.event_schema ?? BaseEventSchema) as AnyEventSchema
-    const encoded = encodeEventSchema(event_schema, {
+    const event_parse_schema = ((this.constructor as typeof BaseEvent)._event_parse_schema ??
+      this._event_parse_schema ??
+      (this.constructor as typeof BaseEvent).event_schema ??
+      this.event_schema ??
+      BaseEventSchema) as AnyEventSchema
+    const encoded = encodeEventSchema(event_parse_schema, {
       ...record,
       event_id: this.event_id,
       event_type: this.event_type,

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,32 +3,27 @@ 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> extends [infer TInit, ...unknown[]] ? TInit : never
+type EventInit<TEventClass extends EventClass<BaseEvent>> = [ConstructorParameters<TEventClass>[0]] extends [undefined]
+  ? {}
+  : NonNullable<ConstructorParameters<TEventClass>[0]>
 
 type EventMethodArgs<TEventClass extends EventClass<BaseEvent>> =
   {} extends EventInit<TEventClass>
@@ -50,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>
 }
@@ -75,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,