abxbus 2.5.4 → 2.5.6

package/dist/esm/jsonschema.js

@@ -0,0 +1,135 @@
+import { z } from "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(z.toJSONSchema(schema));
+};
+const fromJsonSchema = (schema) => {
+  return z.fromJSONSchema(schema);
+};
+export {
+  fromJsonSchema,
+  isJsonSchema,
+  normalizeJsonSchema,
+  toJsonSchema
+};
+//# sourceMappingURL=jsonschema.js.map

package/dist/esm/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/esm/types.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { fromJsonSchema, isJsonSchema } from "./jsonschema.js";
 const normalizeEventPattern = (event_pattern) => {
   if (event_pattern === "*") {
     return "*";
@@ -50,16 +51,7 @@ const extractZodShape = (raw) => {
   }
   return shape;
 };
-const toJsonSchema = (schema) => {
-  if (!schema || !isZodSchema(schema)) return schema;
-  const zod_any = z;
-  return zod_any.toJSONSchema(schema);
-};
-const fromJsonSchema = (schema) => {
-  const zod_any = z;
-  return zod_any.fromJSONSchema(schema);
-};
-const normalizeEventResultType = (value) => {
+function normalizeEventResultType(value) {
   if (value === void 0 || value === null) {
     return void 0;
   }
@@ -70,15 +62,16 @@ const normalizeEventResultType = (value) => {
   if (constructor_schema) {
     return constructor_schema;
   }
+  if (!isJsonSchema(value)) {
+    throw new Error(`event_result_type must be a Zod schema, constructor shorthand, or JSON Schema value, got: ${typeof value}`);
+  }
   return fromJsonSchema(value);
-};
+}
 export {
   eventResultTypeFromConstructor,
   extractZodShape,
-  fromJsonSchema,
   isZodSchema,
   normalizeEventPattern,
-  normalizeEventResultType,
-  toJsonSchema
+  normalizeEventResultType
 };
 //# sourceMappingURL=types.js.map

package/dist/esm/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,SAAS,SAAS;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,EAAE,OAAO;AAAA,EAClB;AACA,MAAI,UAAU,QAAQ;AACpB,WAAO,EAAE,OAAO;AAAA,EAClB;AACA,MAAI,UAAU,SAAS;AACrB,WAAO,EAAE,QAAQ;AAAA,EACnB;AACA,MAAI,UAAU,OAAO;AACnB,WAAO,EAAE,MAAM,EAAE,QAAQ,CAAC;AAAA,EAC5B;AACA,MAAI,UAAU,QAAQ;AACpB,WAAO,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,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,SAAS,SAAS;AAElB,SAAS,gBAAgB,oBAAqC;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,EAAE,OAAO;AAAA,EAClB;AACA,MAAI,UAAU,QAAQ;AACpB,WAAO,EAAE,OAAO;AAAA,EAClB;AACA,MAAI,UAAU,SAAS;AACrB,WAAO,EAAE,QAAQ;AAAA,EACnB;AACA,MAAI,UAAU,OAAO;AACnB,WAAO,EAAE,MAAM,EAAE,QAAQ,CAAC;AAAA,EAC5B;AACA,MAAI,UAAU,QAAQ;AACpB,WAAO,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,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,CAAC,aAAa,KAAK,GAAG;AACxB,UAAM,IAAI,MAAM,6FAA6F,OAAO,KAAK,EAAE;AAAA,EAC7H;AACA,SAAO,eAAe,KAAK;AAC7B;",
   "names": []
 }

package/dist/types/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/types/base_event.d.ts

@@ -27,7 +27,7 @@ export declare const BaseEventSchema: z.ZodObject<{
     }>>;
     event_started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     event_completed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    event_results: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    event_results: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
     event_concurrency: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
         "global-serial": "global-serial";
         "bus-serial": "bus-serial";
@@ -133,7 +133,7 @@ export declare class BaseEvent {
         }>>;
         event_started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         event_completed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        event_results: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        event_results: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
         event_concurrency: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
             "global-serial": "global-serial";
             "bus-serial": "bus-serial";

package/dist/types/bridge_ipc.d.ts

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

package/dist/types/event_handler.d.ts

@@ -61,6 +61,7 @@ export declare class EventHandler {
         eventbus_id: string;
     });
     get _handler_async(): EventHandlerCallable;
+    static handlerNameFromCallable(handler: EventHandlerCallable): string;
     static computeHandlerId(params: {
         eventbus_id: string;
         handler_name: string;

package/dist/types/events_suck.d.ts

@@ -22,7 +22,7 @@ export type GeneratedEvents<TEvents extends FunctionMap> = {
 } & {
     [K in keyof TEvents]: GeneratedEvent<TEvents[K]>;
 };
-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> ? [init?: EventInit<TEventClass>, extra?: Record<string, unknown>] : [init: EventInit<TEventClass>, extra?: Record<string, unknown>];
 type EventMethodResult<TEventClass extends EventClass<BaseEvent>> = EventResultType<InstanceType<TEventClass>> | undefined;
 export type EventsSuckClient<TEvents extends EventMap> = {

package/dist/types/jsonschema.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export type JsonSchema = boolean | z.core.JSONSchema.JSONSchema;
+export declare const isJsonSchema: (value: unknown) => value is JsonSchema;
+export declare const normalizeJsonSchema: (schema: JsonSchema) => JsonSchema;
+export declare const toJsonSchema: (schema: z.core.$ZodType) => JsonSchema;
+export declare const fromJsonSchema: (schema: JsonSchema) => z.ZodTypeAny;

package/dist/types/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/types/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abxbus",
-  "version": "2.5.4",
+  "version": "2.5.6",
   "description": "Event bus library for browsers and ESM Node.js",
   "type": "module",
   "sideEffects": false,