abxbus 2.5.3 → 2.5.6

package/src/jsonschema.ts

@@ -0,0 +1,146 @@
+import { z } from 'zod'
+
+export type JsonSchema = boolean | z.core.JSONSchema.JSONSchema
+type JsonSchemaObject = z.core.JSONSchema.JSONSchema
+
+const isJsonSchemaObject = (value: unknown): value is JsonSchemaObject => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export const isJsonSchema = (value: unknown): value is JsonSchema => {
+  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: Record<string, unknown>): Record<string, unknown>[] | null => {
+  if (Array.isArray(schema.type) && schema.type.includes('null')) {
+    const non_null_types = schema.type.filter((item): item is string => 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
+}
+
+export const normalizeJsonSchema = (schema: JsonSchema): JsonSchema => {
+  const normalized = normalizeJsonSchemaValue(schema)
+  if (!isJsonSchemaObject(normalized)) {
+    return normalized as JsonSchema
+  }
+  const schema_record = { ...normalized } as JsonSchemaObject
+  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]: '#' }) as JsonSchemaObject
+  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]: '#' }) as Record<string, JsonSchemaObject>
+  }
+  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: JsonSchemaObject, definitions: Record<string, JsonSchemaObject> | undefined): string | null => {
+  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: JsonSchemaObject): Record<string, unknown> => {
+  const root: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(schema)) {
+    if (key !== '$schema' && key !== '$defs') {
+      root[key] = value
+    }
+  }
+  return root
+}
+
+const setTitleFromInlinedRootDefinition = (schema: JsonSchemaObject, root_name: string): void => {
+  if (root_name.startsWith('__schema')) return
+  schema.title ??= root_name
+}
+
+const rewriteJsonSchemaRefs = (schema: unknown, refs: Record<string, string>): unknown => {
+  if (Array.isArray(schema)) {
+    return schema.map((item) => rewriteJsonSchemaRefs(item, refs))
+  }
+  if (!isJsonSchemaObject(schema)) {
+    return schema
+  }
+  const rewritten: Record<string, unknown> = {}
+  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: unknown): unknown => {
+  if (Array.isArray(schema)) {
+    return schema.map((item) => normalizeJsonSchemaValue(item))
+  }
+  if (!isJsonSchemaObject(schema)) {
+    return schema
+  }
+
+  const normalized: Record<string, unknown> = {}
+  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: Record<string, unknown> = { anyOf: normalizeJsonSchemaValue(null_union_candidates) }
+    for (const [key, value] of Object.entries(normalized)) {
+      if (key !== 'type') {
+        merged[key] = value
+      }
+    }
+    return merged
+  }
+
+  return normalized
+}
+
+export const toJsonSchema = (schema: z.core.$ZodType): JsonSchema => {
+  return normalizeJsonSchema(z.toJSONSchema(schema) as JsonSchema)
+}
+
+export const fromJsonSchema = (schema: JsonSchema): z.ZodTypeAny => {
+  return z.fromJSONSchema(schema)
+}

package/src/retry.ts

@@ -275,7 +275,12 @@ export function retry(options: RetryOptions = {}): RetryDecorator {
       }
     }
 
