abxbus 2.5.4 → 2.5.6

package/dist/cjs/jsonschema.js

@@ -0,0 +1,155 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jsonschema_exports = {};
+__export(jsonschema_exports, {
+  fromJsonSchema: () => fromJsonSchema,
+  isJsonSchema: () => isJsonSchema,
+  normalizeJsonSchema: () => normalizeJsonSchema,
+  toJsonSchema: () => toJsonSchema
+});
+module.exports = __toCommonJS(jsonschema_exports);
+var import_zod = require("zod");
+const isJsonSchemaObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const isJsonSchema = (value) => {
+  if (typeof value === "boolean") {
+    return true;
+  }
+  if (!isJsonSchemaObject(value)) {
+    return false;
+  }
+  if ("_zod" in value || "_def" in value || "~standard" in value) {
+    return false;
+  }
+  return true;
+};
+const nullUnionCandidates = (schema) => {
+  if (Array.isArray(schema.type) && schema.type.includes("null")) {
+    const non_null_types = schema.type.filter((item) => typeof item === "string" && item !== "null");
+    if (non_null_types.length > 0) {
+      return [{ type: non_null_types.length === 1 ? non_null_types[0] : non_null_types }, { type: "null" }];
+    }
+  }
+  return null;
+};
+const normalizeJsonSchema = (schema) => {
+  const normalized = normalizeJsonSchemaValue(schema);
+  if (!isJsonSchemaObject(normalized)) {
+    return normalized;
+  }
+  const schema_record = { ...normalized };
+  const definitions = schema_record.$defs;
+  const root_ref = rootRefForSchema(schema_record, definitions);
+  if (!root_ref || !definitions) {
+    schema_record.$schema ??= "https://json-schema.org/draft/2020-12/schema";
+    return schema_record;
+  }
+  const root_name = root_ref.slice("#/$defs/".length);
+  const root_schema = definitions[root_name];
+  if (!isJsonSchemaObject(root_schema)) {
+    schema_record.$schema ??= "https://json-schema.org/draft/2020-12/schema";
+    return schema_record;
+  }
+  const rewritten_root = rewriteJsonSchemaRefs(root_schema, { [root_ref]: "#" });
+  const remaining_defs = Object.fromEntries(Object.entries(definitions).filter(([name]) => name !== root_name));
+  if (Object.keys(remaining_defs).length > 0) {
+    rewritten_root.$defs = rewriteJsonSchemaRefs(remaining_defs, { [root_ref]: "#" });
+  }
+  rewritten_root.$schema ??= schema_record.$schema ?? "https://json-schema.org/draft/2020-12/schema";
+  setTitleFromInlinedRootDefinition(rewritten_root, root_name);
+  return rewritten_root;
+};
+const rootRefForSchema = (schema, definitions) => {
+  if (typeof schema.$ref === "string" && schema.$ref.startsWith("#/$defs/")) {
+    return schema.$ref;
+  }
+  if (!definitions) {
+    return null;
+  }
+  const root = schemaWithoutSchemaAndDefinitions(schema);
+  for (const [name, definition] of Object.entries(definitions)) {
+    if (JSON.stringify(definition) === JSON.stringify(root)) {
+      return `#/$defs/${name}`;
+    }
+  }
+  return null;
+};
+const schemaWithoutSchemaAndDefinitions = (schema) => {
+  const root = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key !== "$schema" && key !== "$defs") {
+      root[key] = value;
+    }
+  }
+  return root;
+};
+const setTitleFromInlinedRootDefinition = (schema, root_name) => {
+  if (root_name.startsWith("__schema")) return;
+  schema.title ??= root_name;
+};
+const rewriteJsonSchemaRefs = (schema, refs) => {
+  if (Array.isArray(schema)) {
+    return schema.map((item) => rewriteJsonSchemaRefs(item, refs));
+  }
+  if (!isJsonSchemaObject(schema)) {
+    return schema;
+  }
+  const rewritten = {};
+  for (const [key, value] of Object.entries(schema)) {
+    rewritten[key] = rewriteJsonSchemaRefs(value, refs);
+  }
+  if (typeof rewritten.$ref === "string" && rewritten.$ref in refs) {
+    rewritten.$ref = refs[rewritten.$ref];
+  }
+  return rewritten;
+};
+const normalizeJsonSchemaValue = (schema) => {
+  if (Array.isArray(schema)) {
+    return schema.map((item) => normalizeJsonSchemaValue(item));
+  }
+  if (!isJsonSchemaObject(schema)) {
+    return schema;
+  }
+  const normalized = {};
+  for (const [key, value] of Object.entries(schema)) {
+    normalized[key] = normalizeJsonSchemaValue(value);
+  }
+  if (Array.isArray(normalized.required) && normalized.required.every((item) => typeof item === "string")) {
+    normalized.required = [...normalized.required].sort();
+  }
+  const null_union_candidates = nullUnionCandidates(normalized);
+  if (null_union_candidates !== null) {
+    const merged = { anyOf: normalizeJsonSchemaValue(null_union_candidates) };
+    for (const [key, value] of Object.entries(normalized)) {
+      if (key !== "type") {
+        merged[key] = value;
+      }
+    }
+    return merged;
+  }
+  return normalized;
+};
+const toJsonSchema = (schema) => {
+  return normalizeJsonSchema(import_zod.z.toJSONSchema(schema));
+};
+const fromJsonSchema = (schema) => {
+  return import_zod.z.fromJSONSchema(schema);
+};
+//# sourceMappingURL=jsonschema.js.map

