abxbus 2.5.4 → 2.5.9

package/dist/cjs/events_suck.d.ts

@@ -1,28 +1,21 @@
 import { EventBus } from './EventBus.js';
 import { BaseEvent } from './BaseEvent.js';
 import type { EventClass, EventResultType } from './types.js';
-type EventMap = Record<string, EventClass<BaseEvent>>;
-type AnyFn = (...args: any[]) => any;
-type FunctionMap = Record<string, AnyFn>;
+type EventMap = Record<string, EventClass<BaseEvent, never>>;
+type FunctionMap = Record<string, (...args: never[]) => unknown>;
 type ExtraDict = Record<string, unknown>;
-type EventFieldsFromFn<TFunc extends AnyFn> = Parameters<TFunc> extends [infer TArg] ? (TArg extends Record<string, unknown> ? TArg : ExtraDict) : ExtraDict;
-type GeneratedEvent<TFunc extends AnyFn> = {
-    (data: EventFieldsFromFn<TFunc> & ExtraDict): BaseEvent & EventFieldsFromFn<TFunc> & {
-        __event_result_type__?: Awaited<ReturnType<TFunc>>;
-    };
-    new (data: EventFieldsFromFn<TFunc> & ExtraDict): BaseEvent & EventFieldsFromFn<TFunc> & {
-        __event_result_type__?: Awaited<ReturnType<TFunc>>;
-    };
-    event_type?: string;
+type EventFieldsFromFn<TFunc extends FunctionMap[string]> = Parameters<TFunc> extends [infer TArg, ...unknown[]] ? (TArg extends Record<string, unknown> ? TArg : ExtraDict) : ExtraDict;
+type EventFromFn<TFunc extends FunctionMap[string]> = BaseEvent & EventFieldsFromFn<TFunc> & {
+    __event_result_type__?: Awaited<ReturnType<TFunc>>;
 };
 export type GeneratedEvents<TEvents extends FunctionMap> = {
     by_name: {
-        [K in keyof TEvents]: GeneratedEvent<TEvents[K]>;
+        [K in keyof TEvents]: EventClass<EventFromFn<TEvents[K]>, EventFieldsFromFn<TEvents[K]> & ExtraDict>;
     };
 } & {
-    [K in keyof TEvents]: GeneratedEvent<TEvents[K]>;
+    [K in keyof TEvents]: EventClass<EventFromFn<TEvents[K]>, EventFieldsFromFn<TEvents[K]> & ExtraDict>;
 };
-type EventInit<TEventClass extends EventClass<BaseEvent>> = ConstructorParameters<TEventClass> extends [infer TInit, ...unknown[]] ? TInit : never;
+type EventInit<TEventClass extends EventClass<BaseEvent>> = [ConstructorParameters<TEventClass>[0]] extends [undefined] ? {} : NonNullable<ConstructorParameters<TEventClass>[0]>;
 type EventMethodArgs<TEventClass extends EventClass<BaseEvent>> = {} extends EventInit<TEventClass> ? [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/cjs/events_suck.js

@@ -47,7 +47,7 @@ const wrap = (class_name, methods) => {
     Object.defineProperty(WrappedClient.prototype, method_name, {
       value: async function(init, extra) {
         const payload = { ...init ?? {}, ...extra ?? {} };
-        return await this.bus.emit(new EventCtor(payload)).now({ first_result: true }).eventResult();
+        return await this.bus.emit(EventCtor(payload)).now({ first_result: true }).eventResult();
       },
       writable: true,
       configurable: true

package/dist/cjs/events_suck.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/events_suck.ts"],
-  "sourcesContent": ["import { EventBus } from './EventBus.js'\nimport { BaseEvent } from './BaseEvent.js'\n\nimport type { EventClass, EventResultType } from './types.js'\n\ntype EventMap = Record<string, EventClass<BaseEvent>>\ntype AnyFn = (...args: any[]) => any\ntype FunctionMap = Record<string, AnyFn>\ntype ExtraDict = Record<string, unknown>\n\ntype EventFieldsFromFn<TFunc extends AnyFn> =\n  Parameters<TFunc> extends [infer TArg] ? (TArg extends Record<string, unknown> ? TArg : ExtraDict) : ExtraDict\n\ntype GeneratedEvent<TFunc extends AnyFn> = {\n  (\n    data: EventFieldsFromFn<TFunc> & ExtraDict\n  ): BaseEvent & EventFieldsFromFn<TFunc> & { __event_result_type__?: Awaited<ReturnType<TFunc>> }\n  new (\n    data: EventFieldsFromFn<TFunc> & ExtraDict\n  ): BaseEvent & EventFieldsFromFn<TFunc> & { __event_result_type__?: Awaited<ReturnType<TFunc>> }\n  event_type?: string\n}\n\nexport type GeneratedEvents<TEvents extends FunctionMap> = {\n  by_name: { [K in keyof TEvents]: GeneratedEvent<TEvents[K]> }\n} & {\n  [K in keyof TEvents]: GeneratedEvent<TEvents[K]>\n}\n\ntype EventInit<TEventClass extends EventClass<BaseEvent>> =\n  ConstructorParameters<TEventClass> extends [infer TInit, ...unknown[]] ? TInit : never\n\ntype EventMethodArgs<TEventClass extends EventClass<BaseEvent>> =\n  {} extends EventInit<TEventClass>\n    ? [init?: EventInit<TEventClass>, extra?: Record<string, unknown>]\n    : [init: EventInit<TEventClass>, extra?: Record<string, unknown>]\n\ntype EventMethodResult<TEventClass extends EventClass<BaseEvent>> = EventResultType<InstanceType<TEventClass>> | undefined\n\nexport type EventsSuckClient<TEvents extends EventMap> = {\n  bus: EventBus\n} & {\n  [K in keyof TEvents]: (...args: EventMethodArgs<TEvents[K]>) => Promise<EventMethodResult<TEvents[K]>>\n}\n\nexport type EventsSuckClientClass<TEvents extends EventMap> = new (bus?: EventBus) => EventsSuckClient<TEvents>\n\ntype DynamicWrappedClient = {\n  bus: EventBus\n} & Record<string, (...args: unknown[]) => Promise<unknown>>\n\nexport const make_events = <TEvents extends FunctionMap>(events: TEvents): GeneratedEvents<TEvents> => {\n  const by_name = {} as { [K in keyof TEvents]: GeneratedEvent<TEvents[K]> }\n  for (const [event_name] of Object.entries(events) as Array<[keyof TEvents, TEvents[keyof TEvents]]>) {\n    if (!/^[A-Za-z_$][\\w$]*$/.test(String(event_name))) {\n      throw new Error(`Invalid event name: ${String(event_name)}`)\n    }\n    by_name[event_name] = BaseEvent.extend(String(event_name), {}) as unknown as GeneratedEvent<TEvents[keyof TEvents]>\n  }\n  return Object.assign({ by_name }, by_name) as GeneratedEvents<TEvents>\n}\n\nexport const wrap = <TEvents extends EventMap>(class_name: string, methods: TEvents): EventsSuckClientClass<TEvents> => {\n  class WrappedClient {\n    bus: EventBus\n\n    constructor(bus?: EventBus) {\n      this.bus = bus ?? new EventBus(`${class_name}Bus`)\n    }\n  }\n\n  Object.defineProperty(WrappedClient, 'name', { value: class_name })\n\n  for (const [method_name, EventCtor] of Object.entries(methods)) {\n    Object.defineProperty(WrappedClient.prototype, method_name, {\n      value: async function (this: DynamicWrappedClient, init?: Record<string, unknown>, extra?: Record<string, unknown>) {\n        const payload = { ...(init ?? {}), ...(extra ?? {}) }\n        return await this.bus.emit(new EventCtor(payload)).now({ first_result: true }).eventResult()\n      },\n      writable: true,\n      configurable: true,\n    })\n  }\n\n  return WrappedClient as unknown as EventsSuckClientClass<TEvents>\n}\n\n// Intentionally no make_event()/make_handler() helpers in TypeScript.\n// Prefer the explicit inline pattern:\n//   const FooCreateEvent = BaseEvent.extend('FooCreateEvent', {\n//     id: z.string().nullable().optional(),\n//     name: z.string(),\n//     age: z.number(),\n//   })\n//   bus.on(FooCreateEvent, ({ id, name, age, ...extra }) => impl.create(id, { name, age }))\nexport const events_suck = { make_events, wrap } as const\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAAyB;AACzB,uBAA0B;AAkDnB,MAAM,cAAc,CAA8B,WAA8C;AACrG,QAAM,UAAU,CAAC;AACjB,aAAW,CAAC,UAAU,KAAK,OAAO,QAAQ,MAAM,GAAqD;AACnG,QAAI,CAAC,qBAAqB,KAAK,OAAO,UAAU,CAAC,GAAG;AAClD,YAAM,IAAI,MAAM,uBAAuB,OAAO,UAAU,CAAC,EAAE;AAAA,IAC7D;AACA,YAAQ,UAAU,IAAI,2BAAU,OAAO,OAAO,UAAU,GAAG,CAAC,CAAC;AAAA,EAC/D;AACA,SAAO,OAAO,OAAO,EAAE,QAAQ,GAAG,OAAO;AAC3C;AAEO,MAAM,OAAO,CAA2B,YAAoB,YAAqD;AAAA,EACtH,MAAM,cAAc;AAAA,IAClB;AAAA,IAEA,YAAY,KAAgB;AAC1B,WAAK,MAAM,OAAO,IAAI,yBAAS,GAAG,UAAU,KAAK;AAAA,IACnD;AAAA,EACF;AAEA,SAAO,eAAe,eAAe,QAAQ,EAAE,OAAO,WAAW,CAAC;AAElE,aAAW,CAAC,aAAa,SAAS,KAAK,OAAO,QAAQ,OAAO,GAAG;AAC9D,WAAO,eAAe,cAAc,WAAW,aAAa;AAAA,MAC1D,OAAO,eAA4C,MAAgC,OAAiC;AAClH,cAAM,UAAU,EAAE,GAAI,QAAQ,CAAC,GAAI,GAAI,SAAS,CAAC,EAAG;AACpD,eAAO,MAAM,KAAK,IAAI,KAAK,IAAI,UAAU,OAAO,CAAC,EAAE,IAAI,EAAE,cAAc,KAAK,CAAC,EAAE,YAAY;AAAA,MAC7F;AAAA,MACA,UAAU;AAAA,MACV,cAAc;AAAA,IAChB,CAAC;AAAA,EACH;AAEA,SAAO;AACT;AAUO,MAAM,cAAc,EAAE,aAAa,KAAK;",
+  "sourcesContent": ["import { EventBus } from './EventBus.js'\nimport { BaseEvent } from './BaseEvent.js'\n\nimport type { EventClass, EventResultType } from './types.js'\n\ntype EventMap = Record<string, EventClass<BaseEvent, never>>\ntype FunctionMap = Record<string, (...args: never[]) => unknown>\ntype ExtraDict = Record<string, unknown>\n\ntype EventFieldsFromFn<TFunc extends FunctionMap[string]> =\n  Parameters<TFunc> extends [infer TArg, ...unknown[]] ? (TArg extends Record<string, unknown> ? TArg : ExtraDict) : ExtraDict\n\ntype EventFromFn<TFunc extends FunctionMap[string]> = BaseEvent &\n  EventFieldsFromFn<TFunc> & {\n    __event_result_type__?: Awaited<ReturnType<TFunc>>\n  }\n\nexport type GeneratedEvents<TEvents extends FunctionMap> = {\n  by_name: { [K in keyof TEvents]: EventClass<EventFromFn<TEvents[K]>, EventFieldsFromFn<TEvents[K]> & ExtraDict> }\n} & {\n  [K in keyof TEvents]: EventClass<EventFromFn<TEvents[K]>, EventFieldsFromFn<TEvents[K]> & ExtraDict>\n}\n\ntype EventInit<TEventClass extends EventClass<BaseEvent>> = [ConstructorParameters<TEventClass>[0]] extends [undefined]\n  ? {}\n  : NonNullable<ConstructorParameters<TEventClass>[0]>\n\ntype EventMethodArgs<TEventClass extends EventClass<BaseEvent>> =\n  {} extends EventInit<TEventClass>\n    ? [init?: EventInit<TEventClass>, extra?: Record<string, unknown>]\n    : [init: EventInit<TEventClass>, extra?: Record<string, unknown>]\n\ntype EventMethodResult<TEventClass extends EventClass<BaseEvent>> = EventResultType<InstanceType<TEventClass>> | undefined\n\nexport type EventsSuckClient<TEvents extends EventMap> = {\n  bus: EventBus\n} & {\n  [K in keyof TEvents]: (...args: EventMethodArgs<TEvents[K]>) => Promise<EventMethodResult<TEvents[K]>>\n}\n\nexport type EventsSuckClientClass<TEvents extends EventMap> = new (bus?: EventBus) => EventsSuckClient<TEvents>\n\ntype DynamicWrappedClient = {\n  bus: EventBus\n} & Record<string, (...args: unknown[]) => Promise<unknown>>\n\nexport const make_events = <TEvents extends FunctionMap>(events: TEvents): GeneratedEvents<TEvents> => {\n  const by_name = {} as GeneratedEvents<TEvents>['by_name']\n  for (const [event_name] of Object.entries(events) as Array<[keyof TEvents, TEvents[keyof TEvents]]>) {\n    if (!/^[A-Za-z_$][\\w$]*$/.test(String(event_name))) {\n      throw new Error(`Invalid event name: ${String(event_name)}`)\n    }\n    by_name[event_name] = BaseEvent.extend(String(event_name), {}) as unknown as GeneratedEvents<TEvents>['by_name'][typeof event_name]\n  }\n  return Object.assign({ by_name }, by_name) as GeneratedEvents<TEvents>\n}\n\nexport const wrap = <TEvents extends EventMap>(class_name: string, methods: TEvents): EventsSuckClientClass<TEvents> => {\n  class WrappedClient {\n    bus: EventBus\n\n    constructor(bus?: EventBus) {\n      this.bus = bus ?? new EventBus(`${class_name}Bus`)\n    }\n  }\n\n  Object.defineProperty(WrappedClient, 'name', { value: class_name })\n\n  for (const [method_name, EventCtor] of Object.entries(methods)) {\n    Object.defineProperty(WrappedClient.prototype, method_name, {\n      value: async function (this: DynamicWrappedClient, init?: Record<string, unknown>, extra?: Record<string, unknown>) {\n        const payload = { ...(init ?? {}), ...(extra ?? {}) }\n        return await this.bus\n          .emit((EventCtor as EventClass<BaseEvent, Record<string, unknown>>)(payload))\n          .now({ first_result: true })\n          .eventResult()\n      },\n      writable: true,\n      configurable: true,\n    })\n  }\n\n  return WrappedClient as unknown as EventsSuckClientClass<TEvents>\n}\n\n// Intentionally no make_event()/make_handler() helpers in TypeScript.\n// Prefer the explicit inline pattern:\n//   const FooCreateEvent = BaseEvent.extend('FooCreateEvent', {\n//     id: z.string().nullable().optional(),\n//     name: z.string(),\n//     age: z.number(),\n//   })\n//   bus.on(FooCreateEvent, ({ id, name, age, ...extra }) => impl.create(id, { name, age }))\nexport const events_suck = { make_events, wrap } as const\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAAyB;AACzB,uBAA0B;AA6CnB,MAAM,cAAc,CAA8B,WAA8C;AACrG,QAAM,UAAU,CAAC;AACjB,aAAW,CAAC,UAAU,KAAK,OAAO,QAAQ,MAAM,GAAqD;AACnG,QAAI,CAAC,qBAAqB,KAAK,OAAO,UAAU,CAAC,GAAG;AAClD,YAAM,IAAI,MAAM,uBAAuB,OAAO,UAAU,CAAC,EAAE;AAAA,IAC7D;AACA,YAAQ,UAAU,IAAI,2BAAU,OAAO,OAAO,UAAU,GAAG,CAAC,CAAC;AAAA,EAC/D;AACA,SAAO,OAAO,OAAO,EAAE,QAAQ,GAAG,OAAO;AAC3C;AAEO,MAAM,OAAO,CAA2B,YAAoB,YAAqD;AAAA,EACtH,MAAM,cAAc;AAAA,IAClB;AAAA,IAEA,YAAY,KAAgB;AAC1B,WAAK,MAAM,OAAO,IAAI,yBAAS,GAAG,UAAU,KAAK;AAAA,IACnD;AAAA,EACF;AAEA,SAAO,eAAe,eAAe,QAAQ,EAAE,OAAO,WAAW,CAAC;AAElE,aAAW,CAAC,aAAa,SAAS,KAAK,OAAO,QAAQ,OAAO,GAAG;AAC9D,WAAO,eAAe,cAAc,WAAW,aAAa;AAAA,MAC1D,OAAO,eAA4C,MAAgC,OAAiC;AAClH,cAAM,UAAU,EAAE,GAAI,QAAQ,CAAC,GAAI,GAAI,SAAS,CAAC,EAAG;AACpD,eAAO,MAAM,KAAK,IACf,KAAM,UAA6D,OAAO,CAAC,EAC3E,IAAI,EAAE,cAAc,KAAK,CAAC,EAC1B,YAAY;AAAA,MACjB;AAAA,MACA,UAAU;AAAA,MACV,cAAc;AAAA,IAChB,CAAC;AAAA,EACH;AAEA,SAAO;AACT;AAUO,MAAM,cAAc,EAAE,aAAa,KAAK;",
   "names": []
 }

package/dist/cjs/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/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/retry.d.ts

@@ -19,6 +19,8 @@ export interface RetryOptions {
     retry_on_errors?: Array<(new (...args: any[]) => Error) | string | RegExp>;
     /** Per-attempt timeout in seconds. Default: undefined (no per-attempt timeout) */
     timeout?: number | null;
+    /** Emit a warning when a decorated call exceeds this many seconds. Default: undefined (disabled) */
+    slow_timeout?: number | null;
     /** Maximum concurrent executions sharing this semaphore. Default: undefined (no concurrency limit) */
     semaphore_limit?: number | null;
     /** Semaphore identifier. Functions with the same name share the same concurrency slot pool. Default: function name.

package/dist/cjs/retry.js

@@ -28,6 +28,8 @@ var import_async_context = require("./async_context.js");
 var import_optional_deps = require("./optional_deps.js");
 const MULTIPROCESS_SEMAPHORE_DIRNAME = "browser_use_semaphores";
 const MULTIPROCESS_STALE_LOCK_MS = 5 * 60 * 1e3;
+const RETRY_SLOW_WARNING_THROTTLE_MS = 2e3;
+const RETRY_SLOW_WARNING_ARGS_MAX_LENGTH = 80;
 let multiprocess_fallback_reason_logged = null;
 class RetryTimeoutError extends Error {
   timeout_seconds;
@@ -133,16 +135,20 @@ function retry(options = {}) {
     retry_backoff_factor = 1,
     retry_on_errors,
     timeout,
+    slow_timeout,
     semaphore_limit,
     semaphore_name: semaphore_name_option,
     semaphore_lax = true,
     semaphore_scope = "global",
     semaphore_timeout
   } = options;
-  const decorateFunction = (target, _context) => {
-    const fn_name = target.name || _context?.name || "anonymous";
+  const decorateFunction = (target, _context, owner_name) => {
+    const base_fn_name = target.name || _context?.name || "anonymous";
+    let fn_name = owner_name ? `${owner_name}.${base_fn_name}` : base_fn_name;
     const effective_max_attempts = Math.max(1, max_attempts);
     const effective_retry_after = Math.max(0, retry_after);
+    const effective_slow_timeout_ms = slow_timeout != null && slow_timeout > 0 ? slow_timeout * 1e3 : null;
+    let last_slow_warning_at = 0;
     const shouldRetry = (error) => {
       if (!retry_on_errors || retry_on_errors.length === 0) return true;
       return retry_on_errors.some(
@@ -161,6 +167,13 @@ function retry(options = {}) {
         sleepSync(delay_seconds * 1e3);
       }
     };
+    const emitSlowWarningIfDue = (args, start_time) => {
+      if (effective_slow_timeout_ms == null) return;
+      const now = Date.now();
+      if (now - last_slow_warning_at < RETRY_SLOW_WARNING_THROTTLE_MS) return;
+      last_slow_warning_at = now;
+      console.warn(`Warning: ${fn_name}(${formatRetrySlowWarningArgs(args)}) slow (${((now - start_time) / 1e3).toFixed(1)}s)`);
+    };
     const runRetryLoopFromThenable = async (this_arg, args, first_thenable, first_attempt) => {
       let current_result = first_thenable;
       for (let attempt = first_attempt; attempt <= effective_max_attempts; attempt++) {
@@ -240,20 +253,35 @@ function retry(options = {}) {
         new_held.add(scoped_key);
       }
       const runRetryLoop = async () => {
-        for (let attempt = 1; attempt <= effective_max_attempts; attempt++) {
-          try {
-            if (timeout != null && timeout > 0) {
-              return await _runWithTimeout(() => Promise.resolve(target.apply(this, args)), timeout * 1e3, attempt);
-            } else {
-              return await Promise.resolve(target.apply(this, args));
+        const call_started_at = Date.now();
+        const warning_args = [...args];
+        const slow_warning_timer = effective_slow_timeout_ms == null ? null : setTimeout(() => emitSlowWarningIfDue(warning_args, call_started_at), effective_slow_timeout_ms);
+        const finishSlowWarning = () => {
+          if (slow_warning_timer !== null) {
+            clearTimeout(slow_warning_timer);
+          }
+          if (effective_slow_timeout_ms != null && Date.now() - call_started_at >= effective_slow_timeout_ms) {
+            emitSlowWarningIfDue(warning_args, call_started_at);
+          }
+        };
+        try {
+          for (let attempt = 1; attempt <= effective_max_attempts; attempt++) {
+            try {
+              if (timeout != null && timeout > 0) {
+                return await _runWithTimeout(() => Promise.resolve(target.apply(this, args)), timeout * 1e3, attempt);
+              } else {
+                return await Promise.resolve(target.apply(this, args));
+              }
+            } catch (error) {
+              if (!shouldRetry(error)) throw error;
+              if (attempt >= effective_max_attempts) throw error;
+              await asyncRetryDelay(attempt);
             }
-          } catch (error) {
-            if (!shouldRetry(error)) throw error;
-            if (attempt >= effective_max_attempts) throw error;
-            await asyncRetryDelay(attempt);
           }
+          throw new Error(`retry(${fn_name}): unexpected end of retry loop`);
+        } finally {
+          finishSlowWarning();
         }
-        throw new Error(`retry(${fn_name}): unexpected end of retry loop`);
       };
       try {
         return await runWithHeldSemaphores(new_held, runRetryLoop);
@@ -303,27 +331,48 @@ function retry(options = {}) {
         }
       };
       const runRetryLoop = () => {
-        for (let attempt = 1; attempt <= effective_max_attempts; attempt++) {
-          const attempt_started_at = Date.now();
-          try {
-            const result = target.apply(this, args);
-            if (isThenable(result)) {
-              return runRetryLoopFromThenable(this, args, result, attempt);
-            }
-            if (timeout != null && timeout > 0 && Date.now() - attempt_started_at > timeout * 1e3) {
-              throw new RetryTimeoutError(`Timed out after ${timeout}s (attempt ${attempt})`, {
-                timeout_seconds: timeout,
-                attempt
-              });
+        const call_started_at = Date.now();
+        const warning_args = [...args];
+        const slow_warning_timer = effective_slow_timeout_ms == null ? null : setTimeout(() => emitSlowWarningIfDue(warning_args, call_started_at), effective_slow_timeout_ms);
+        const finishSlowWarning = () => {
+          if (slow_warning_timer !== null) {
+            clearTimeout(slow_warning_timer);
+          }
+          if (effective_slow_timeout_ms != null && Date.now() - call_started_at >= effective_slow_timeout_ms) {
+            emitSlowWarningIfDue(warning_args, call_started_at);
+          }
+        };
+        let finish_on_return = true;
+        try {
+          for (let attempt = 1; attempt <= effective_max_attempts; attempt++) {
+            const attempt_started_at = Date.now();
+            try {
+              const result = target.apply(this, args);
+              if (isThenable(result)) {
+                finish_on_return = false;
+                return runRetryLoopFromThenable(this, args, result, attempt).finally(finishSlowWarning);
+              }
+              if (timeout != null && timeout > 0 && Date.now() - attempt_started_at > timeout * 1e3) {
+                throw new RetryTimeoutError(`Timed out after ${timeout}s (attempt ${attempt})`, {
+                  timeout_seconds: timeout,
+                  attempt
+                });
+              }
+              return result;
+            } catch (error) {
+              if (!shouldRetry(error)) throw error;
+              if (attempt >= effective_max_attempts) {
+                throw error;
+              }
+              syncRetryDelay(attempt);
             }
-            return result;
-          } catch (error) {
-            if (!shouldRetry(error)) throw error;
-            if (attempt >= effective_max_attempts) throw error;
-            syncRetryDelay(attempt);
+          }
+          throw new Error(`retry(${fn_name}): unexpected end of retry loop`);
+        } finally {
+          if (finish_on_return) {
+            finishSlowWarning();
           }
         }
-        throw new Error(`retry(${fn_name}): unexpected end of retry loop`);
       };
       try {
         const result = runWithHeldSemaphores(new_held, runRetryLoop);
@@ -341,9 +390,10 @@ function retry(options = {}) {
     Object.defineProperty(retryWrapper, "name", { value: fn_name, configurable: true });
     if (_context?.kind === "method" && typeof _context.addInitializer === "function") {
       _context.addInitializer(function() {
-        const owner_name = findDecoratedMethodOwnerName(this, _context, retryWrapper);
-        if (owner_name) {
-          Object.defineProperty(retryWrapper, "name", { value: `${owner_name}.${fn_name}`, configurable: true });
+        const owner_name2 = findDecoratedMethodOwnerName(this, _context, retryWrapper);
+        if (owner_name2) {
+          fn_name = `${owner_name2}.${target.name || _context.name || "anonymous"}`;
+          Object.defineProperty(retryWrapper, "name", { value: fn_name, configurable: true });
         }
       });
     }
@@ -351,7 +401,8 @@ function retry(options = {}) {
   };
   function decorator(target, context_or_property_key, descriptor) {
     if (descriptor?.value && typeof descriptor.value === "function") {
-      descriptor.value = decorateFunction(descriptor.value);
+      const owner_name = target && (typeof target === "object" || typeof target === "function") ? typeof target === "function" ? target.name : target.constructor?.name : null;
+      descriptor.value = decorateFunction(descriptor.value, void 0, owner_name);
       return descriptor;
     }
     if (typeof target === "function") {
@@ -398,6 +449,30 @@ function isAsyncFunction(fn) {
 function isThenable(value) {
   return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
 }
+function formatRetrySlowWarningArgs(args) {
+  const preview = args.map(formatRetrySlowWarningValue).join(", ");
+  if (preview.length > RETRY_SLOW_WARNING_ARGS_MAX_LENGTH) {
+    return `${preview.slice(0, RETRY_SLOW_WARNING_ARGS_MAX_LENGTH - 3).replace(/,?\s*$/, "")}...`;
+  }
+  return preview;
+}
+function formatRetrySlowWarningValue(value) {
+  let text;
+  if (typeof value === "string") {
+    text = value;
+  } else if (value === null || value === void 0) {
+    text = String(value);
+  } else if (typeof value === "object") {
+    try {
+      text = JSON.stringify(value);
+    } catch {
+      text = String(value);
+    }
+  } else {
+    text = String(value);
+  }
+  return text.replace(/['"]/g, "").slice(0, 3);
+}
 async function acquireWithTimeout(semaphore, timeout_ms) {
   return new Promise((resolve) => {
     let settled = false;