-    const runRetryLoopFromThenable = async (this_arg: any, args: any[], first_thenable: PromiseLike<any>, first_attempt: number): Promise<any> => {
+    const runRetryLoopFromThenable = async (
+      this_arg: any,
+      args: any[],
+      first_thenable: PromiseLike<any>,
+      first_attempt: number
+    ): Promise<any> => {
       let current_result: any = first_thenable
       for (let attempt = first_attempt; attempt <= effective_max_attempts; attempt++) {
         try {
@@ -560,9 +565,7 @@ function isAsyncFunction(fn: AnyFunction): boolean {
 
 function isThenable(value: unknown): value is PromiseLike<unknown> {
   return (
-    (typeof value === 'object' || typeof value === 'function') &&
-    value !== null &&
-    typeof (value as { then?: unknown }).then === 'function'
+    (typeof value === 'object' || typeof value === 'function') && value !== null && typeof (value as { then?: unknown }).then === 'function'
   )
 }
 

package/src/types.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod'
 import type { BaseEvent } from './BaseEvent.js'
+import { fromJsonSchema, isJsonSchema, type JsonSchema } from './jsonschema.js'
 
 export type EventStatus = 'pending' | 'started' | 'completed'
 
@@ -13,7 +14,7 @@ export type EventResultType<TEvent extends BaseEvent> = TEvent extends { __event
 
 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
 
@@ -107,19 +108,7 @@ export const extractZodShape = (raw: Record<string, unknown>): z.ZodRawShape =>
   return shape as z.ZodRawShape
 }
 
-export const toJsonSchema = (schema: unknown): unknown => {
-  if (!schema || !isZodSchema(schema)) return schema
-  const zod_any = z as unknown as { toJSONSchema: (input: z.ZodTypeAny) => unknown }
-  // Cross-language roundtrips preserve core structural types; constraint keywords may not roundtrip exactly.
-  return zod_any.toJSONSchema(schema)
-}
-
-export const fromJsonSchema = (schema: unknown): z.ZodTypeAny => {
-  const zod_any = z as unknown as { fromJSONSchema: (input: unknown) => z.ZodTypeAny }
-  return zod_any.fromJSONSchema(schema)
-}
-
-export const normalizeEventResultType = (value: EventResultTypeInput): z.ZodTypeAny | undefined => {
+export function normalizeEventResultType(value: unknown): z.ZodTypeAny | undefined {
   if (value === undefined || value === null) {
     return undefined
   }
@@ -130,5 +119,8 @@ export const normalizeEventResultType = (value: EventResultTypeInput): z.ZodType
   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)
 }

package/dist/cjs/CoreClient.d.ts

@@ -1,167 +0,0 @@
-export declare const CORE_PROTOCOL_VERSION = 1;
-export type ProtocolEnvelope<TMessage = Record<string, unknown>> = {
-    protocol_version: number;
-    session_id: string;
-    request_id?: string;
-    last_patch_seq?: number;
-    message: TMessage;
-};
-export type CoreMessage = Record<string, unknown> & {
-    type?: string;
-};
-type FastCompletedHandlerOptions = {
-    result_is_event_reference?: boolean;
-    process_route_after?: boolean;
-    process_available_after?: boolean;
-    compact_response?: boolean;
-    include_patches?: boolean;
-};
-type ForwardEventOptions = {
-    parent_invocation_id?: string | null;
-    block_parent_completion?: boolean;
-    pause_parent_route?: boolean;
-    event_timeout?: number | null;
-    event_slow_timeout?: number | null;
-    event_concurrency?: string | null;
-    event_handler_timeout?: number | null;
-    event_handler_slow_timeout?: number | null;
-    event_handler_concurrency?: string | null;
-    event_handler_completion?: string | null;
-    event_blocks_parent_completion?: boolean | null;
-};
-export declare class RustCoreClient {
-    private static shared_named_clients;
-    private static cleanup_registered;
-    static acquireNamed(bus_name: string): RustCoreClient;
-    static releaseNamed(client: RustCoreClient, options?: {
-        stopCore?: boolean;
-    }): void;
-    private static registerProcessCleanup;
-    static stopIdleNamedClients(): void;
-    readonly session_id: string;
-    readonly command: string;
-    readonly args: string[];
-    readonly socket_path: string;
-    private process;
-    private rpc;
-    private last_patch_seq;
-    private request_seq;
-    private release_transport_timer;
-    private readonly kill_process_on_close;
-    private readonly owns_socket_path;
-    private readonly bus_name;
-    private readonly session_id_bytes;
-    constructor(options?: {
-        command?: string;
-        args?: string[];
-        session_id?: string;
-        socket_path?: string;
-        bus_name?: string;
-    });
-    request(message: CoreMessage, options?: {
-        includePatches?: boolean;
-        advancePatchSeq?: boolean;
-        advancePatchSeqWhenNoPatches?: boolean;
-    }): ProtocolEnvelope<CoreMessage>[];
-    private requestOnce;
-    requestMessages(message: CoreMessage, options?: {
-        includePatches?: boolean;
-        advancePatchSeq?: boolean;
-        advancePatchSeqWhenNoPatches?: boolean;
-    }): CoreMessage[];
-    getPatchSeq(): number;
-    setPatchSeq(last_patch_seq: number): void;
-    filterUnseenPatchMessages(messages: CoreMessage[]): CoreMessage[];
-    ackPatchMessages(messages: CoreMessage | CoreMessage[]): void;
-    registerBus(bus: Record<string, unknown>): CoreMessage[];
-    unregisterBus(bus_id: string): CoreMessage[];
-    registerHandler(handler: Record<string, unknown>): CoreMessage[];
-    importBusSnapshot(snapshot: {
-        bus: Record<string, unknown>;
-        handlers: Record<string, unknown>[];
-        events: Record<string, unknown>[];
-        pending_event_ids: string[];
-    }): CoreMessage[];
-    unregisterHandler(handler_id: string): CoreMessage[];
-    disconnectHost(host_id?: string | null): CoreMessage[];
-    closeSession(): void;
-    stopCore(): CoreMessage[];
-    emitEvent(event: Record<string, unknown>, bus_id: string, defer_start?: boolean, compact_response?: boolean, options?: {
-        parent_invocation_id?: string | null;
-        block_parent_completion?: boolean;
-        pause_parent_route?: boolean;
-    }): CoreMessage[];
-    forwardEvent(event_id: string, bus_id: string, defer_start?: boolean, compact_response?: boolean, options?: ForwardEventOptions): CoreMessage[];
-    updateEventOptions(event_id: string, options: {
-        event_handler_completion?: string | null;
-        event_blocks_parent_completion?: boolean | null;
-    }): CoreMessage[];
-    processNextRoute(bus_id: string, limit?: number | null, compact_response?: boolean): CoreMessage[];
-    waitInvocations(bus_id?: string | null, limit?: number | null): CoreMessage[];
-    waitEventCompleted(event_id: string): CoreMessage[];
-    waitEventEmitted(bus_id: string, event_pattern?: string, seen_event_ids?: string[], after_event_id?: string | null, after_created_at?: string | null): CoreMessage[];
-    waitBusIdle(bus_id: string, timeout?: number | null): boolean;
-    processRoute(route_id: string, limit?: number | null, compact_response?: boolean): CoreMessage[];
-    awaitEvent(event_id: string, parent_invocation_id?: string | null): CoreMessage[];
-    queueJumpEvent(event_id: string, parent_invocation_id: string, block_parent_completion?: boolean, pause_parent_route?: boolean): CoreMessage[];
-    getEvent(event_id: string): Record<string, unknown> | null;
-    listEvents(event_pattern?: string, limit?: number | null, bus_id?: string | null): Record<string, unknown>[];
-    listEventIds(event_pattern?: string, limit?: number | null, bus_id?: string | null, statuses?: string[] | null): string[];
-    listPendingEventIds(bus_id: string): string[];
-    completeHandler(invocation: Record<string, unknown>, value: unknown, options?: FastCompletedHandlerOptions): CoreMessage[];
-    completeHandlerNoPatches(invocation: Record<string, unknown>, value: unknown, options?: FastCompletedHandlerOptions): CoreMessage[];
-    private requestFastCompletedHandler;
-    private requestFastRegisterHandler;
-    private requestFastUnregisterHandler;
-    private requestFastQueueJumpEvent;
-    private waitFastCoreAck;
-    private waitFastCoreMessages;
-    private readFastPatchSeq;
-    private requiredString;
-    private requiredUint64;
-    completeHandlerOutcomes(outcomes: Record<string, unknown>[], options?: {
-        compact_response?: boolean;
-    }): CoreMessage[];
-    completedHandlerOutcome(value: unknown, result_is_event_reference?: boolean): CoreMessage;
-    handlerOutcomeRecord(invocation: Record<string, unknown>, outcome: CoreMessage, options?: {
-        process_available_after?: boolean;
-    }): CoreMessage;
-    errorHandler(invocation: Record<string, unknown>, error: unknown, options?: {
-        process_route_after?: boolean;
-        process_available_after?: boolean;
-        compact_response?: boolean;
-    }): CoreMessage[];
-    erroredHandlerOutcome(error: unknown): CoreMessage;
-    close(): void;
-    closeTransportOnly(options?: {
-        closeSession?: boolean;
-    }): void;
-    disconnect(): void;
-    stop(): void;
-    private cleanupFailedSpawn;
-    private connect;
-    private tryConnect;
-    private connectNamedBus;
-    private requestNamedSession;
-    private requestNamedStop;
-    private waitForNamedDaemonStopped;
-    private ensureNamedDaemon;
-    private coreProcessEnv;
-    private ensureRpc;
-    private configureRpc;
-    private closeTransport;
-    private cleanupOwnedSocketPath;
-    releaseTransportSoon(): void;
-    private sendCloseSession;
-}
-export declare const defaultCoreCommand: (socket_path: string, options?: {
-    daemon?: boolean;
-}) => {
-    command: string;
-    args: string[];
-};
-export declare const stableCoreSocketPath: (_bus_name: string) => string;
-export declare const coreNamespace: () => string;
-export declare const stableCoreSessionSocketPath: (bus_name: string) => string;
-export declare const namedCoreLockPath: (socket_path: string) => string;
-export {};