package/dist/cjs/jsonschema.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/jsonschema.ts"],
+  "sourcesContent": ["import { z } from 'zod'\n\nexport type JsonSchema = boolean | z.core.JSONSchema.JSONSchema\ntype JsonSchemaObject = z.core.JSONSchema.JSONSchema\n\nconst isJsonSchemaObject = (value: unknown): value is JsonSchemaObject => {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\nexport const isJsonSchema = (value: unknown): value is JsonSchema => {\n  if (typeof value === 'boolean') {\n    return true\n  }\n  if (!isJsonSchemaObject(value)) {\n    return false\n  }\n  if ('_zod' in value || '_def' in value || '~standard' in value) {\n    return false\n  }\n  return true\n}\n\nconst nullUnionCandidates = (schema: Record<string, unknown>): Record<string, unknown>[] | null => {\n  if (Array.isArray(schema.type) && schema.type.includes('null')) {\n    const non_null_types = schema.type.filter((item): item is string => typeof item === 'string' && item !== 'null')\n    if (non_null_types.length > 0) {\n      return [{ type: non_null_types.length === 1 ? non_null_types[0] : non_null_types }, { type: 'null' }]\n    }\n  }\n\n  return null\n}\n\nexport const normalizeJsonSchema = (schema: JsonSchema): JsonSchema => {\n  const normalized = normalizeJsonSchemaValue(schema)\n  if (!isJsonSchemaObject(normalized)) {\n    return normalized as JsonSchema\n  }\n  const schema_record = { ...normalized } as JsonSchemaObject\n  const definitions = schema_record.$defs\n  const root_ref = rootRefForSchema(schema_record, definitions)\n  if (!root_ref || !definitions) {\n    schema_record.$schema ??= 'https://json-schema.org/draft/2020-12/schema'\n    return schema_record\n  }\n  const root_name = root_ref.slice('#/$defs/'.length)\n  const root_schema = definitions[root_name]\n  if (!isJsonSchemaObject(root_schema)) {\n    schema_record.$schema ??= 'https://json-schema.org/draft/2020-12/schema'\n    return schema_record\n  }\n  const rewritten_root = rewriteJsonSchemaRefs(root_schema, { [root_ref]: '#' }) as JsonSchemaObject\n  const remaining_defs = Object.fromEntries(Object.entries(definitions).filter(([name]) => name !== root_name))\n  if (Object.keys(remaining_defs).length > 0) {\n    rewritten_root.$defs = rewriteJsonSchemaRefs(remaining_defs, { [root_ref]: '#' }) as Record<string, JsonSchemaObject>\n  }\n  rewritten_root.$schema ??= schema_record.$schema ?? 'https://json-schema.org/draft/2020-12/schema'\n  setTitleFromInlinedRootDefinition(rewritten_root, root_name)\n  return rewritten_root\n}\n\nconst rootRefForSchema = (schema: JsonSchemaObject, definitions: Record<string, JsonSchemaObject> | undefined): string | null => {\n  if (typeof schema.$ref === 'string' && schema.$ref.startsWith('#/$defs/')) {\n    return schema.$ref\n  }\n  if (!definitions) {\n    return null\n  }\n  const root = schemaWithoutSchemaAndDefinitions(schema)\n  for (const [name, definition] of Object.entries(definitions)) {\n    if (JSON.stringify(definition) === JSON.stringify(root)) {\n      return `#/$defs/${name}`\n    }\n  }\n  return null\n}\n\nconst schemaWithoutSchemaAndDefinitions = (schema: JsonSchemaObject): Record<string, unknown> => {\n  const root: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(schema)) {\n    if (key !== '$schema' && key !== '$defs') {\n      root[key] = value\n    }\n  }\n  return root\n}\n\nconst setTitleFromInlinedRootDefinition = (schema: JsonSchemaObject, root_name: string): void => {\n  if (root_name.startsWith('__schema')) return\n  schema.title ??= root_name\n}\n\nconst rewriteJsonSchemaRefs = (schema: unknown, refs: Record<string, string>): unknown => {\n  if (Array.isArray(schema)) {\n    return schema.map((item) => rewriteJsonSchemaRefs(item, refs))\n  }\n  if (!isJsonSchemaObject(schema)) {\n    return schema\n  }\n  const rewritten: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(schema)) {\n    rewritten[key] = rewriteJsonSchemaRefs(value, refs)\n  }\n  if (typeof rewritten.$ref === 'string' && rewritten.$ref in refs) {\n    rewritten.$ref = refs[rewritten.$ref]\n  }\n  return rewritten\n}\n\nconst normalizeJsonSchemaValue = (schema: unknown): unknown => {\n  if (Array.isArray(schema)) {\n    return schema.map((item) => normalizeJsonSchemaValue(item))\n  }\n  if (!isJsonSchemaObject(schema)) {\n    return schema\n  }\n\n  const normalized: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(schema)) {\n    normalized[key] = normalizeJsonSchemaValue(value)\n  }\n  if (Array.isArray(normalized.required) && normalized.required.every((item) => typeof item === 'string')) {\n    normalized.required = [...normalized.required].sort()\n  }\n\n  const null_union_candidates = nullUnionCandidates(normalized)\n  if (null_union_candidates !== null) {\n    const merged: Record<string, unknown> = { anyOf: normalizeJsonSchemaValue(null_union_candidates) }\n    for (const [key, value] of Object.entries(normalized)) {\n      if (key !== 'type') {\n        merged[key] = value\n      }\n    }\n    return merged\n  }\n\n  return normalized\n}\n\nexport const toJsonSchema = (schema: z.core.$ZodType): JsonSchema => {\n  return normalizeJsonSchema(z.toJSONSchema(schema) as JsonSchema)\n}\n\nexport const fromJsonSchema = (schema: JsonSchema): z.ZodTypeAny => {\n  return z.fromJSONSchema(schema)\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/middleware_otel_tracing.d.ts

@@ -0,0 +1,49 @@
+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/cjs/types.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import type { BaseEvent } from './BaseEvent.js';
+import { type JsonSchema } from './jsonschema.js';
 export type EventStatus = 'pending' | 'started' | 'completed';
 export type EventClass<T extends BaseEvent = BaseEvent> = {
     event_type?: string;
@@ -12,7 +13,7 @@ export type EventResultType<TEvent extends BaseEvent> = TEvent extends {
     __event_result_type__?: infer TResult;
 } ? TResult : unknown;
 export type EventResultTypeConstructor = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
-export type EventResultTypeInput = z.ZodTypeAny | EventResultTypeConstructor | unknown;
+export type EventResultTypeInput = z.ZodTypeAny | EventResultTypeConstructor | JsonSchema;
 export type EventHandlerReturn<T extends BaseEvent = BaseEvent> = EventResultType<T> | BaseEvent | null | void;
 export type EventHandlerCallable<T extends BaseEvent = BaseEvent> = (event: T) => EventHandlerReturn<T> | Promise<EventHandlerReturn<T>>;
 export type UntypedEventHandlerFunction<T extends BaseEvent = BaseEvent> = (event: T) => EventHandlerReturn<T> | unknown | Promise<EventHandlerReturn<T> | unknown>;
@@ -33,7 +34,5 @@ export declare const normalizeEventPattern: (event_pattern: EventPattern | "*")
 export declare const isZodSchema: (value: unknown) => value is z.ZodTypeAny;
 export declare const eventResultTypeFromConstructor: (value: unknown) => z.ZodTypeAny | undefined;
 export declare const extractZodShape: (raw: Record<string, unknown>) => z.ZodRawShape;
-export declare const toJsonSchema: (schema: unknown) => unknown;
-export declare const fromJsonSchema: (schema: unknown) => z.ZodTypeAny;
-export declare const normalizeEventResultType: (value: EventResultTypeInput) => z.ZodTypeAny | undefined;
+export declare function normalizeEventResultType(value: unknown): z.ZodTypeAny | undefined;
 export {};

package/dist/cjs/types.js

@@ -20,14 +20,13 @@ var types_exports = {};
 __export(types_exports, {
   eventResultTypeFromConstructor: () => eventResultTypeFromConstructor,
   extractZodShape: () => extractZodShape,
-  fromJsonSchema: () => fromJsonSchema,
   isZodSchema: () => isZodSchema,
   normalizeEventPattern: () => normalizeEventPattern,
-  normalizeEventResultType: () => normalizeEventResultType,
-  toJsonSchema: () => toJsonSchema
+  normalizeEventResultType: () => normalizeEventResultType
 });
 module.exports = __toCommonJS(types_exports);
 var import_zod = require("zod");
+var import_jsonschema = require("./jsonschema.js");
 const normalizeEventPattern = (event_pattern) => {
   if (event_pattern === "*") {
     return "*";
@@ -79,16 +78,7 @@ const extractZodShape = (raw) => {
   }
   return shape;
 };
-const toJsonSchema = (schema) => {
-  if (!schema || !isZodSchema(schema)) return schema;
-  const zod_any = import_zod.z;
-  return zod_any.toJSONSchema(schema);
-};
-const fromJsonSchema = (schema) => {
-  const zod_any = import_zod.z;
-  return zod_any.fromJSONSchema(schema);
-};
-const normalizeEventResultType = (value) => {
+function normalizeEventResultType(value) {
   if (value === void 0 || value === null) {
     return void 0;
   }
@@ -99,6 +89,9 @@ const normalizeEventResultType = (value) => {
   if (constructor_schema) {
     return constructor_schema;
   }
-  return fromJsonSchema(value);
-};
+  if (!(0, import_jsonschema.isJsonSchema)(value)) {
+    throw new Error(`event_result_type must be a Zod schema, constructor shorthand, or JSON Schema value, got: ${typeof value}`);
+  }
+  return (0, import_jsonschema.fromJsonSchema)(value);
+}
 //# sourceMappingURL=types.js.map

package/dist/cjs/types.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/types.ts"],
-  "sourcesContent": ["import { z } from 'zod'\nimport type { BaseEvent } from './BaseEvent.js'\n\nexport type EventStatus = 'pending' | 'started' | 'completed'\n\nexport type EventClass<T extends BaseEvent = BaseEvent> = { event_type?: string } & (new (...args: any[]) => T)\n\nexport type EventPattern<T extends BaseEvent = BaseEvent> = string | EventClass<T>\n\nexport type EventWithResultSchema<TResult> = BaseEvent & { __event_result_type__?: TResult }\n\nexport type EventResultType<TEvent extends BaseEvent> = TEvent extends { __event_result_type__?: infer TResult } ? TResult : unknown\n\nexport type EventResultTypeConstructor = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor\n\nexport type EventResultTypeInput = z.ZodTypeAny | EventResultTypeConstructor | unknown\n\nexport type EventHandlerReturn<T extends BaseEvent = BaseEvent> = EventResultType<T> | BaseEvent | null | void\n\nexport type EventHandlerCallable<T extends BaseEvent = BaseEvent> = (event: T) => EventHandlerReturn<T> | Promise<EventHandlerReturn<T>>\n\n// For string and wildcard subscriptions we cannot reliably infer which event\n// type will arrive, so return type checking intentionally degrades to unknown.\nexport type UntypedEventHandlerFunction<T extends BaseEvent = BaseEvent> = (\n  event: T\n) => EventHandlerReturn<T> | unknown | Promise<EventHandlerReturn<T> | unknown>\n\nexport type FindWindow = boolean | number\n\ntype FindReservedOptionKeys = 'past' | 'future' | 'child_of'\n\ntype EventFilterFields<T extends BaseEvent> = {\n  [K in keyof T as string extends K\n    ? never\n    : number extends K\n      ? never\n      : symbol extends K\n        ? never\n        : K extends FindReservedOptionKeys\n          ? never\n          : T[K] extends (...args: any[]) => any\n            ? never\n            : K]?: T[K]\n}\n\nexport type FindOptions<T extends BaseEvent = BaseEvent> = {\n  past?: FindWindow\n  future?: FindWindow\n  child_of?: BaseEvent | null\n} & EventFilterFields<T> &\n  Record<string, unknown>\n\nexport type FilterOptions<T extends BaseEvent = BaseEvent> = FindOptions<T> & { limit?: number | null }\n\nexport const normalizeEventPattern = (event_pattern: EventPattern | '*'): string | '*' => {\n  if (event_pattern === '*') {\n    return '*'\n  }\n  if (typeof event_pattern === 'string') {\n    return event_pattern\n  }\n  const event_type = (event_pattern as { event_type?: unknown }).event_type\n  if (typeof event_type === 'string' && event_type.length > 0 && event_type !== 'BaseEvent') {\n    return event_type\n  }\n  const class_name = (event_pattern as { name?: unknown }).name\n  if (typeof class_name === 'string' && class_name.length > 0 && class_name !== 'BaseEvent') {\n    return class_name\n  }\n  let preview: string\n  try {\n    const encoded = JSON.stringify(event_pattern)\n    preview = typeof encoded === 'string' ? encoded.slice(0, 30) : String(event_pattern).slice(0, 30)\n  } catch {\n    preview = String(event_pattern).slice(0, 30)\n  }\n  throw new Error('bus.on(match_pattern, ...) must be a string event type, \"*\", or a BaseEvent class, got: ' + preview)\n}\n\nexport const isZodSchema = (value: unknown): value is z.ZodTypeAny => !!value && typeof (value as z.ZodTypeAny).safeParse === 'function'\n\nexport const eventResultTypeFromConstructor = (value: unknown): z.ZodTypeAny | undefined => {\n  if (value === String) {\n    return z.string()\n  }\n  if (value === Number) {\n    return z.number()\n  }\n  if (value === Boolean) {\n    return z.boolean()\n  }\n  if (value === Array) {\n    return z.array(z.unknown())\n  }\n  if (value === Object) {\n    return z.record(z.string(), z.unknown())\n  }\n  return undefined\n}\n\nexport const extractZodShape = (raw: Record<string, unknown>): z.ZodRawShape => {\n  const shape: Record<string, z.ZodTypeAny> = {}\n  for (const [key, value] of Object.entries(raw)) {\n    if (key === 'event_result_type') continue\n    if (isZodSchema(value)) shape[key] = value\n  }\n  return shape as z.ZodRawShape\n}\n\nexport const toJsonSchema = (schema: unknown): unknown => {\n  if (!schema || !isZodSchema(schema)) return schema\n  const zod_any = z as unknown as { toJSONSchema: (input: z.ZodTypeAny) => unknown }\n  // Cross-language roundtrips preserve core structural types; constraint keywords may not roundtrip exactly.\n  return zod_any.toJSONSchema(schema)\n}\n\nexport const fromJsonSchema = (schema: unknown): z.ZodTypeAny => {\n  const zod_any = z as unknown as { fromJSONSchema: (input: unknown) => z.ZodTypeAny }\n  return zod_any.fromJSONSchema(schema)\n}\n\nexport const normalizeEventResultType = (value: EventResultTypeInput): z.ZodTypeAny | undefined => {\n  if (value === undefined || value === null) {\n    return undefined\n  }\n  if (isZodSchema(value)) {\n    return value\n  }\n  const constructor_schema = eventResultTypeFromConstructor(value)\n  if (constructor_schema) {\n    return constructor_schema\n  }\n  return fromJsonSchema(value)\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAkB;AAsDX,MAAM,wBAAwB,CAAC,kBAAoD;AACxF,MAAI,kBAAkB,KAAK;AACzB,WAAO;AAAA,EACT;AACA,MAAI,OAAO,kBAAkB,UAAU;AACrC,WAAO;AAAA,EACT;AACA,QAAM,aAAc,cAA2C;AAC/D,MAAI,OAAO,eAAe,YAAY,WAAW,SAAS,KAAK,eAAe,aAAa;AACzF,WAAO;AAAA,EACT;AACA,QAAM,aAAc,cAAqC;AACzD,MAAI,OAAO,eAAe,YAAY,WAAW,SAAS,KAAK,eAAe,aAAa;AACzF,WAAO;AAAA,EACT;AACA,MAAI;AACJ,MAAI;AACF,UAAM,UAAU,KAAK,UAAU,aAAa;AAC5C,cAAU,OAAO,YAAY,WAAW,QAAQ,MAAM,GAAG,EAAE,IAAI,OAAO,aAAa,EAAE,MAAM,GAAG,EAAE;AAAA,EAClG,QAAQ;AACN,cAAU,OAAO,aAAa,EAAE,MAAM,GAAG,EAAE;AAAA,EAC7C;AACA,QAAM,IAAI,MAAM,6FAA6F,OAAO;AACtH;AAEO,MAAM,cAAc,CAAC,UAA0C,CAAC,CAAC,SAAS,OAAQ,MAAuB,cAAc;AAEvH,MAAM,iCAAiC,CAAC,UAA6C;AAC1F,MAAI,UAAU,QAAQ;AACpB,WAAO,aAAE,OAAO;AAAA,EAClB;AACA,MAAI,UAAU,QAAQ;AACpB,WAAO,aAAE,OAAO;AAAA,EAClB;AACA,MAAI,UAAU,SAAS;AACrB,WAAO,aAAE,QAAQ;AAAA,EACnB;AACA,MAAI,UAAU,OAAO;AACnB,WAAO,aAAE,MAAM,aAAE,QAAQ,CAAC;AAAA,EAC5B;AACA,MAAI,UAAU,QAAQ;AACpB,WAAO,aAAE,OAAO,aAAE,OAAO,GAAG,aAAE,QAAQ,CAAC;AAAA,EACzC;AACA,SAAO;AACT;AAEO,MAAM,kBAAkB,CAAC,QAAgD;AAC9E,QAAM,QAAsC,CAAC;AAC7C,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC9C,QAAI,QAAQ,oBAAqB;AACjC,QAAI,YAAY,KAAK,EAAG,OAAM,GAAG,IAAI;AAAA,EACvC;AACA,SAAO;AACT;AAEO,MAAM,eAAe,CAAC,WAA6B;AACxD,MAAI,CAAC,UAAU,CAAC,YAAY,MAAM,EAAG,QAAO;AAC5C,QAAM,UAAU;AAEhB,SAAO,QAAQ,aAAa,MAAM;AACpC;AAEO,MAAM,iBAAiB,CAAC,WAAkC;AAC/D,QAAM,UAAU;AAChB,SAAO,QAAQ,eAAe,MAAM;AACtC;AAEO,MAAM,2BAA2B,CAAC,UAA0D;AACjG,MAAI,UAAU,UAAa,UAAU,MAAM;AACzC,WAAO;AAAA,EACT;AACA,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO;AAAA,EACT;AACA,QAAM,qBAAqB,+BAA+B,KAAK;AAC/D,MAAI,oBAAoB;AACtB,WAAO;AAAA,EACT;AACA,SAAO,eAAe,KAAK;AAC7B;",
+  "sourcesContent": ["import { z } from 'zod'\nimport type { BaseEvent } from './BaseEvent.js'\nimport { fromJsonSchema, isJsonSchema, type JsonSchema } from './jsonschema.js'\n\nexport type EventStatus = 'pending' | 'started' | 'completed'\n\nexport type EventClass<T extends BaseEvent = BaseEvent> = { event_type?: string } & (new (...args: any[]) => T)\n\nexport type EventPattern<T extends BaseEvent = BaseEvent> = string | EventClass<T>\n\nexport type EventWithResultSchema<TResult> = BaseEvent & { __event_result_type__?: TResult }\n\nexport type EventResultType<TEvent extends BaseEvent> = TEvent extends { __event_result_type__?: infer TResult } ? TResult : unknown\n\nexport type EventResultTypeConstructor = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor\n\nexport type EventResultTypeInput = z.ZodTypeAny | EventResultTypeConstructor | JsonSchema\n\nexport type EventHandlerReturn<T extends BaseEvent = BaseEvent> = EventResultType<T> | BaseEvent | null | void\n\nexport type EventHandlerCallable<T extends BaseEvent = BaseEvent> = (event: T) => EventHandlerReturn<T> | Promise<EventHandlerReturn<T>>\n\n// For string and wildcard subscriptions we cannot reliably infer which event\n// type will arrive, so return type checking intentionally degrades to unknown.\nexport type UntypedEventHandlerFunction<T extends BaseEvent = BaseEvent> = (\n  event: T\n) => EventHandlerReturn<T> | unknown | Promise<EventHandlerReturn<T> | unknown>\n\nexport type FindWindow = boolean | number\n\ntype FindReservedOptionKeys = 'past' | 'future' | 'child_of'\n\ntype EventFilterFields<T extends BaseEvent> = {\n  [K in keyof T as string extends K\n    ? never\n    : number extends K\n      ? never\n      : symbol extends K\n        ? never\n        : K extends FindReservedOptionKeys\n          ? never\n          : T[K] extends (...args: any[]) => any\n            ? never\n            : K]?: T[K]\n}\n\nexport type FindOptions<T extends BaseEvent = BaseEvent> = {\n  past?: FindWindow\n  future?: FindWindow\n  child_of?: BaseEvent | null\n} & EventFilterFields<T> &\n  Record<string, unknown>\n\nexport type FilterOptions<T extends BaseEvent = BaseEvent> = FindOptions<T> & { limit?: number | null }\n\nexport const normalizeEventPattern = (event_pattern: EventPattern | '*'): string | '*' => {\n  if (event_pattern === '*') {\n    return '*'\n  }\n  if (typeof event_pattern === 'string') {\n    return event_pattern\n  }\n  const event_type = (event_pattern as { event_type?: unknown }).event_type\n  if (typeof event_type === 'string' && event_type.length > 0 && event_type !== 'BaseEvent') {\n    return event_type\n  }\n  const class_name = (event_pattern as { name?: unknown }).name\n  if (typeof class_name === 'string' && class_name.length > 0 && class_name !== 'BaseEvent') {\n    return class_name\n  }\n  let preview: string\n  try {\n    const encoded = JSON.stringify(event_pattern)\n    preview = typeof encoded === 'string' ? encoded.slice(0, 30) : String(event_pattern).slice(0, 30)\n  } catch {\n    preview = String(event_pattern).slice(0, 30)\n  }\n  throw new Error('bus.on(match_pattern, ...) must be a string event type, \"*\", or a BaseEvent class, got: ' + preview)\n}\n\nexport const isZodSchema = (value: unknown): value is z.ZodTypeAny => !!value && typeof (value as z.ZodTypeAny).safeParse === 'function'\n\nexport const eventResultTypeFromConstructor = (value: unknown): z.ZodTypeAny | undefined => {\n  if (value === String) {\n    return z.string()\n  }\n  if (value === Number) {\n    return z.number()\n  }\n  if (value === Boolean) {\n    return z.boolean()\n  }\n  if (value === Array) {\n    return z.array(z.unknown())\n  }\n  if (value === Object) {\n    return z.record(z.string(), z.unknown())\n  }\n  return undefined\n}\n\nexport const extractZodShape = (raw: Record<string, unknown>): z.ZodRawShape => {\n  const shape: Record<string, z.ZodTypeAny> = {}\n  for (const [key, value] of Object.entries(raw)) {\n    if (key === 'event_result_type') continue\n    if (isZodSchema(value)) shape[key] = value\n  }\n  return shape as z.ZodRawShape\n}\n\nexport function normalizeEventResultType(value: unknown): z.ZodTypeAny | undefined {\n  if (value === undefined || value === null) {\n    return undefined\n  }\n  if (isZodSchema(value)) {\n    return value\n  }\n  const constructor_schema = eventResultTypeFromConstructor(value)\n  if (constructor_schema) {\n    return constructor_schema\n  }\n  if (!isJsonSchema(value)) {\n    throw new Error(`event_result_type must be a Zod schema, constructor shorthand, or JSON Schema value, got: ${typeof value}`)\n  }\n  return fromJsonSchema(value)\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAkB;AAElB,wBAA8D;AAqDvD,MAAM,wBAAwB,CAAC,kBAAoD;AACxF,MAAI,kBAAkB,KAAK;AACzB,WAAO;AAAA,EACT;AACA,MAAI,OAAO,kBAAkB,UAAU;AACrC,WAAO;AAAA,EACT;AACA,QAAM,aAAc,cAA2C;AAC/D,MAAI,OAAO,eAAe,YAAY,WAAW,SAAS,KAAK,eAAe,aAAa;AACzF,WAAO;AAAA,EACT;AACA,QAAM,aAAc,cAAqC;AACzD,MAAI,OAAO,eAAe,YAAY,WAAW,SAAS,KAAK,eAAe,aAAa;AACzF,WAAO;AAAA,EACT;AACA,MAAI;AACJ,MAAI;AACF,UAAM,UAAU,KAAK,UAAU,aAAa;AAC5C,cAAU,OAAO,YAAY,WAAW,QAAQ,MAAM,GAAG,EAAE,IAAI,OAAO,aAAa,EAAE,MAAM,GAAG,EAAE;AAAA,EAClG,QAAQ;AACN,cAAU,OAAO,aAAa,EAAE,MAAM,GAAG,EAAE;AAAA,EAC7C;AACA,QAAM,IAAI,MAAM,6FAA6F,OAAO;AACtH;AAEO,MAAM,cAAc,CAAC,UAA0C,CAAC,CAAC,SAAS,OAAQ,MAAuB,cAAc;AAEvH,MAAM,iCAAiC,CAAC,UAA6C;AAC1F,MAAI,UAAU,QAAQ;AACpB,WAAO,aAAE,OAAO;AAAA,EAClB;AACA,MAAI,UAAU,QAAQ;AACpB,WAAO,aAAE,OAAO;AAAA,EAClB;AACA,MAAI,UAAU,SAAS;AACrB,WAAO,aAAE,QAAQ;AAAA,EACnB;AACA,MAAI,UAAU,OAAO;AACnB,WAAO,aAAE,MAAM,aAAE,QAAQ,CAAC;AAAA,EAC5B;AACA,MAAI,UAAU,QAAQ;AACpB,WAAO,aAAE,OAAO,aAAE,OAAO,GAAG,aAAE,QAAQ,CAAC;AAAA,EACzC;AACA,SAAO;AACT;AAEO,MAAM,kBAAkB,CAAC,QAAgD;AAC9E,QAAM,QAAsC,CAAC;AAC7C,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC9C,QAAI,QAAQ,oBAAqB;AACjC,QAAI,YAAY,KAAK,EAAG,OAAM,GAAG,IAAI;AAAA,EACvC;AACA,SAAO;AACT;AAEO,SAAS,yBAAyB,OAA0C;AACjF,MAAI,UAAU,UAAa,UAAU,MAAM;AACzC,WAAO;AAAA,EACT;AACA,MAAI,YAAY,KAAK,GAAG;AACtB,WAAO;AAAA,EACT;AACA,QAAM,qBAAqB,+BAA+B,KAAK;AAC/D,MAAI,oBAAoB;AACtB,WAAO;AAAA,EACT;AACA,MAAI,KAAC,gCAAa,KAAK,GAAG;AACxB,UAAM,IAAI,MAAM,6FAA6F,OAAO,KAAK,EAAE;AAAA,EAC7H;AACA,aAAO,kCAAe,KAAK;AAC7B;",
   "names": []
 }

package/dist/esm/BaseEvent.js

@@ -10,7 +10,8 @@ import {
   withResolvers
 } from "./LockManager.js";
 import { _runWithTimeout } from "./timing.js";
-import { isZodSchema, normalizeEventResultType, toJsonSchema } from "./types.js";
+import { toJsonSchema } from "./jsonschema.js";
+import { isZodSchema, normalizeEventResultType } from "./types.js";
 import { monotonicDatetime } from "./helpers.js";
 const RESERVED_USER_EVENT_FIELDS = /* @__PURE__ */ new Set([
   "bus",
@@ -83,6 +84,16 @@ const BaseEventSchema = z.object({
   event_handler_completion: z.enum(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 {
@@ -112,11 +123,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 z.literal(value);
+  }
+  return z.custom((candidate) => shortcutLiteralValuesEqual(candidate, value), "Invalid literal value");
+}
 function shortcutDefaultSchema(base_field_schema, value) {
   if (!base_field_schema) {
-    return 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 = {};
@@ -139,10 +206,42 @@ function zodFieldsForShortcut(raw_shape) {
   }
   return fields;
 }
+function modelFieldsForShortcut(raw_shape, shortcut_shape) {
+  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) {
+  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 : normalizeEventResultType(raw_event_result_type);
 }
+function eventParseSchemaFromEventSchema(schema) {
+  return schema.safeExtend({
+    event_result_type: z.unknown().optional()
+  });
+}
 function buildFullEventSchema(event_type, spec) {
   if (isZodObjectSchema(spec)) {
     const user_shape = spec.shape;
@@ -150,11 +249,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: 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)
     };
   }
@@ -166,9 +266,12 @@ function buildFullEventSchema(event_type, spec) {
     ...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 : void 0
   };
@@ -229,12 +332,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)
@@ -257,6 +363,7 @@ class BaseEvent {
     const raw_event_result_type = merged_data.event_result_type ?? ctor.event_result_type;
     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 = {
       ...merged_data,
       event_id: merged_data.event_id ?? uuidv7(),
@@ -265,11 +372,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,
@@ -277,6 +384,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,
@@ -306,10 +419,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;
@@ -321,19 +438,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 };
@@ -350,9 +470,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 = normalizeEventResultType(record.event_result_type);
-    }
     return new this(record);
   }
   static toJSONArray(events) {
@@ -377,8 +494,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,