@holo-js/events 0.3.28 → 0.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Holo-JS contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/.holo-build-fingerprint

@@ -0,0 +1 @@
+3fc9dd4981443d3306e60b3ff6271a7d1d56721340f20c03d22c91df21ae7fe9

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { QueueJobDefinition, QueueJsonValue, QueueRegisteredJob } from '@holo-js/queue';
+import { QueueJobDefinition, QueueJsonValue, QueueRegisteredJob, QueueJobContext } from '@holo-js/queue';
 
 type EventDelayValue = number | Date;
 type EventDefinitionDispatcher = <TPayload>(event: EventDefinition<TPayload, string | undefined>, payload: TPayload) => EventPendingDispatch<TPayload>;
@@ -50,6 +50,8 @@ interface ListenerDefinition<TInput extends EventReferenceInput = EventReference
     readonly queueName?: string;
     readonly delay?: EventDelayValue;
     readonly afterCommit?: boolean;
+    readonly tries?: number;
+    readonly backoff?: number | readonly number[];
     handle(event: ListenerHandledEvent<TInput>): TResult | Promise<TResult>;
 }
 type ListenerDefinitionInput<TInput extends EventReferenceInput = EventReferenceInput, TResult = unknown> = Omit<ListenerDefinition<TInput, TResult>, 'listensTo'> & {
@@ -94,6 +96,7 @@ interface EventQueuedListenerDispatch {
     readonly connection?: string;
     readonly queueName?: string;
     readonly delay?: EventDelayValue;
+    readonly tries?: number;
 }
 interface EventDeferredDispatchContext {
     readonly eventName: string;
@@ -196,7 +199,9 @@ declare module '@holo-js/queue' {
 }
 type QueueModule = {
     defineJob(definition: QueueJobDefinition<EventsInvokeListenerPayload, void>): QueueJobDefinition<EventsInvokeListenerPayload, void>;
-    dispatch(jobName: string, payload: EventsInvokeListenerPayload): QueuePendingDispatchChain;
+    dispatch(jobName: string, payload: EventsInvokeListenerPayload, options?: {
+        readonly tries?: number;
+    }): QueuePendingDispatchChain;
     getRegisteredQueueJob(name: string): QueueRegisteredJob | undefined;
     registerQueueJob(definition: QueueJobDefinition<EventsInvokeListenerPayload, void>, options: {
         name: string;
@@ -212,7 +217,7 @@ declare function loadQueueModule(): Promise<QueueModule>;
 declare function createQueuedListenerEventEnvelope(payload: EventsInvokeListenerPayload): EventEnvelope<string, QueueJsonValue>;
 declare function requireQueuedListener(listenerId: string): RegisteredListener;
 declare function assertQueuedListenerMatchesEvent(listener: RegisteredListener, eventName: string): void;
-declare function runQueuedListenerInvocation(payload: EventsInvokeListenerPayload): Promise<void>;
+declare function runQueuedListenerInvocation(payload: EventsInvokeListenerPayload, context?: QueueJobContext): Promise<void>;
 declare function ensureEventsQueueJobRegistered(): void;
 declare function ensureEventsQueueJobRegisteredAsync(): Promise<void>;
 declare const eventQueueInternals: {
@@ -234,12 +239,6 @@ type EventPayloadValidationState = {
 type RuntimeState = {
     hooks: EventRuntimeHooks;
 };
-type ListenerExecutionGroups = {
-    readonly immediateSyncListeners: readonly RegisteredListener[];
-    readonly immediateQueuedListeners: readonly RegisteredListener[];
-    readonly deferredSyncListeners: readonly RegisteredListener[];
-    readonly deferredQueuedListeners: readonly RegisteredListener[];
-};
 declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 declare function assertEventJsonValue(value: unknown, path: string, state: EventPayloadValidationState): void;
 declare function validateQueuedEventPayload<TPayload>(payload: TPayload): void;
@@ -249,19 +248,14 @@ declare function normalizeEventName(name: string): string;
 declare function resolveDispatchedEventName<TPayload>(event: string | EventDefinition<TPayload, string | undefined>): string;
 declare function requireRegisteredEvent(name: string): RegisteredEvent;
 declare function createEventEnvelope<TPayload>(eventName: string, payload: TPayload, occurredAt?: number): EventEnvelope<string, TPayload>;
-declare function splitRegisteredListeners(listeners: readonly RegisteredListener[]): {
-    readonly syncListeners: readonly RegisteredListener[];
-    readonly queuedListeners: readonly RegisteredListener[];
+declare function splitListenersByCommitTiming(listeners: readonly RegisteredListener[], shouldDeferAll: boolean): {
+    readonly immediateListeners: readonly RegisteredListener[];
+    readonly deferredListeners: readonly RegisteredListener[];
 };
-declare function executeSyncListeners<TPayload>(listeners: readonly RegisteredListener[], event: EventEnvelope<string, TPayload>): Promise<number>;
-declare function executeListenerGroups<TPayload>(syncListeners: readonly RegisteredListener[], queuedListeners: readonly RegisteredListener[], event: EventEnvelope<string, TPayload>, options: PendingOptions): Promise<{
-    readonly syncCount: number;
-    readonly queuedCount: number;
-}>;
 declare function executeListener<TPayload>(listener: RegisteredListener, event: EventEnvelope<string, TPayload>): Promise<void>;
 declare function createQueuedListenerDispatch(listener: RegisteredListener, event: EventEnvelope, options: PendingOptions): EventQueuedListenerDispatch;
-declare function dispatchQueuedListeners<TPayload>(listeners: readonly RegisteredListener[], event: EventEnvelope<string, TPayload>, options: PendingOptions): Promise<number>;
-declare function splitListenersForExecution(listeners: readonly RegisteredListener[], forceAfterCommit: boolean): ListenerExecutionGroups;
+declare function dispatchQueuedListener<TPayload>(listener: RegisteredListener, event: EventEnvelope<string, TPayload>, options: PendingOptions): Promise<void>;
+declare function runListenersInOrder<TPayload>(listeners: readonly RegisteredListener[], event: EventEnvelope<string, TPayload>, options: PendingOptions): Promise<void>;
 declare function scheduleDeferredDispatch(callback: () => Promise<void>, eventName: string): boolean;
 declare function executeDispatch<TPayload>(event: string | EventDefinition<TPayload, string | undefined>, payload: TPayload, options?: PendingOptions): Promise<EventDispatchResult>;
 declare function configureEventsRuntime(hooks?: EventRuntimeHooks): void;
@@ -276,20 +270,19 @@ declare const eventRuntimeInternals: {
     createEventEnvelope: typeof createEventEnvelope;
     createQueuedListenerDispatch: typeof createQueuedListenerDispatch;
     createRuntimeBinding: typeof createRuntimeBinding;
-    dispatchQueuedListeners: typeof dispatchQueuedListeners;
-    executeListenerGroups: typeof executeListenerGroups;
+    dispatchQueuedListener: typeof dispatchQueuedListener;
     executeDispatch: typeof executeDispatch;
     executeListener: typeof executeListener;
-    executeSyncListeners: typeof executeSyncListeners;
+    runListenersInOrder: typeof runListenersInOrder;
     getRuntimeState: typeof getRuntimeState;
     isPlainObject: typeof isPlainObject;
     normalizeEventName: typeof normalizeEventName;
     requireRegisteredEvent: typeof requireRegisteredEvent;
     resolveDispatchedEventName: typeof resolveDispatchedEventName;
     scheduleDeferredDispatch: typeof scheduleDeferredDispatch;
-    splitRegisteredListeners: typeof splitRegisteredListeners;
-    splitListenersForExecution: typeof splitListenersForExecution;
+    splitListenersByCommitTiming: typeof splitListenersByCommitTiming;
     validateQueuedEventPayload: typeof validateQueuedEventPayload;
 };
 
-export { type DefinedEventDefinition, EVENTS_INVOKE_LISTENER_JOB, Event, type EventDeferredDispatchContext, type EventDefinition, type EventDelayValue, type EventDispatchResult, type EventEnvelope, type EventEnvelopeFor, type EventFacade, type EventPayloadFor, type EventPendingDispatch, type EventQueuedListenerDispatch, type EventReference, type EventReferenceInput, type EventRuntimeBinding, type EventRuntimeHooks, type EventsInvokeListenerPayload, type ExportedEventDefinition, type HoloEventRegistry, type HoloListenerRegistry, type ListenerDefinition, type ListenerDefinitionInput, type ListenerHandledEvent, type RegisterEventOptions, type RegisterListenerOptions, type RegisteredEvent, type RegisteredListener, configureEventsRuntime, deferEventDispatchToDatabaseCommit, defineEvent, defineListener, dispatchEvent, ensureEventsQueueJobRegistered, ensureEventsQueueJobRegisteredAsync, eventInternals, eventQueueInternals, eventRegistryInternals, eventRuntimeInternals, getEventsRuntime, getRegisteredEvent, getRegisteredListener, isEventDefinition, isListenerDefinition, listRegisteredEvents, listRegisteredListeners, listRegisteredListenersForEvent, normalizeEventDefinition, normalizeListenerDefinition, registerEvent, registerEvents, registerListener, registerListeners, resetEventRegistry, resetEventsRegistry, resetEventsRuntime, resetListenerRegistry, runQueuedListenerInvocation, unregisterEvent, unregisterListener };
+export { EVENTS_INVOKE_LISTENER_JOB, Event, configureEventsRuntime, deferEventDispatchToDatabaseCommit, defineEvent, defineListener, dispatchEvent, ensureEventsQueueJobRegistered, ensureEventsQueueJobRegisteredAsync, eventInternals, eventQueueInternals, eventRegistryInternals, eventRuntimeInternals, getEventsRuntime, getRegisteredEvent, getRegisteredListener, isEventDefinition, isListenerDefinition, listRegisteredEvents, listRegisteredListeners, listRegisteredListenersForEvent, normalizeEventDefinition, normalizeListenerDefinition, registerEvent, registerEvents, registerListener, registerListeners, resetEventRegistry, resetEventsRegistry, resetEventsRuntime, resetListenerRegistry, runQueuedListenerInvocation, unregisterEvent, unregisterListener };
+export type { DefinedEventDefinition, EventDeferredDispatchContext, EventDefinition, EventDelayValue, EventDispatchResult, EventEnvelope, EventEnvelopeFor, EventFacade, EventPayloadFor, EventPendingDispatch, EventQueuedListenerDispatch, EventReference, EventReferenceInput, EventRuntimeBinding, EventRuntimeHooks, EventsInvokeListenerPayload, ExportedEventDefinition, HoloEventRegistry, HoloListenerRegistry, ListenerDefinition, ListenerDefinitionInput, ListenerHandledEvent, RegisterEventOptions, RegisterListenerOptions, RegisteredEvent, RegisteredListener };

package/dist/index.mjs

@@ -37,6 +37,30 @@ function normalizeOptionalBoolean(value, label) {
   }
   return value;
 }
+function normalizeOptionalTries(value) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error("[Holo Events] Listener tries must be an integer greater than or equal to 1.");
+  }
+  return value;
+}
+function normalizeOptionalBackoff(value) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value) || value < 0) {
+      throw new Error("[Holo Events] Listener backoff must be an integer greater than or equal to 0 or a non-empty array of them.");
+    }
+    return value;
+  }
+  if (!Array.isArray(value) || value.length === 0 || value.some((entry) => !Number.isInteger(entry) || entry < 0)) {
+    throw new Error("[Holo Events] Listener backoff must be an integer greater than or equal to 0 or a non-empty array of them.");
+  }
+  return Object.freeze([...value]);
+}
 function normalizeOptionalDelay(value) {
   if (typeof value === "undefined") {
     return void 0;
@@ -139,7 +163,9 @@ function normalizeListenerDefinition(listener) {
   const queueName = normalizeOptionalString(listener.queueName, "Listener queue name");
   const delay = normalizeOptionalDelay(listener.delay);
   const afterCommit = normalizeOptionalBoolean(listener.afterCommit, "Listener afterCommit");
-  if (queue !== true && (connection || queueName || typeof delay !== "undefined")) {
+  const tries = normalizeOptionalTries(listener.tries);
+  const backoff = normalizeOptionalBackoff(listener.backoff);
+  if (queue !== true && (connection || queueName || typeof delay !== "undefined" || typeof tries !== "undefined" || typeof backoff !== "undefined")) {
     throw new Error("[Holo Events] Listener queue metadata requires queue: true.");
   }
   return {
@@ -150,7 +176,9 @@ function normalizeListenerDefinition(listener) {
     ...typeof connection === "undefined" ? {} : { connection },
     ...typeof queueName === "undefined" ? {} : { queueName },
     ...typeof delay === "undefined" ? {} : { delay },
-    ...typeof afterCommit === "undefined" ? {} : { afterCommit }
+    ...typeof afterCommit === "undefined" ? {} : { afterCommit },
+    ...typeof tries === "undefined" ? {} : { tries },
+    ...typeof backoff === "undefined" ? {} : { backoff }
   };
 }
 function defineListener(listener) {
@@ -411,6 +439,7 @@ function deferEventDispatchToDatabaseCommit(callback, _context) {
 
 // src/queue.ts
 import { createRequire } from "module";
+import { holoRuntimeInternals } from "@holo-js/db";
 var EVENTS_INVOKE_LISTENER_JOB = "holo.events.invoke-listener";
 var require2 = createRequire(import.meta.url);
 var queueSpecifier = "@holo-js/queue";
@@ -455,10 +484,29 @@ function assertQueuedListenerMatchesEvent(listener, eventName) {
     );
   }
 }
-async function runQueuedListenerInvocation(payload) {
+function resolveListenerRetryDelaySeconds(backoff, attempt) {
+  if (typeof backoff === "number") {
+    return backoff;
+  }
+  return backoff[Math.min(Math.max(attempt - 1, 0), backoff.length - 1)] ?? 0;
+}
+async function runQueuedListenerInvocation(payload, context) {
   const listener = requireQueuedListener(payload.listenerId);
   assertQueuedListenerMatchesEvent(listener, payload.eventName);
-  await listener.definition.handle(createQueuedListenerEventEnvelope(payload));
+  try {
+    await listener.definition.handle(createQueuedListenerEventEnvelope(payload));
+  } catch (error) {
+    const { backoff } = listener.definition;
+    if (!context || typeof backoff === "undefined" || context.attempt >= context.maxAttempts) {
+      throw error;
+    }
+    try {
+      await context.release(resolveListenerRetryDelaySeconds(backoff, context.attempt));
+    } catch (releaseError) {
+      holoRuntimeInternals.reportError(releaseError, { capability: "events", operation: "listener.releaseRetry" });
+      throw error;
+    }
+  }
 }
 function registerEventsQueueJob(queue) {
   if (queue.getRegisteredQueueJob(EVENTS_INVOKE_LISTENER_JOB)) {
@@ -482,7 +530,7 @@ async function dispatchQueuedListenerViaQueue(dispatch) {
     eventName: dispatch.event.name,
     occurredAt: dispatch.event.occurredAt,
     payload: dispatch.event.payload
-  });
+  }, typeof dispatch.tries === "undefined" ? {} : { tries: dispatch.tries });
   if (typeof dispatch.connection !== "undefined") {
     pending = pending.onConnection(dispatch.connection);
   }
@@ -599,33 +647,19 @@ function createEventEnvelope(eventName, payload, occurredAt = Date.now()) {
     occurredAt
   });
 }
-function splitRegisteredListeners(listeners) {
-  const syncListeners = [];
-  const queuedListeners = [];
+function splitListenersByCommitTiming(listeners, shouldDeferAll) {
+  const immediateListeners = [];
+  const deferredListeners = [];
   for (const listener of listeners) {
-    if (listener.definition.queue === true) {
-      queuedListeners.push(listener);
+    if (shouldDeferAll || listener.definition.afterCommit === true) {
+      deferredListeners.push(listener);
       continue;
     }
-    syncListeners.push(listener);
-  }
-  return Object.freeze({
-    syncListeners: Object.freeze(syncListeners),
-    queuedListeners: Object.freeze(queuedListeners)
-  });
-}
-async function executeSyncListeners(listeners, event) {
-  for (const listener of listeners) {
-    await executeListener(listener, event);
+    immediateListeners.push(listener);
   }
-  return listeners.length;
-}
-async function executeListenerGroups(syncListeners, queuedListeners, event, options) {
-  const syncCount = await executeSyncListeners(syncListeners, event);
-  const queuedCount = await dispatchQueuedListeners(queuedListeners, event, options);
   return Object.freeze({
-    syncCount,
-    queuedCount
+    immediateListeners: Object.freeze(immediateListeners),
+    deferredListeners: Object.freeze(deferredListeners)
   });
 }
 async function executeListener(listener, event) {
@@ -637,53 +671,22 @@ function createQueuedListenerDispatch(listener, event, options) {
     event,
     ...typeof (options.connection ?? listener.definition.connection) === "undefined" ? {} : { connection: options.connection ?? listener.definition.connection },
     ...typeof (options.queueName ?? listener.definition.queueName) === "undefined" ? {} : { queueName: options.queueName ?? listener.definition.queueName },
-    ...typeof (options.delay ?? listener.definition.delay) === "undefined" ? {} : { delay: options.delay ?? listener.definition.delay }
+    ...typeof (options.delay ?? listener.definition.delay) === "undefined" ? {} : { delay: options.delay ?? listener.definition.delay },
+    ...typeof listener.definition.tries === "undefined" ? {} : { tries: listener.definition.tries }
   });
 }
-async function dispatchQueuedListeners(listeners, event, options) {
-  if (listeners.length === 0) {
-    return 0;
-  }
-  validateQueuedEventPayload(event.payload);
+async function dispatchQueuedListener(listener, event, options) {
   const dispatcher = getRuntimeState().hooks.dispatchQueuedListener ?? dispatchQueuedListenerViaQueue;
-  for (const listener of listeners) {
-    await dispatcher(createQueuedListenerDispatch(listener, event, options));
-  }
-  return listeners.length;
+  await dispatcher(createQueuedListenerDispatch(listener, event, options));
 }
-function splitListenersForExecution(listeners, forceAfterCommit) {
-  const immediateSyncListeners = [];
-  const immediateQueuedListeners = [];
-  const deferredSyncListeners = [];
-  const deferredQueuedListeners = [];
+async function runListenersInOrder(listeners, event, options) {
   for (const listener of listeners) {
-    const shouldDefer = forceAfterCommit || listener.definition.afterCommit === true;
-    if (shouldDefer) {
-      if (listener.definition.queue === true) {
-        deferredQueuedListeners.push(listener);
-        continue;
-      }
-      deferredSyncListeners.push(listener);
-      continue;
-    }
     if (listener.definition.queue === true) {
-      immediateQueuedListeners.push(listener);
+      await dispatchQueuedListener(listener, event, options);
       continue;
     }
-    immediateSyncListeners.push(listener);
-  }
-  return Object.freeze({
-    immediateSyncListeners: Object.freeze(immediateSyncListeners),
-    immediateQueuedListeners: Object.freeze(immediateQueuedListeners),
-    deferredSyncListeners: Object.freeze(deferredSyncListeners),
-    deferredQueuedListeners: Object.freeze(deferredQueuedListeners)
-  });
-}
-function validateQueuedPayloadForExecutionGroups(groups, payload) {
-  if (groups.immediateQueuedListeners.length === 0 && groups.deferredQueuedListeners.length === 0) {
-    return;
+    await executeListener(listener, event);
   }
-  validateQueuedEventPayload(payload);
 }
 function scheduleDeferredDispatch(callback, eventName) {
   const defer = getRuntimeState().hooks.defer ?? deferEventDispatchToDatabaseCommit;
@@ -697,61 +700,38 @@ async function executeDispatch(event, payload, options = {}) {
   requireRegisteredEvent(eventName);
   const envelope = createEventEnvelope(eventName, payload);
   const listeners = listRegisteredListenersForEvent(eventName);
-  const groups = splitListenersForExecution(listeners, options.afterCommit === true);
-  validateQueuedPayloadForExecutionGroups(groups, envelope.payload);
-  if (options.afterCommit) {
-    const scheduled = scheduleDeferredDispatch(async () => {
-      await executeListenerGroups(
-        [...groups.immediateSyncListeners, ...groups.deferredSyncListeners],
-        [...groups.immediateQueuedListeners, ...groups.deferredQueuedListeners],
-        envelope,
-        options
-      );
-    }, eventName);
-    if (scheduled) {
-      return Object.freeze({
-        eventName,
-        occurredAt: envelope.occurredAt,
-        deferred: true,
-        syncListeners: groups.immediateSyncListeners.length + groups.deferredSyncListeners.length,
-        queuedListeners: groups.immediateQueuedListeners.length + groups.deferredQueuedListeners.length
-      });
-    }
-  }
-  const immediate = await executeListenerGroups(
-    groups.immediateSyncListeners,
-    groups.immediateQueuedListeners,
-    envelope,
-    options
-  );
-  let deferred = false;
-  if (groups.deferredSyncListeners.length > 0 || groups.deferredQueuedListeners.length > 0) {
-    const scheduled = scheduleDeferredDispatch(async () => {
-      await executeListenerGroups(
-        groups.deferredSyncListeners,
-        groups.deferredQueuedListeners,
-        envelope,
-        options
-      );
-    }, eventName);
-    if (scheduled) {
-      deferred = true;
-    } else {
-      await executeListenerGroups(
-        groups.deferredSyncListeners,
-        groups.deferredQueuedListeners,
-        envelope,
-        options
-      );
-    }
+  const queuedListeners = listeners.filter((listener) => listener.definition.queue === true).length;
+  if (queuedListeners > 0) {
+    validateQueuedEventPayload(envelope.payload);
   }
-  return Object.freeze({
+  const createResult = (deferred) => Object.freeze({
     eventName,
     occurredAt: envelope.occurredAt,
     deferred,
-    syncListeners: immediate.syncCount + groups.deferredSyncListeners.length,
-    queuedListeners: immediate.queuedCount + groups.deferredQueuedListeners.length
+    syncListeners: listeners.length - queuedListeners,
+    queuedListeners
   });
+  const { immediateListeners, deferredListeners } = splitListenersByCommitTiming(
+    listeners,
+    options.afterCommit === true
+  );
+  if (deferredListeners.length === 0) {
+    await runListenersInOrder(listeners, envelope, options);
+    return createResult(false);
+  }
+  let immediatePhaseCompleted = false;
+  const scheduled = scheduleDeferredDispatch(async () => {
+    if (immediatePhaseCompleted) {
+      await runListenersInOrder(deferredListeners, envelope, options);
+    }
+  }, eventName);
+  if (!scheduled) {
+    await runListenersInOrder(listeners, envelope, options);
+    return createResult(false);
+  }
+  await runListenersInOrder(immediateListeners, envelope, options);
+  immediatePhaseCompleted = true;
+  return createResult(true);
 }
 var PendingEventDispatch = class _PendingEventDispatch {
   constructor(event, payload, options = {}) {
@@ -759,6 +739,8 @@ var PendingEventDispatch = class _PendingEventDispatch {
     this.payload = payload;
     this.options = options;
   }
+  event;
+  payload;
   options;
   executionPromise;
   afterCommit() {
@@ -826,19 +808,17 @@ var eventRuntimeInternals = {
   createEventEnvelope,
   createQueuedListenerDispatch,
   createRuntimeBinding,
-  dispatchQueuedListeners,
-  executeListenerGroups,
+  dispatchQueuedListener,
   executeDispatch,
   executeListener,
-  executeSyncListeners,
+  runListenersInOrder,
   getRuntimeState,
   isPlainObject: isPlainObject2,
   normalizeEventName,
   requireRegisteredEvent,
   resolveDispatchedEventName,
   scheduleDeferredDispatch,
-  splitRegisteredListeners,
-  splitListenersForExecution,
+  splitListenersByCommitTiming,
   validateQueuedEventPayload
 };
 export {

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@holo-js/events",
-  "version": "0.3.28",
+  "version": "0.4.1",
   "description": "Holo-JS Framework - event contracts and runtime surface",
   "type": "module",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cobraprojects/holo-js.git",
+    "directory": "packages/events"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -14,7 +19,8 @@
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
   "scripts": {
     "build": "tsup",
@@ -23,10 +29,10 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/db": "^0.3.28"
+    "@holo-js/db": "^0.4.1"
   },
   "peerDependencies": {
-    "@holo-js/queue": "^0.3.28"
+    "@holo-js/queue": "^0.4.1"
   },
   "peerDependenciesMeta": {
     "@holo-js/queue": {
@@ -34,13 +40,13 @@
     }
   },
   "devDependencies": {
-    "@holo-js/queue": "^0.3.28",
-    "@types/node": "^22.10.2",
-    "tsup": "^8.3.5",
-    "typescript": "^5.7.2",
-    "vitest": "^4.1.5"
+    "@holo-js/queue": "^0.4.1",
+    "@types/node": "^22.20.5",
+    "tsup": "^9.0.0",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.5"
   },
   "engines": {
-    "node": "^22.12.0 || ^24.0.0 || ^26.0.0"
+    "node": "^22.18.0 || ^24.0.0 || ^26.0.0"
   }
 }