abxbus 2.5.3 → 2.5.6

package/dist/cjs/BaseEvent.d.ts

@@ -4,6 +4,7 @@ import { EventResult } from './EventResult.js';
 import { EventHandler } from './EventHandler.js';
 import type { EventConcurrencyMode, EventHandlerConcurrencyMode, EventHandlerCompletionMode, Deferred } from './LockManager.js';
 import { AsyncLock } from './LockManager.js';
+import { type JsonSchema } from './jsonschema.js';
 import type { EventHandlerCallable, EventResultType } from './types.js';
 export declare const BaseEventSchema: z.ZodObject<{
     event_id: z.ZodString;
@@ -42,7 +43,7 @@ export declare const BaseEventSchema: z.ZodObject<{
         first: "first";
     }>>>;
 }, z.core.$loose>;
-type AnyEventSchema = z.ZodTypeAny;
+type AnyEventSchema = z.ZodObject<z.ZodRawShape>;
 export type BaseEventData = z.infer<typeof BaseEventSchema>;
 export type BaseEventJSON = BaseEventData & Record<string, unknown>;
 type BaseEventFieldName = 'event_id' | 'event_created_at' | 'event_type' | 'event_version' | 'event_timeout' | 'event_slow_timeout' | 'event_handler_timeout' | 'event_handler_slow_timeout' | 'event_blocks_parent_completion' | 'event_parent_id' | 'event_path' | 'event_result_type' | 'event_emitted_by_handler_id' | 'event_pending_bus_count' | 'event_status' | 'event_started_at' | 'event_completed_at' | 'event_results' | 'event_concurrency' | 'event_handler_concurrency' | 'event_handler_completion';
