abxbus 2.4.1

package/dist/cjs/helpers.js

@@ -0,0 +1,84 @@
+"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 helpers_exports = {};
+__export(helpers_exports, {
+  monotonicDatetime: () => monotonicDatetime
+});
+module.exports = __toCommonJS(helpers_exports);
+const MONOTONIC_DATETIME_REGEX = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?(Z|[+-]\d{2}:\d{2})$/;
+const MONOTONIC_DATETIME_LENGTH = 30;
+const NS_PER_MS = 1000000n;
+const NS_PER_SECOND = 1000000000n;
+const has_performance_now = typeof performance !== "undefined" && typeof performance.now === "function";
+const monotonic_clock_anchor_ms = has_performance_now ? performance.now() : 0;
+const monotonic_epoch_anchor_ns = BigInt(Date.now()) * NS_PER_MS;
+let last_monotonic_datetime_ns = monotonic_epoch_anchor_ns;
+function assertYearRange(date, context) {
+  const year = date.getUTCFullYear();
+  if (year <= 1990 || year >= 2500) {
+    throw new Error(`${context} year must be >1990 and <2500, got ${year}`);
+  }
+}
+function formatEpochNs(epoch_ns) {
+  const epoch_ms = Number(epoch_ns / NS_PER_MS);
+  const date = new Date(epoch_ms);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Failed to format datetime from epoch ns: ${epoch_ns.toString()}`);
+  }
+  assertYearRange(date, "monotonicDatetime()");
+  const base = date.toISOString().slice(0, 19);
+  const fraction = (epoch_ns % NS_PER_SECOND).toString().padStart(9, "0");
+  const normalized = `${base}.${fraction}Z`;
+  if (normalized.length !== MONOTONIC_DATETIME_LENGTH) {
+    throw new Error(`Expected canonical datetime length ${MONOTONIC_DATETIME_LENGTH}, got ${normalized.length}: ${normalized}`);
+  }
+  return normalized;
+}
+function monotonicDatetime(isostring) {
+  if (isostring !== void 0) {
+    if (typeof isostring !== "string") {
+      throw new Error(`monotonicDatetime(isostring?) requires string | undefined, got ${typeof isostring}`);
+    }
+    const match = MONOTONIC_DATETIME_REGEX.exec(isostring);
+    if (!match) {
+      throw new Error(`Invalid ISO datetime: ${isostring}`);
+    }
+    const parsed = new Date(isostring);
+    if (Number.isNaN(parsed.getTime())) {
+      throw new Error(`Invalid ISO datetime: ${isostring}`);
+    }
+    assertYearRange(parsed, "monotonicDatetime(isostring)");
+    const base = parsed.toISOString().slice(0, 19);
+    const fraction = (match[7] ?? "").padEnd(9, "0");
+    const normalized = `${base}.${fraction}Z`;
+    if (normalized.length !== MONOTONIC_DATETIME_LENGTH) {
+      throw new Error(`Expected canonical datetime length ${MONOTONIC_DATETIME_LENGTH}, got ${normalized.length}: ${normalized}`);
+    }
+    return normalized;
+  }
+  const elapsed_ms = has_performance_now ? performance.now() - monotonic_clock_anchor_ms : 0;
+  const elapsed_ns = BigInt(Math.max(0, Math.floor(elapsed_ms * 1e6)));
+  let epoch_ns = monotonic_epoch_anchor_ns + elapsed_ns;
+  if (epoch_ns <= last_monotonic_datetime_ns) {
+    epoch_ns = last_monotonic_datetime_ns + 1n;
+  }
+  last_monotonic_datetime_ns = epoch_ns;
+  return formatEpochNs(epoch_ns);
+}
+//# sourceMappingURL=helpers.js.map

package/dist/cjs/helpers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/helpers.ts"],
+  "sourcesContent": ["const MONOTONIC_DATETIME_REGEX = /^(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})(?:\\.(\\d{1,9}))?(Z|[+-]\\d{2}:\\d{2})$/\nconst MONOTONIC_DATETIME_LENGTH = 30 // YYYY-MM-DDTHH:MM:SS.fffffffffZ\nconst NS_PER_MS = 1_000_000n\nconst NS_PER_SECOND = 1_000_000_000n\n\nconst has_performance_now = typeof performance !== 'undefined' && typeof performance.now === 'function'\nconst monotonic_clock_anchor_ms = has_performance_now ? performance.now() : 0\nconst monotonic_epoch_anchor_ns = BigInt(Date.now()) * NS_PER_MS\nlet last_monotonic_datetime_ns = monotonic_epoch_anchor_ns\n\nfunction assertYearRange(date: Date, context: string): void {\n  const year = date.getUTCFullYear()\n  if (year <= 1990 || year >= 2500) {\n    throw new Error(`${context} year must be >1990 and <2500, got ${year}`)\n  }\n}\n\nfunction formatEpochNs(epoch_ns: bigint): string {\n  const epoch_ms = Number(epoch_ns / NS_PER_MS)\n  const date = new Date(epoch_ms)\n  if (Number.isNaN(date.getTime())) {\n    throw new Error(`Failed to format datetime from epoch ns: ${epoch_ns.toString()}`)\n  }\n  assertYearRange(date, 'monotonicDatetime()')\n  const base = date.toISOString().slice(0, 19)\n  const fraction = (epoch_ns % NS_PER_SECOND).toString().padStart(9, '0')\n  const normalized = `${base}.${fraction}Z`\n  if (normalized.length !== MONOTONIC_DATETIME_LENGTH) {\n    throw new Error(`Expected canonical datetime length ${MONOTONIC_DATETIME_LENGTH}, got ${normalized.length}: ${normalized}`)\n  }\n  return normalized\n}\n\nexport function monotonicDatetime(isostring?: string): string {\n  if (isostring !== undefined) {\n    if (typeof isostring !== 'string') {\n      throw new Error(`monotonicDatetime(isostring?) requires string | undefined, got ${typeof isostring}`)\n    }\n    const match = MONOTONIC_DATETIME_REGEX.exec(isostring)\n    if (!match) {\n      throw new Error(`Invalid ISO datetime: ${isostring}`)\n    }\n    const parsed = new Date(isostring)\n    if (Number.isNaN(parsed.getTime())) {\n      throw new Error(`Invalid ISO datetime: ${isostring}`)\n    }\n    assertYearRange(parsed, 'monotonicDatetime(isostring)')\n    const base = parsed.toISOString().slice(0, 19)\n    const fraction = (match[7] ?? '').padEnd(9, '0')\n    const normalized = `${base}.${fraction}Z`\n    if (normalized.length !== MONOTONIC_DATETIME_LENGTH) {\n      throw new Error(`Expected canonical datetime length ${MONOTONIC_DATETIME_LENGTH}, got ${normalized.length}: ${normalized}`)\n    }\n    return normalized\n  }\n\n  const elapsed_ms = has_performance_now ? performance.now() - monotonic_clock_anchor_ms : 0\n  const elapsed_ns = BigInt(Math.max(0, Math.floor(elapsed_ms * 1_000_000)))\n  let epoch_ns = monotonic_epoch_anchor_ns + elapsed_ns\n  if (epoch_ns <= last_monotonic_datetime_ns) {\n    epoch_ns = last_monotonic_datetime_ns + 1n\n  }\n  last_monotonic_datetime_ns = epoch_ns\n  return formatEpochNs(epoch_ns)\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAAM,2BAA2B;AACjC,MAAM,4BAA4B;AAClC,MAAM,YAAY;AAClB,MAAM,gBAAgB;AAEtB,MAAM,sBAAsB,OAAO,gBAAgB,eAAe,OAAO,YAAY,QAAQ;AAC7F,MAAM,4BAA4B,sBAAsB,YAAY,IAAI,IAAI;AAC5E,MAAM,4BAA4B,OAAO,KAAK,IAAI,CAAC,IAAI;AACvD,IAAI,6BAA6B;AAEjC,SAAS,gBAAgB,MAAY,SAAuB;AAC1D,QAAM,OAAO,KAAK,eAAe;AACjC,MAAI,QAAQ,QAAQ,QAAQ,MAAM;AAChC,UAAM,IAAI,MAAM,GAAG,OAAO,sCAAsC,IAAI,EAAE;AAAA,EACxE;AACF;AAEA,SAAS,cAAc,UAA0B;AAC/C,QAAM,WAAW,OAAO,WAAW,SAAS;AAC5C,QAAM,OAAO,IAAI,KAAK,QAAQ;AAC9B,MAAI,OAAO,MAAM,KAAK,QAAQ,CAAC,GAAG;AAChC,UAAM,IAAI,MAAM,4CAA4C,SAAS,SAAS,CAAC,EAAE;AAAA,EACnF;AACA,kBAAgB,MAAM,qBAAqB;AAC3C,QAAM,OAAO,KAAK,YAAY,EAAE,MAAM,GAAG,EAAE;AAC3C,QAAM,YAAY,WAAW,eAAe,SAAS,EAAE,SAAS,GAAG,GAAG;AACtE,QAAM,aAAa,GAAG,IAAI,IAAI,QAAQ;AACtC,MAAI,WAAW,WAAW,2BAA2B;AACnD,UAAM,IAAI,MAAM,sCAAsC,yBAAyB,SAAS,WAAW,MAAM,KAAK,UAAU,EAAE;AAAA,EAC5H;AACA,SAAO;AACT;AAEO,SAAS,kBAAkB,WAA4B;AAC5D,MAAI,cAAc,QAAW;AAC3B,QAAI,OAAO,cAAc,UAAU;AACjC,YAAM,IAAI,MAAM,kEAAkE,OAAO,SAAS,EAAE;AAAA,IACtG;AACA,UAAM,QAAQ,yBAAyB,KAAK,SAAS;AACrD,QAAI,CAAC,OAAO;AACV,YAAM,IAAI,MAAM,yBAAyB,SAAS,EAAE;AAAA,IACtD;AACA,UAAM,SAAS,IAAI,KAAK,SAAS;AACjC,QAAI,OAAO,MAAM,OAAO,QAAQ,CAAC,GAAG;AAClC,YAAM,IAAI,MAAM,yBAAyB,SAAS,EAAE;AAAA,IACtD;AACA,oBAAgB,QAAQ,8BAA8B;AACtD,UAAM,OAAO,OAAO,YAAY,EAAE,MAAM,GAAG,EAAE;AAC7C,UAAM,YAAY,MAAM,CAAC,KAAK,IAAI,OAAO,GAAG,GAAG;AAC/C,UAAM,aAAa,GAAG,IAAI,IAAI,QAAQ;AACtC,QAAI,WAAW,WAAW,2BAA2B;AACnD,YAAM,IAAI,MAAM,sCAAsC,yBAAyB,SAAS,WAAW,MAAM,KAAK,UAAU,EAAE;AAAA,IAC5H;AACA,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,sBAAsB,YAAY,IAAI,IAAI,4BAA4B;AACzF,QAAM,aAAa,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,aAAa,GAAS,CAAC,CAAC;AACzE,MAAI,WAAW,4BAA4B;AAC3C,MAAI,YAAY,4BAA4B;AAC1C,eAAW,6BAA6B;AAAA,EAC1C;AACA,+BAA6B;AAC7B,SAAO,cAAc,QAAQ;AAC/B;",
+  "names": []
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,17 @@
+export { BaseEvent, BaseEventSchema } from './base_event.js';
+export { EventHistory } from './event_history.js';
+export type { EventHistoryFindOptions, EventHistoryTrimOptions } from './event_history.js';
+export { EventResult } from './event_result.js';
+export { EventBus } from './event_bus.js';
+export type { EventBusJSON, EventBusOptions } from './event_bus.js';
+export { monotonicDatetime } from './helpers.js';
+export type { EventBusMiddleware, EventBusMiddlewareCtor, EventBusMiddlewareInput } from './middlewares.js';
+export { EventHandlerTimeoutError, EventHandlerCancelledError, EventHandlerAbortedError, EventHandlerResultSchemaError, } from './event_handler.js';
+export type { EventConcurrencyMode, EventHandlerConcurrencyMode, EventHandlerCompletionMode, EventBusInterfaceForLockManager, } from './lock_manager.js';
+export type { EventClass, EventHandlerCallable as EventHandler, EventPattern, EventStatus, FindOptions, FindWindow } from './types.js';
+export { retry, clearSemaphoreRegistry, RetryTimeoutError, SemaphoreTimeoutError } from './retry.js';
+export type { RetryOptions } from './retry.js';
+export { HTTPEventBridge, SocketEventBridge, NATSEventBridge, RedisEventBridge, PostgresEventBridge, JSONLEventBridge, SQLiteEventBridge, } from './bridges.js';
+export type { HTTPEventBridgeOptions } from './bridges.js';
+export { events_suck } from './events_suck.js';
+export type { EventsSuckClient, EventsSuckClientClass, GeneratedEvents } from './events_suck.js';

package/dist/cjs/index.js

@@ -0,0 +1,54 @@
+"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 index_exports = {};
+__export(index_exports, {
+  BaseEvent: () => import_base_event.BaseEvent,
+  BaseEventSchema: () => import_base_event.BaseEventSchema,
+  EventBus: () => import_event_bus.EventBus,
+  EventHandlerAbortedError: () => import_event_handler.EventHandlerAbortedError,
+  EventHandlerCancelledError: () => import_event_handler.EventHandlerCancelledError,
+  EventHandlerResultSchemaError: () => import_event_handler.EventHandlerResultSchemaError,
+  EventHandlerTimeoutError: () => import_event_handler.EventHandlerTimeoutError,
+  EventHistory: () => import_event_history.EventHistory,
+  EventResult: () => import_event_result.EventResult,
+  HTTPEventBridge: () => import_bridges.HTTPEventBridge,
+  JSONLEventBridge: () => import_bridges.JSONLEventBridge,
+  NATSEventBridge: () => import_bridges.NATSEventBridge,
+  PostgresEventBridge: () => import_bridges.PostgresEventBridge,
+  RedisEventBridge: () => import_bridges.RedisEventBridge,
+  RetryTimeoutError: () => import_retry.RetryTimeoutError,
+  SQLiteEventBridge: () => import_bridges.SQLiteEventBridge,
+  SemaphoreTimeoutError: () => import_retry.SemaphoreTimeoutError,
+  SocketEventBridge: () => import_bridges.SocketEventBridge,
+  clearSemaphoreRegistry: () => import_retry.clearSemaphoreRegistry,
+  events_suck: () => import_events_suck.events_suck,
+  monotonicDatetime: () => import_helpers.monotonicDatetime,
+  retry: () => import_retry.retry
+});
+module.exports = __toCommonJS(index_exports);
+var import_base_event = require("./base_event.js");
+var import_event_history = require("./event_history.js");
+var import_event_result = require("./event_result.js");
+var import_event_bus = require("./event_bus.js");
+var import_helpers = require("./helpers.js");
+var import_event_handler = require("./event_handler.js");
+var import_retry = require("./retry.js");
+var import_bridges = require("./bridges.js");
+var import_events_suck = require("./events_suck.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": ["export { BaseEvent, BaseEventSchema } from './base_event.js'\nexport { EventHistory } from './event_history.js'\nexport type { EventHistoryFindOptions, EventHistoryTrimOptions } from './event_history.js'\nexport { EventResult } from './event_result.js'\nexport { EventBus } from './event_bus.js'\nexport type { EventBusJSON, EventBusOptions } from './event_bus.js'\nexport { monotonicDatetime } from './helpers.js'\nexport type { EventBusMiddleware, EventBusMiddlewareCtor, EventBusMiddlewareInput } from './middlewares.js'\nexport {\n  EventHandlerTimeoutError,\n  EventHandlerCancelledError,\n  EventHandlerAbortedError,\n  EventHandlerResultSchemaError,\n} from './event_handler.js'\nexport type {\n  EventConcurrencyMode,\n  EventHandlerConcurrencyMode,\n  EventHandlerCompletionMode,\n  EventBusInterfaceForLockManager,\n} from './lock_manager.js'\nexport type { EventClass, EventHandlerCallable as EventHandler, EventPattern, EventStatus, FindOptions, FindWindow } from './types.js'\nexport { retry, clearSemaphoreRegistry, RetryTimeoutError, SemaphoreTimeoutError } from './retry.js'\nexport type { RetryOptions } from './retry.js'\nexport {\n  HTTPEventBridge,\n  SocketEventBridge,\n  NATSEventBridge,\n  RedisEventBridge,\n  PostgresEventBridge,\n  JSONLEventBridge,\n  SQLiteEventBridge,\n} from './bridges.js'\nexport type { HTTPEventBridgeOptions } from './bridges.js'\nexport { events_suck } from './events_suck.js'\nexport type { EventsSuckClient, EventsSuckClientClass, GeneratedEvents } from './events_suck.js'\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAA2C;AAC3C,2BAA6B;AAE7B,0BAA4B;AAC5B,uBAAyB;AAEzB,qBAAkC;AAElC,2BAKO;AAQP,mBAAwF;AAExF,qBAQO;AAEP,yBAA4B;",
+  "names": []
+}

package/dist/cjs/lock_manager.d.ts

@@ -0,0 +1,70 @@
+import type { BaseEvent } from './base_event.js';
+import type { EventResult } from './event_result.js';
+export type Deferred<T> = {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+};
+export declare const withResolvers: <T>() => Deferred<T>;
+export declare const EVENT_CONCURRENCY_MODES: readonly ["global-serial", "bus-serial", "parallel"];
+export type EventConcurrencyMode = (typeof EVENT_CONCURRENCY_MODES)[number];
+export declare const EVENT_HANDLER_CONCURRENCY_MODES: readonly ["serial", "parallel"];
+export type EventHandlerConcurrencyMode = (typeof EVENT_HANDLER_CONCURRENCY_MODES)[number];
+export declare const EVENT_HANDLER_COMPLETION_MODES: readonly ["all", "first"];
+export type EventHandlerCompletionMode = (typeof EVENT_HANDLER_COMPLETION_MODES)[number];
+export declare class AsyncLock {
+    size: number;
+    in_use: number;
+    waiters: Array<() => void>;
+    constructor(size: number);
+    acquire(): Promise<void>;
+    release(): void;
+}
+export declare const runWithLock: <T>(lock: AsyncLock | null, fn: () => Promise<T>) => Promise<T>;
+export type HandlerExecutionState = 'held' | 'yielded' | 'closed';
+export declare class HandlerLock {
+    private lock;
+    private state;
+    constructor(lock: AsyncLock | null);
+    yieldHandlerLockForChildRun(): boolean;
+    reclaimHandlerLockIfRunning(): Promise<boolean>;
+    exitHandlerRun(): void;
+    runQueueJump<T>(fn: () => Promise<T>): Promise<T>;
+}
+export type EventBusInterfaceForLockManager = {
+    isIdleAndQueueEmpty: () => boolean;
+    event_concurrency: EventConcurrencyMode;
+    _lock_for_event_global_serial: AsyncLock;
+};
+export type LockManagerOptions = {
+    auto_schedule_idle_checks?: boolean;
+};
+export declare class LockManager {
+    private bus;
+    private auto_schedule_idle_checks;
+    readonly bus_event_lock: AsyncLock;
+    private pause_depth;
+    private pause_waiters;
+    private active_handler_results;
+    private idle_waiters;
+    private idle_check_pending;
+    private idle_check_streak;
+    constructor(bus: EventBusInterfaceForLockManager, options?: LockManagerOptions);
+    _requestRunloopPause(): () => void;
+    _waitUntilRunloopResumed(): Promise<void>;
+    _isPaused(): boolean;
+    _runWithHandlerDispatchContext<T>(result: EventResult, fn: () => Promise<T>): Promise<T>;
+    _getActiveHandlerResult(): EventResult | undefined;
+    _getActiveHandlerResults(): EventResult[];
+    _isAnyHandlerActive(): boolean;
+    waitForIdle(timeout_seconds?: number | null): Promise<boolean>;
+    _notifyIdleListeners(): void;
+    getLockForEvent(event: BaseEvent): AsyncLock | null;
+    _runWithEventLock<T>(event: BaseEvent, fn: () => Promise<T>, options?: {
+        bypass_event_locks?: boolean;
+        pre_acquired_lock?: AsyncLock | null;
+    }): Promise<T>;
+    _runWithHandlerLock<T>(event: BaseEvent, default_handler_concurrency: EventHandlerConcurrencyMode | undefined, fn: (lock: HandlerLock | null) => Promise<T>): Promise<T>;
+    private scheduleIdleCheck;
+    clear(): void;
+}

package/dist/cjs/lock_manager.js

@@ -0,0 +1,343 @@
+"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 lock_manager_exports = {};
+__export(lock_manager_exports, {
+  AsyncLock: () => AsyncLock,
+  EVENT_CONCURRENCY_MODES: () => EVENT_CONCURRENCY_MODES,
+  EVENT_HANDLER_COMPLETION_MODES: () => EVENT_HANDLER_COMPLETION_MODES,
+  EVENT_HANDLER_CONCURRENCY_MODES: () => EVENT_HANDLER_CONCURRENCY_MODES,
+  HandlerLock: () => HandlerLock,
+  LockManager: () => LockManager,
+  runWithLock: () => runWithLock,
+  withResolvers: () => withResolvers
+});
+module.exports = __toCommonJS(lock_manager_exports);
+const withResolvers = () => {
+  if (typeof Promise.withResolvers === "function") {
+    return Promise.withResolvers();
+  }
+  let resolve;
+  let reject;
+  const promise = new Promise((resolve_fn, reject_fn) => {
+    resolve = resolve_fn;
+    reject = reject_fn;
+  });
+  return { promise, resolve, reject };
+};
+const EVENT_CONCURRENCY_MODES = ["global-serial", "bus-serial", "parallel"];
+const EVENT_HANDLER_CONCURRENCY_MODES = ["serial", "parallel"];
+const EVENT_HANDLER_COMPLETION_MODES = ["all", "first"];
+class AsyncLock {
+  size;
+  in_use;
+  waiters;
+  constructor(size) {
+    this.size = size;
+    this.in_use = 0;
+    this.waiters = [];
+  }
+  async acquire() {
+    if (this.size === Infinity) {
+      return;
+    }
+    if (this.in_use < this.size) {
+      this.in_use += 1;
+      return;
+    }
+    await new Promise((resolve) => {
+      this.waiters.push(resolve);
+    });
+  }
+  release() {
+    if (this.size === Infinity) {
+      return;
+    }
+    const next = this.waiters.shift();
+    if (next) {
+      next();
+      return;
+    }
+    this.in_use = Math.max(0, this.in_use - 1);
+  }
+}
+const runWithLock = async (lock, fn) => {
+  if (!lock) {
+    return await fn();
+  }
+  await lock.acquire();
+  try {
+    return await fn();
+  } finally {
+    lock.release();
+  }
+};
+class HandlerLock {
+  lock;
+  state;
+  constructor(lock) {
+    this.lock = lock;
+    this.state = "held";
+  }
+  // used by EventBus._processEventImmediately to yield the parent handler's lock to the child event so it can be processed immediately
+  yieldHandlerLockForChildRun() {
+    if (!this.lock || this.state !== "held") {
+      return false;
+    }
+    this.state = "yielded";
+    this.lock.release();
+    return true;
+  }
+  // used by EventBus._processEventImmediately to reacquire the handler lock after the child event has been processed
+  async reclaimHandlerLockIfRunning() {
+    if (!this.lock || this.state !== "yielded") {
+      return false;
+    }
+    await this.lock.acquire();
+    if (this.state !== "yielded") {
+      this.lock.release();
+      return false;
+    }
+    this.state = "held";
+    return true;
+  }
+  // used by EventResult.runHandler to exit the handler lock after the handler has finished executing
+  exitHandlerRun() {
+    if (this.state === "closed") {
+      return;
+    }
+    const should_release = !!this.lock && this.state === "held";
+    this.state = "closed";
+    if (should_release) {
+      this.lock.release();
+    }
+  }
+  // used by EventBus._processEventImmediately to yield the handler lock and reacquire it after the child event has been processed
+  async runQueueJump(fn) {
+    const yielded = this.yieldHandlerLockForChildRun();
+    try {
+      return await fn();
+    } finally {
+      if (yielded) {
+        await this.reclaimHandlerLockIfRunning();
+      }
+    }
+  }
+}
+class LockManager {
+  bus;
+  // Live bus reference; used to read defaults and idle state.
+  auto_schedule_idle_checks;
+  bus_event_lock;
+  // Per-bus event lock; created with LockManager and never swapped.
+  pause_depth;
+  // Re-entrant pause counter; increments on _requestRunloopPause, decrements on release.
+  pause_waiters;
+  // Resolvers for _waitUntilRunloopResumed; drained when pause_depth hits 0.
+  active_handler_results;
+  // Stack of active handler results for "inside handler" detection.
+  idle_waiters;
+  // Resolvers waiting for stable idle; cleared when idle confirmed.
+  idle_check_pending;
+  // Debounce flag to avoid scheduling redundant idle checks.
+  idle_check_streak;
+  // Counts consecutive idle checks; used to require two ticks of idle.
+  constructor(bus, options = {}) {
+    this.bus = bus;
+    this.auto_schedule_idle_checks = options.auto_schedule_idle_checks ?? true;
+    this.bus_event_lock = new AsyncLock(1);
+    this.pause_depth = 0;
+    this.pause_waiters = [];
+    this.active_handler_results = [];
+    this.idle_waiters = [];
+    this.idle_check_pending = false;
+    this.idle_check_streak = 0;
+  }
+  // Low-level runloop pause: increments a re-entrant counter and returns a release
+  // function. Used for broad, bus-scoped pauses during queue-jump across buses.
+  _requestRunloopPause() {
+    this.pause_depth += 1;
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      this.pause_depth = Math.max(0, this.pause_depth - 1);
+      if (this.pause_depth !== 0) {
+        return;
+      }
+      const waiters = this.pause_waiters;
+      this.pause_waiters = [];
+      for (const resolve of waiters) {
+        resolve();
+      }
+    };
+  }
+  _waitUntilRunloopResumed() {
+    if (this.pause_depth === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.pause_waiters.push(resolve);
+    });
+  }
+  _isPaused() {
+    return this.pause_depth > 0;
+  }
+  async _runWithHandlerDispatchContext(result, fn) {
+    this.active_handler_results.push(result);
+    try {
+      return await fn();
+    } finally {
+      const idx = this.active_handler_results.indexOf(result);
+      if (idx >= 0) {
+        this.active_handler_results.splice(idx, 1);
+      }
+    }
+  }
+  _getActiveHandlerResult() {
+    return this.active_handler_results[this.active_handler_results.length - 1];
+  }
+  _getActiveHandlerResults() {
+    return [...this.active_handler_results];
+  }
+  // Per-bus check: true only if this specific bus has a handler on its stack.
+  // For cross-bus queue-jumping, EventBus._processEventImmediately uses getParentEventResultAcrossAllBuses()
+  // to walk up the parent event tree, and the bus proxy passes handler_result
+  // to _processEventImmediately so it can yield/reacquire the correct lock.
+  _isAnyHandlerActive() {
+    return this.active_handler_results.length > 0;
+  }
+  waitForIdle(timeout_seconds = null) {
+    return new Promise((resolve) => {
+      let done = false;
+      let timeout_id = null;
+      const finish = (became_idle) => {
+        if (done) {
+          return;
+        }
+        done = true;
+        if (timeout_id !== null) {
+          clearTimeout(timeout_id);
+          timeout_id = null;
+        }
+        resolve(became_idle);
+      };
+      this.idle_waiters.push(finish);
+      this.scheduleIdleCheck();
+      if (timeout_seconds === null || timeout_seconds === void 0) {
+        return;
+      }
+      const timeout_ms = Math.max(0, Number(timeout_seconds)) * 1e3;
+      if (!Number.isFinite(timeout_ms)) {
+        return;
+      }
+      timeout_id = setTimeout(() => {
+        const index = this.idle_waiters.indexOf(finish);
+        if (index >= 0) {
+          this.idle_waiters.splice(index, 1);
+        }
+        finish(false);
+      }, timeout_ms);
+    });
+  }
+  // Called by EventBus.markEventCompleted and EventBus.markHandlerCompleted to notify
+  // waitUntilIdle() callers that the bus may now be idle.
+  _notifyIdleListeners() {
+    if (this.idle_waiters.length === 0) {
+      this.idle_check_streak = 0;
+      return;
+    }
+    if (!this.bus.isIdleAndQueueEmpty()) {
+      this.idle_check_streak = 0;
+      if (this.idle_waiters.length > 0) {
+        this.scheduleIdleCheck();
+      }
+      return;
+    }
+    this.idle_check_streak += 1;
+    if (this.idle_check_streak < 2) {
+      if (this.idle_waiters.length > 0) {
+        this.scheduleIdleCheck();
+      }
+      return;
+    }
+    this.idle_check_streak = 0;
+    const waiters = this.idle_waiters;
+    this.idle_waiters = [];
+    for (const resolve of waiters) {
+      resolve(true);
+    }
+  }
+  // get the bus-level lock that prevents/allows multiple events to be processed concurrently on the same bus
+  getLockForEvent(event) {
+    const resolved = event.event_concurrency ?? this.bus.event_concurrency;
+    if (resolved === "parallel") {
+      return null;
+    }
+    if (resolved === "global-serial") {
+      return this.bus._lock_for_event_global_serial;
+    }
+    return this.bus_event_lock;
+  }
+  async _runWithEventLock(event, fn, options = {}) {
+    const pre_acquired = options.pre_acquired_lock ?? null;
+    if (options.bypass_event_locks || pre_acquired) {
+      return await fn();
+    }
+    return await runWithLock(this.getLockForEvent(event), fn);
+  }
+  async _runWithHandlerLock(event, default_handler_concurrency, fn) {
+    const lock = event._getHandlerLock(default_handler_concurrency);
+    if (lock) {
+      await lock.acquire();
+    }
+    const handler_lock = lock ? new HandlerLock(lock) : null;
+    try {
+      return await fn(handler_lock);
+    } finally {
+      handler_lock?.exitHandlerRun();
+    }
+  }
+  // Schedules a debounced idle check to run after a short delay. Used to gate
+  // waitUntilIdle() calls during handler execution and after event completion.
+  scheduleIdleCheck() {
+    if (!this.auto_schedule_idle_checks) {
+      return;
+    }
+    if (this.idle_check_pending) {
+      return;
+    }
+    this.idle_check_pending = true;
+    setTimeout(() => {
+      this.idle_check_pending = false;
+      this._notifyIdleListeners();
+    }, 0);
+  }
+  // Reset all state to initial values
+  clear() {
+    this.pause_depth = 0;
+    this.pause_waiters = [];
+    this.active_handler_results = [];
+    this.idle_waiters = [];
+    this.idle_check_pending = false;
+    this.idle_check_streak = 0;
+  }
+}
+//# sourceMappingURL=lock_manager.js.map

package/dist/cjs/lock_manager.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lock_manager.ts"],
+  "sourcesContent": ["import type { BaseEvent } from './base_event.js'\nimport type { EventResult } from './event_result.js'\n\n// \u2500\u2500\u2500 Deferred / withResolvers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type Deferred<T> = {\n  promise: Promise<T>\n  resolve: (value: T | PromiseLike<T>) => void\n  reject: (reason?: unknown) => void\n}\n\nexport const withResolvers = <T>(): Deferred<T> => {\n  if (typeof Promise.withResolvers === 'function') {\n    return Promise.withResolvers<T>()\n  }\n  let resolve!: (value: T | PromiseLike<T>) => void\n  let reject!: (reason?: unknown) => void\n  const promise = new Promise<T>((resolve_fn, reject_fn) => {\n    resolve = resolve_fn\n    reject = reject_fn\n  })\n  return { promise, resolve, reject }\n}\n\n// \u2500\u2500\u2500 Concurrency modes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport const EVENT_CONCURRENCY_MODES = ['global-serial', 'bus-serial', 'parallel'] as const\nexport type EventConcurrencyMode = (typeof EVENT_CONCURRENCY_MODES)[number]\n\nexport const EVENT_HANDLER_CONCURRENCY_MODES = ['serial', 'parallel'] as const\nexport type EventHandlerConcurrencyMode = (typeof EVENT_HANDLER_CONCURRENCY_MODES)[number]\n\nexport const EVENT_HANDLER_COMPLETION_MODES = ['all', 'first'] as const\nexport type EventHandlerCompletionMode = (typeof EVENT_HANDLER_COMPLETION_MODES)[number]\n\n// \u2500\u2500\u2500 AsyncLock \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport class AsyncLock {\n  size: number\n  in_use: number\n  waiters: Array<() => void>\n\n  constructor(size: number) {\n    this.size = size\n    this.in_use = 0\n    this.waiters = []\n  }\n\n  async acquire(): Promise<void> {\n    if (this.size === Infinity) {\n      return\n    }\n    if (this.in_use < this.size) {\n      this.in_use += 1\n      return\n    }\n    await new Promise<void>((resolve) => {\n      this.waiters.push(resolve)\n    })\n  }\n\n  release(): void {\n    if (this.size === Infinity) {\n      return\n    }\n    const next = this.waiters.shift()\n    if (next) {\n      // Handoff: keep permit accounted for and transfer directly to next waiter.\n      next()\n      return\n    }\n    this.in_use = Math.max(0, this.in_use - 1)\n  }\n}\n\nexport const runWithLock = async <T>(lock: AsyncLock | null, fn: () => Promise<T>): Promise<T> => {\n  if (!lock) {\n    return await fn()\n  }\n  await lock.acquire()\n  try {\n    return await fn()\n  } finally {\n    lock.release()\n  }\n}\n\n// \u2500\u2500\u2500 HandlerLock \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type HandlerExecutionState = 'held' | 'yielded' | 'closed'\n\n// Tracks a single handler execution's ownership of a handler lock.\n// Reacquire is race-safe: if the handler exits while waiting to reclaim,\n// the reclaimed lock is immediately released to avoid leaks.\nexport class HandlerLock {\n  private lock: AsyncLock | null\n  private state: HandlerExecutionState\n\n  constructor(lock: AsyncLock | null) {\n    this.lock = lock\n    this.state = 'held'\n  }\n\n  // used by EventBus._processEventImmediately to yield the parent handler's lock to the child event so it can be processed immediately\n  yieldHandlerLockForChildRun(): boolean {\n    if (!this.lock || this.state !== 'held') {\n      return false\n    }\n    this.state = 'yielded'\n    this.lock.release()\n    return true\n  }\n\n  // used by EventBus._processEventImmediately to reacquire the handler lock after the child event has been processed\n  async reclaimHandlerLockIfRunning(): Promise<boolean> {\n    if (!this.lock || this.state !== 'yielded') {\n      return false\n    }\n    await this.lock.acquire()\n    if (this.state !== 'yielded') {\n      // Handler exited while this reacquire was pending.\n      this.lock.release()\n      return false\n    }\n    this.state = 'held'\n    return true\n  }\n\n  // used by EventResult.runHandler to exit the handler lock after the handler has finished executing\n  exitHandlerRun(): void {\n    if (this.state === 'closed') {\n      return\n    }\n    const should_release = !!this.lock && this.state === 'held'\n    this.state = 'closed'\n    if (should_release) {\n      this.lock!.release()\n    }\n  }\n\n  // used by EventBus._processEventImmediately to yield the handler lock and reacquire it after the child event has been processed\n  async runQueueJump<T>(fn: () => Promise<T>): Promise<T> {\n    const yielded = this.yieldHandlerLockForChildRun()\n    try {\n      return await fn()\n    } finally {\n      if (yielded) {\n        await this.reclaimHandlerLockIfRunning()\n      }\n    }\n  }\n}\n\n// \u2500\u2500\u2500 LockManager \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n// Interface that must be implemented by the EventBus class to be used by the LockManager\nexport type EventBusInterfaceForLockManager = {\n  isIdleAndQueueEmpty: () => boolean\n  event_concurrency: EventConcurrencyMode\n  _lock_for_event_global_serial: AsyncLock\n}\n\nexport type LockManagerOptions = {\n  auto_schedule_idle_checks?: boolean\n}\n\n// The LockManager is responsible for managing the concurrency of events and handlers\nexport class LockManager {\n  private bus: EventBusInterfaceForLockManager // Live bus reference; used to read defaults and idle state.\n  private auto_schedule_idle_checks: boolean\n\n  readonly bus_event_lock: AsyncLock // Per-bus event lock; created with LockManager and never swapped.\n  private pause_depth: number // Re-entrant pause counter; increments on _requestRunloopPause, decrements on release.\n  private pause_waiters: Array<() => void> // Resolvers for _waitUntilRunloopResumed; drained when pause_depth hits 0.\n  private active_handler_results: EventResult[] // Stack of active handler results for \"inside handler\" detection.\n\n  private idle_waiters: Array<(became_idle: boolean) => void> // Resolvers waiting for stable idle; cleared when idle confirmed.\n  private idle_check_pending: boolean // Debounce flag to avoid scheduling redundant idle checks.\n  private idle_check_streak: number // Counts consecutive idle checks; used to require two ticks of idle.\n\n  constructor(bus: EventBusInterfaceForLockManager, options: LockManagerOptions = {}) {\n    this.bus = bus\n    this.auto_schedule_idle_checks = options.auto_schedule_idle_checks ?? true\n    this.bus_event_lock = new AsyncLock(1) // used for the bus-serial concurrency mode\n\n    this.pause_depth = 0\n    this.pause_waiters = []\n    this.active_handler_results = []\n\n    this.idle_waiters = []\n    this.idle_check_pending = false\n    this.idle_check_streak = 0\n  }\n\n  // Low-level runloop pause: increments a re-entrant counter and returns a release\n  // function. Used for broad, bus-scoped pauses during queue-jump across buses.\n  _requestRunloopPause(): () => void {\n    this.pause_depth += 1\n    let released = false\n    return () => {\n      if (released) {\n        return\n      }\n      released = true\n      this.pause_depth = Math.max(0, this.pause_depth - 1)\n      if (this.pause_depth !== 0) {\n        return\n      }\n      const waiters = this.pause_waiters\n      this.pause_waiters = []\n      for (const resolve of waiters) {\n        resolve()\n      }\n    }\n  }\n\n  _waitUntilRunloopResumed(): Promise<void> {\n    if (this.pause_depth === 0) {\n      return Promise.resolve()\n    }\n    return new Promise((resolve) => {\n      this.pause_waiters.push(resolve)\n    })\n  }\n\n  _isPaused(): boolean {\n    return this.pause_depth > 0\n  }\n\n  async _runWithHandlerDispatchContext<T>(result: EventResult, fn: () => Promise<T>): Promise<T> {\n    this.active_handler_results.push(result)\n    try {\n      return await fn()\n    } finally {\n      const idx = this.active_handler_results.indexOf(result)\n      if (idx >= 0) {\n        this.active_handler_results.splice(idx, 1)\n      }\n    }\n  }\n\n  _getActiveHandlerResult(): EventResult | undefined {\n    return this.active_handler_results[this.active_handler_results.length - 1]\n  }\n\n  _getActiveHandlerResults(): EventResult[] {\n    return [...this.active_handler_results]\n  }\n\n  // Per-bus check: true only if this specific bus has a handler on its stack.\n  // For cross-bus queue-jumping, EventBus._processEventImmediately uses getParentEventResultAcrossAllBuses()\n  // to walk up the parent event tree, and the bus proxy passes handler_result\n  // to _processEventImmediately so it can yield/reacquire the correct lock.\n  _isAnyHandlerActive(): boolean {\n    return this.active_handler_results.length > 0\n  }\n\n  waitForIdle(timeout_seconds: number | null = null): Promise<boolean> {\n    return new Promise((resolve) => {\n      let done = false\n      let timeout_id: ReturnType<typeof setTimeout> | null = null\n\n      const finish = (became_idle: boolean): void => {\n        if (done) {\n          return\n        }\n        done = true\n        if (timeout_id !== null) {\n          clearTimeout(timeout_id)\n          timeout_id = null\n        }\n        resolve(became_idle)\n      }\n\n      this.idle_waiters.push(finish)\n      this.scheduleIdleCheck()\n\n      if (timeout_seconds === null || timeout_seconds === undefined) {\n        return\n      }\n\n      const timeout_ms = Math.max(0, Number(timeout_seconds)) * 1000\n      if (!Number.isFinite(timeout_ms)) {\n        return\n      }\n\n      timeout_id = setTimeout(() => {\n        const index = this.idle_waiters.indexOf(finish)\n        if (index >= 0) {\n          this.idle_waiters.splice(index, 1)\n        }\n        finish(false)\n      }, timeout_ms)\n    })\n  }\n\n  // Called by EventBus.markEventCompleted and EventBus.markHandlerCompleted to notify\n  // waitUntilIdle() callers that the bus may now be idle.\n  _notifyIdleListeners(): void {\n    // Fast-path: most completions have no waitUntilIdle() callers waiting,\n    // so skip expensive idle snapshot scans in that common case.\n    if (this.idle_waiters.length === 0) {\n      this.idle_check_streak = 0\n      return\n    }\n\n    if (!this.bus.isIdleAndQueueEmpty()) {\n      this.idle_check_streak = 0\n      if (this.idle_waiters.length > 0) {\n        this.scheduleIdleCheck()\n      }\n      return\n    }\n\n    this.idle_check_streak += 1\n    if (this.idle_check_streak < 2) {\n      if (this.idle_waiters.length > 0) {\n        this.scheduleIdleCheck()\n      }\n      return\n    }\n\n    this.idle_check_streak = 0\n    const waiters = this.idle_waiters\n    this.idle_waiters = []\n    for (const resolve of waiters) {\n      resolve(true)\n    }\n  }\n\n  // get the bus-level lock that prevents/allows multiple events to be processed concurrently on the same bus\n  getLockForEvent(event: BaseEvent): AsyncLock | null {\n    const resolved = event.event_concurrency ?? this.bus.event_concurrency\n    if (resolved === 'parallel') {\n      return null\n    }\n    if (resolved === 'global-serial') {\n      return this.bus._lock_for_event_global_serial\n    }\n    return this.bus_event_lock\n  }\n\n  async _runWithEventLock<T>(\n    event: BaseEvent,\n    fn: () => Promise<T>,\n    options: { bypass_event_locks?: boolean; pre_acquired_lock?: AsyncLock | null } = {}\n  ): Promise<T> {\n    const pre_acquired = options.pre_acquired_lock ?? null\n    if (options.bypass_event_locks || pre_acquired) {\n      return await fn()\n    }\n    return await runWithLock(this.getLockForEvent(event), fn)\n  }\n\n  async _runWithHandlerLock<T>(\n    event: BaseEvent,\n    default_handler_concurrency: EventHandlerConcurrencyMode | undefined,\n    fn: (lock: HandlerLock | null) => Promise<T>\n  ): Promise<T> {\n    const lock = event._getHandlerLock(default_handler_concurrency)\n    if (lock) {\n      await lock.acquire()\n    }\n    const handler_lock = lock ? new HandlerLock(lock) : null\n    try {\n      return await fn(handler_lock)\n    } finally {\n      handler_lock?.exitHandlerRun()\n    }\n  }\n\n  // Schedules a debounced idle check to run after a short delay. Used to gate\n  // waitUntilIdle() calls during handler execution and after event completion.\n  private scheduleIdleCheck(): void {\n    if (!this.auto_schedule_idle_checks) {\n      return\n    }\n    if (this.idle_check_pending) {\n      return\n    }\n    this.idle_check_pending = true\n    setTimeout(() => {\n      this.idle_check_pending = false\n      this._notifyIdleListeners()\n    }, 0)\n  }\n\n  // Reset all state to initial values\n  clear(): void {\n    this.pause_depth = 0\n    this.pause_waiters = []\n    this.active_handler_results = []\n    this.idle_waiters = []\n    this.idle_check_pending = false\n    this.idle_check_streak = 0\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/logging.d.ts

@@ -0,0 +1,16 @@
+import { BaseEvent } from './base_event.js';
+import { EventResult } from './event_result.js';
+type LogTreeBus = {
+    name: string;
+    event_history: {
+        values(): IterableIterator<BaseEvent>;
+        has(event_id: string): boolean;
+    };
+    toString?: () => string;
+};
+export declare const logTree: (bus: LogTreeBus) => string;
+export declare const buildTreeLine: (event: BaseEvent, indent: string, is_last: boolean, parent_to_children: Map<string, BaseEvent[]>, visited: Set<string>) => string;
+export declare const buildResultLine: (result: EventResult, indent: string, is_last: boolean, parent_to_children: Map<string, BaseEvent[]>, visited: Set<string>) => string;
+export declare const formatTimestamp: (value?: string) => string;
+export declare const formatResultValue: (value: unknown) => string;
+export {};