@@ -52,20 +53,54 @@ type BaseEventFields = {
 export type BaseEventInit<TFields extends Record<string, unknown>> = TFields & Partial<BaseEventFields>;
 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 EventFactoryMetadataFieldName = 'class' | '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 EventFactoryMetadataFieldName ? 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 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;
+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 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 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 EventFactoryMetadataFieldName ? never : TShape[K] extends z.ZodTypeAny ? never : K]: TShape[K];
+};
 export type EventResultInclude<TEvent extends BaseEvent> = (result: EventResult<TEvent>['result'], event_result: EventResult<TEvent>) => boolean;
 export type EventResultOptions<TEvent extends BaseEvent> = {
     include?: EventResultInclude<TEvent>;
@@ -86,28 +121,35 @@ type EventResultUpdateOptions<TEvent extends BaseEvent> = {
     result?: EventResultType<TEvent> | BaseEvent | undefined;
     error?: unknown;
 };
-export type EventFactory<TShape extends z.ZodRawShape, TResult = unknown> = {
-    (data: EventInit<TShape>): EventWithResultSchema<TResult> & EventPayload<TShape>;
-    new (data: EventInit<TShape>): EventWithResultSchema<TResult> & EventPayload<TShape>;
+export type EventFactoryClass<TShape extends z.ZodRawShape, TResult = unknown> = (new (...args: OptionalFactoryArgs<EventInit<TShape>>) => EventWithResultSchema<TResult> & EventPayload<TShape>) & StaticEventDefaultValues<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>;
+    model_fields: EventModelFields<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 EventFactory<TShape extends z.ZodRawShape, TResult = unknown, TStaticFields = StaticEventDefaultValues<TShape>> = 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;
-    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: EventModelFieldsFromSchema<TSchema>;
 };
-type ZodShapeFrom<TShape extends Record<string, unknown>> = {
-    [K in keyof TShape as K extends 'event_result_type' ? never : TShape[K] extends z.ZodTypeAny ? K : never]: Extract<TShape[K], z.ZodTypeAny>;
+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>;
+    event_schema: TSchema;
+    model_fields: EventModelFieldsFromSchema<TSchema>;
+    class: SchemaEventFactoryClass<TSchema, TResult>;
+    event_type: string;
+    event_version: string;
+    event_result_type: ResultTypeSchemaFromEventSchema<TSchema>;
+    fromJSON: (data: unknown) => EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>;
 };
 export declare class BaseEvent {
     event_id: string;
@@ -132,10 +174,13 @@ export declare class BaseEvent {
     event_handler_concurrency?: EventHandlerConcurrencyMode | null;
     event_handler_completion?: EventHandlerCompletionMode | null;
     event_schema?: z.ZodTypeAny;
+    _event_parse_schema?: z.ZodTypeAny;
     static event_type?: string;
     static event_version: string;
     static event_result_type?: z.ZodTypeAny;
     static event_schema: AnyEventSchema;
+    static model_fields: z.ZodRawShape;
+    static _event_parse_schema: AnyEventSchema;
     event_bus?: EventBus;
     _event_original?: BaseEvent;
     _event_dispatch_context?: unknown | null;
@@ -145,8 +190,8 @@ export declare class BaseEvent {
     constructor(data?: BaseEventInit<Record<string, unknown>>);
     toString(): string;
     static extend<TSchema extends z.ZodObject<z.ZodRawShape>>(event_type: string, event_schema: TSchema): SchemaEventFactory<TSchema, ResultSchemaFromEventSchema<TSchema>>;
+    static extend<const TShape extends Record<string, unknown>>(event_type: string, shape?: TShape): EventFactory<ShortcutZodModelFields<TShape>, ResultSchemaFromShape<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 Record<string, unknown>>(event_type: string, shape?: TShape): EventFactory<ZodShapeFrom<TShape>, ResultSchemaFromShape<TShape>>;
     static fromJSON<T extends typeof BaseEvent>(this: T, data: unknown): InstanceType<T>;
     static toJSONArray(events: Iterable<BaseEvent>): BaseEventJSON[];
     static fromJSONArray(data: unknown): BaseEvent[];

package/dist/cjs/BaseEvent.js

@@ -28,6 +28,7 @@ var import_EventResult = require("./EventResult.js");
 var import_EventHandler = require("./EventHandler.js");
 var import_LockManager = require("./LockManager.js");
 var import_timing = require("./timing.js");
+var import_jsonschema = require("./jsonschema.js");
 var import_types = require("./types.js");
 var import_helpers = require("./helpers.js");
 const RESERVED_USER_EVENT_FIELDS = /* @__PURE__ */ new Set([
@@ -101,6 +102,16 @@ const BaseEventSchema = import_zod.z.object({
   event_handler_completion: import_zod.z.enum(import_LockManager.EVENT_HANDLER_COMPLETION_MODES).nullable().optional()
 }).loose();
 const KNOWN_BASE_EVENT_FIELDS = new Set(Object.keys(BaseEventSchema.shape));
+const EVENT_FACTORY_METADATA_FIELDS = /* @__PURE__ */ new Set([
+  "class",
+  "fromJSON",
+  "prototype",
+  "event_schema",
+  "model_fields",
+  "event_type",
+  "event_version",
+  "event_result_type"
+]);
 const ROOT_EVENTBUS_ID = "00000000-0000-0000-0000-000000000000";
 function baseEventDefaultShape(event_type) {
   return {
@@ -130,11 +141,67 @@ function baseEventDefaultShape(event_type) {
 function missingBaseFields(event_type, user_shape) {
   return Object.fromEntries(Object.entries(baseEventDefaultShape(event_type)).filter(([key]) => !(key in user_shape)));
 }
+function isZodLiteralValue(value) {
+  return value === null || value === void 0 || ["string", "number", "bigint", "boolean"].includes(typeof value);
+}
+function isPlainShortcutLiteralObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function alreadyComparedShortcutLiteralPair(left, right, seen) {
+  let right_values = seen.get(left);
+  if (right_values?.has(right)) {
+    return true;
+  }
+  if (!right_values) {
+    right_values = /* @__PURE__ */ new WeakSet();
+    seen.set(left, right_values);
+  }
+  right_values.add(right);
+  return false;
+}
+function shortcutLiteralValuesEqual(left, right, seen = /* @__PURE__ */ new WeakMap()) {
+  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(value) {
+  if (isZodLiteralValue(value)) {
+    return import_zod.z.literal(value);
+  }
+  return import_zod.z.custom((candidate) => shortcutLiteralValuesEqual(candidate, value), "Invalid literal value");
+}
 function shortcutDefaultSchema(base_field_schema, value) {
   if (!base_field_schema) {
-    return import_zod.z.unknown().optional().default(value);
+    return shortcutLiteralSchema(value).default(value);
   }
-  return base_field_schema.prefault(base_field_schema.parse(value));
+  return base_field_schema.default(base_field_schema.parse(value));
 }
 function schemaDefaultsForShortcut(event_type, raw_shape) {
   const defaults = {};
@@ -157,10 +224,42 @@ function zodFieldsForShortcut(raw_shape) {
   }
   return fields;
 }
+function modelFieldsForShortcut(raw_shape, shortcut_shape) {
+  const event_result_type = (0, import_types.normalizeEventResultType)(raw_shape.event_result_type);
+  return event_result_type ? { ...shortcut_shape, event_result_type } : shortcut_shape;
+}
+function staticEventDefaultsFromModelFields(model_fields) {
+  const fields = {};
+  for (const [key, value] of Object.entries(model_fields)) {
+    if (EVENT_FACTORY_METADATA_FIELDS.has(key)) {
+      continue;
+    }
+    const parsed = value.safeParse(void 0);
+    if (parsed.success && parsed.data !== void 0) {
+      fields[key] = parsed.data;
+    }
+  }
+  return fields;
+}
+function defineStaticEventFields(target, fields) {
+  for (const [key, value] of Object.entries(fields)) {
+    Object.defineProperty(target, key, {
+      value,
+      writable: false,
+      enumerable: true,
+      configurable: true
+    });
+  }
+}
 function eventResultTypeFromObjectSchema(schema) {
   const raw_event_result_type = schema.shape.event_result_type;
   return raw_event_result_type === void 0 ? void 0 : (0, import_types.normalizeEventResultType)(raw_event_result_type);
 }
+function eventParseSchemaFromEventSchema(schema) {
+  return schema.safeExtend({
+    event_result_type: import_zod.z.unknown().optional()
+  });
+}
 function buildFullEventSchema(event_type, spec) {
   if (isZodObjectSchema(spec)) {
     const user_shape = spec.shape;
@@ -168,11 +267,12 @@ function buildFullEventSchema(event_type, spec) {
     assertNoUnknownEventPrefixedFields(user_shape, `BaseEvent.extend(${event_type})`);
     assertNoModelPrefixedFields(user_shape, `BaseEvent.extend(${event_type})`);
     const full_schema2 = spec.safeExtend({
-      event_result_type: import_zod.z.unknown().optional(),
       ...missingBaseFields(event_type, user_shape)
     });
     return {
       event_schema: full_schema2,
+      event_parse_schema: eventParseSchemaFromEventSchema(full_schema2),
+      static_field_defaults: staticEventDefaultsFromModelFields(full_schema2.shape),
       event_result_type: eventResultTypeFromObjectSchema(spec)
     };
   }
@@ -184,9 +284,12 @@ function buildFullEventSchema(event_type, spec) {
     ...schemaDefaultsForShortcut(event_type, raw_shape),
     ...zodFieldsForShortcut(raw_shape)
   };
-  const full_schema = import_zod.z.object(shortcut_shape).safeExtend(missingBaseFields(event_type, shortcut_shape)).loose();
+  const model_fields = modelFieldsForShortcut(raw_shape, shortcut_shape);
+  const full_schema = import_zod.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: (0, import_types.normalizeEventResultType)(raw_shape.event_result_type),
     event_version: typeof raw_shape.event_version === "string" ? raw_shape.event_version : void 0
   };
@@ -247,12 +350,15 @@ class BaseEvent {
   event_handler_completion;
   // completion strategy: 'all' (default) waits for every handler, 'first' returns earliest non-undefined result and cancels the rest
   event_schema;
+  _event_parse_schema;
   static event_type;
   // class name of the event, e.g. BaseEvent.extend("MyEvent").event_type === "MyEvent"
   static event_version = "0.0.1";
   static event_result_type;
   static event_schema = BaseEventSchema;
   // generated Zod schema for local TS event data validation; never sent over the wire
+  static model_fields = BaseEventSchema.shape;
+  static _event_parse_schema = BaseEventSchema;
   // internal runtime state
   event_bus;
   // bus that dispatched this event, also used by event.emit(child)
@@ -275,6 +381,7 @@ class BaseEvent {
     const raw_event_result_type = merged_data.event_result_type ?? ctor.event_result_type;
     const event_result_type = (0, import_types.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 = {
       ...merged_data,
       event_id: merged_data.event_id ?? (0, import_uuid.v7)(),
@@ -283,11 +390,11 @@ 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);
+    const parsed = decodeEventSchema(event_parse_schema, base_data);
     Object.assign(this, parsed);
     Object.defineProperty(this, "event_schema", {
       value: event_schema,
@@ -295,6 +402,12 @@ 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,
@@ -324,10 +437,14 @@ class BaseEvent {
   static extend(event_type, shape) {
     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;
     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;
@@ -339,19 +456,22 @@ class BaseEvent {
       return new ExtendedEvent(data);
     }
     EventFactory.event_schema = full_schema;
+    EventFactory.model_fields = EventFactory.event_schema.shape;
     EventFactory.event_type = event_type;
     EventFactory.event_version = event_version ?? BaseEvent.event_version;
     EventFactory.event_result_type = event_result_type;
     EventFactory.class = ExtendedEvent;
     EventFactory.fromJSON = (data) => ExtendedEvent.fromJSON(data);
     EventFactory.prototype = ExtendedEvent.prototype;
+    defineStaticEventFields(ExtendedEvent, static_field_defaults);
+    defineStaticEventFields(EventFactory, static_field_defaults);
     EVENT_TYPE_REGISTRY.set(event_type, ExtendedEvent);
     return EventFactory;
   }
   static fromJSON(data) {
     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);
     }
     const record = { ...data };
@@ -368,9 +488,6 @@ class BaseEvent {
     if (this !== BaseEvent && ctor.event_result_type && record.event_result_type !== void 0) {
       delete record.event_result_type;
     }
-    if (record.event_result_type !== void 0 && record.event_result_type !== null) {
-      record.event_result_type = (0, import_types.normalizeEventResultType)(record.event_result_type);
-    }
     return new this(record);
   }
   static toJSONArray(events) {
@@ -395,8 +512,8 @@ class BaseEvent {
     const event_results = Object.fromEntries(
       Array.from(this.event_results.entries()).map(([handler_id, result]) => [handler_id, result.toJSON()])
     );
-    const event_schema = this.constructor.event_schema ?? this.event_schema ?? BaseEventSchema;
-    const encoded = encodeEventSchema(event_schema, {
+    const event_parse_schema = this.constructor._event_parse_schema ?? this._event_parse_schema ?? this.constructor.event_schema ?? this.event_schema ?? BaseEventSchema;
+    const encoded = encodeEventSchema(event_parse_schema, {
       ...record,
       event_id: this.event_id,
       event_type: this.event_type,
@@ -429,7 +546,7 @@ class BaseEvent {
       event_id: this.event_id,
       event_type: this.event_type,
       event_version: this.event_version,
-      event_result_type: this.event_result_type ? (0, import_types.toJsonSchema)(this.event_result_type) : this.event_result_type,
+      event_result_type: this.event_result_type ? (0, import_jsonschema.toJsonSchema)(this.event_result_type) : this.event_result_type,
       // static configuration options
       event_timeout: this.event_timeout,
       event_slow_timeout: this.event_slow_timeout,