@eclesia/indexer-engine 2.14.5 → 2.16.0

package/dist/_virtual/rolldown_runtime.cjs

@@ -5,24 +5,30 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (all) => {
+var __export = (all, symbols) => {
 	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
 	return target;
 };
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
 	}
 	return to;
 };
@@ -33,6 +39,5 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 
-exports.__commonJS = __commonJS;
 exports.__export = __export;
 exports.__toESM = __toESM;

package/dist/_virtual/rolldown_runtime.mjs

@@ -1,38 +1,18 @@
-import { createRequire } from "node:module";
-
 //#region rolldown:runtime
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (all) => {
+var __export = (all, symbols) => {
 	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
 		});
 	}
-	return to;
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
-export { __commonJS, __export, __require, __toESM };
+export { __export };

package/dist/constants.cjs

@@ -37,11 +37,35 @@ const CONNECT_TIMEOUT_MS = 1e4;
 */
 const RPC_TIMEOUT_MS = 2e4;
 /**
-* Timeout for block queue dequeue operations in milliseconds
-* If no block is available within this time, an error will be thrown
+* @deprecated Waiting for a block is no longer bounded by a timeout: an idle chain is not an
+* error. Kept as an export for compatibility; see IDLE_CHECK_INTERVAL_MS.
 */
 const QUEUE_DEQUEUE_TIMEOUT_MS = 3e4;
 /**
+* How long the indexer waits without any block announcement before checking the chain height.
+* If the chain has moved on without us the subscription is dead and a recovery is triggered;
+* if the chain is simply idle (halt, upgrade) the indexer reports WAITING and checks again.
+*/
+const IDLE_CHECK_INTERVAL_MS = 3e4;
+/**
+* Delay before the first restart after a failure; doubles on every consecutive failure
+*/
+const RETRY_BASE_DELAY_MS = 5e3;
+/**
+* Upper bound for the restart delay
+*/
+const RETRY_MAX_DELAY_MS = 3e5;
+/**
+* Consecutive processing failures on the same block before the indexer gives up with a
+* fatal-error. A block that keeps failing after its data was fetched is a bug or bad data, not
+* an outage, and retrying it forever hides the problem.
+*/
+const MAX_FAILURES_PER_BLOCK = 5;
+/**
+* Address the health check and metrics servers bind to unless configured otherwise
+*/
+const DEFAULT_BIND_HOST = "0.0.0.0";
+/**
 * Number of successful transactions before recycling the database client
 * Prevents long-running connection issues and stale connections
 */
@@ -72,13 +96,18 @@ const GENESIS_BATCH_SIZE = 1e3;
 exports.CONNECT_TIMEOUT_MS = CONNECT_TIMEOUT_MS;
 exports.DB_CLIENT_RECYCLE_COUNT = DB_CLIENT_RECYCLE_COUNT;
 exports.DEFAULT_BATCH_SIZE = DEFAULT_BATCH_SIZE;
+exports.DEFAULT_BIND_HOST = DEFAULT_BIND_HOST;
 exports.DEFAULT_HEALTH_CHECK_PORT = DEFAULT_HEALTH_CHECK_PORT;
 exports.DEFAULT_POLLING_INTERVAL_MS = DEFAULT_POLLING_INTERVAL_MS;
 exports.DEFAULT_PROMETHEUS_PORT = DEFAULT_PROMETHEUS_PORT;
 exports.DEFAULT_START_HEIGHT = DEFAULT_START_HEIGHT;
 exports.GENESIS_BATCH_SIZE = GENESIS_BATCH_SIZE;
+exports.IDLE_CHECK_INTERVAL_MS = IDLE_CHECK_INTERVAL_MS;
+exports.MAX_FAILURES_PER_BLOCK = MAX_FAILURES_PER_BLOCK;
 exports.PAGINATION_LIMITS = PAGINATION_LIMITS;
 exports.PERIODIC_INTERVALS = PERIODIC_INTERVALS;
 exports.QUEUE_DEQUEUE_TIMEOUT_MS = QUEUE_DEQUEUE_TIMEOUT_MS;
+exports.RETRY_BASE_DELAY_MS = RETRY_BASE_DELAY_MS;
+exports.RETRY_MAX_DELAY_MS = RETRY_MAX_DELAY_MS;
 exports.RPC_TIMEOUT_MS = RPC_TIMEOUT_MS;
 //# sourceMappingURL=constants.cjs.map

package/dist/constants.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.cjs","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Configuration constants for the Eclesia indexer\n * These values control performance, timeouts, and connection management\n */\n\n/**\n * Number of blocks to prefetch and keep in the processing queue\n * Higher values increase memory usage but improve throughput\n * Recommended range: 300-1000 depending on block size and available memory\n */\nexport const DEFAULT_BATCH_SIZE = 500;\n\n/**\n * Default start height for indexing when no previous height is found\n */\nexport const DEFAULT_START_HEIGHT = 1;\n\n/**\n * Default port for health check HTTP server\n */\nexport const DEFAULT_HEALTH_CHECK_PORT = 8888;\n\n/**\n * Default port for Prometheus metrics server\n */\nexport const DEFAULT_PROMETHEUS_PORT = 9090;\n\n/**\n * Default polling interval in milliseconds when using polling mode instead of WebSocket\n */\nexport const DEFAULT_POLLING_INTERVAL_MS = 5000;\n\n/**\n * Timeout for connecting to the Tendermint RPC in milliseconds\n * If connection is not established within this time, it will be aborted\n  */\nexport const CONNECT_TIMEOUT_MS = 10000;\n\n/**\n * Timeout for RPC calls in milliseconds\n * If a call takes longer than this, it will be rejected\n */\nexport const RPC_TIMEOUT_MS = 20000;\n\n/**\n * Timeout for block queue dequeue operations in milliseconds\n * If no block is available within this time, an error will be thrown\n */\nexport const QUEUE_DEQUEUE_TIMEOUT_MS = 30000;\n\n/**\n * Number of successful transactions before recycling the database client\n * Prevents long-running connection issues and stale connections\n */\nexport const DB_CLIENT_RECYCLE_COUNT = 1500;\n\n/**\n * Block intervals for periodic event emission\n * Used for operations that should run at regular block intervals\n */\nexport const PERIODIC_INTERVALS = {\n  /** Emit periodic event every 50 blocks */\n  SMALL: 50,\n  /** Emit periodic event every 100 blocks */\n  MEDIUM: 100,\n  /** Emit periodic event every 1000 blocks - used for performance logging */\n  LARGE: 1000,\n} as const;\n\n/**\n * Pagination limits for blockchain queries\n */\nexport const PAGINATION_LIMITS = {\n  /** Default limit for validator queries */\n  VALIDATORS: 1000n,\n  /** Default limit for delegation queries */\n  DELEGATIONS: 250n,\n} as const;\n\n/**\n * Batch size for streaming genesis file processing\n * Number of entries to process at once from genesis JSON\n */\nexport const GENESIS_BATCH_SIZE = 1000;\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,qBAAqB;;;;AAKlC,MAAa,uBAAuB;;;;AAKpC,MAAa,4BAA4B;;;;AAKzC,MAAa,0BAA0B;;;;AAKvC,MAAa,8BAA8B;;;;;AAM3C,MAAa,qBAAqB;;;;;AAMlC,MAAa,iBAAiB;;;;;AAM9B,MAAa,2BAA2B;;;;;AAMxC,MAAa,0BAA0B;;;;;AAMvC,MAAa,qBAAqB;CAEhC,OAAO;CAEP,QAAQ;CAER,OAAO;CACR;;;;AAKD,MAAa,oBAAoB;CAE/B,YAAY;CAEZ,aAAa;CACd;;;;;AAMD,MAAa,qBAAqB"}
+{"version":3,"file":"constants.cjs","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Configuration constants for the Eclesia indexer\n * These values control performance, timeouts, and connection management\n */\n\n/**\n * Number of blocks to prefetch and keep in the processing queue\n * Higher values increase memory usage but improve throughput\n * Recommended range: 300-1000 depending on block size and available memory\n */\nexport const DEFAULT_BATCH_SIZE = 500;\n\n/**\n * Default start height for indexing when no previous height is found\n */\nexport const DEFAULT_START_HEIGHT = 1;\n\n/**\n * Default port for health check HTTP server\n */\nexport const DEFAULT_HEALTH_CHECK_PORT = 8888;\n\n/**\n * Default port for Prometheus metrics server\n */\nexport const DEFAULT_PROMETHEUS_PORT = 9090;\n\n/**\n * Default polling interval in milliseconds when using polling mode instead of WebSocket\n */\nexport const DEFAULT_POLLING_INTERVAL_MS = 5000;\n\n/**\n * Timeout for connecting to the Tendermint RPC in milliseconds\n * If connection is not established within this time, it will be aborted\n  */\nexport const CONNECT_TIMEOUT_MS = 10000;\n\n/**\n * Timeout for RPC calls in milliseconds\n * If a call takes longer than this, it will be rejected\n */\nexport const RPC_TIMEOUT_MS = 20000;\n\n/**\n * @deprecated Waiting for a block is no longer bounded by a timeout: an idle chain is not an\n * error. Kept as an export for compatibility; see IDLE_CHECK_INTERVAL_MS.\n */\nexport const QUEUE_DEQUEUE_TIMEOUT_MS = 30000;\n\n/**\n * How long the indexer waits without any block announcement before checking the chain height.\n * If the chain has moved on without us the subscription is dead and a recovery is triggered;\n * if the chain is simply idle (halt, upgrade) the indexer reports WAITING and checks again.\n */\nexport const IDLE_CHECK_INTERVAL_MS = 30000;\n\n/**\n * Delay before the first restart after a failure; doubles on every consecutive failure\n */\nexport const RETRY_BASE_DELAY_MS = 5000;\n\n/**\n * Upper bound for the restart delay\n */\nexport const RETRY_MAX_DELAY_MS = 300000;\n\n/**\n * Consecutive processing failures on the same block before the indexer gives up with a\n * fatal-error. A block that keeps failing after its data was fetched is a bug or bad data, not\n * an outage, and retrying it forever hides the problem.\n */\nexport const MAX_FAILURES_PER_BLOCK = 5;\n\n/**\n * Address the health check and metrics servers bind to unless configured otherwise\n */\nexport const DEFAULT_BIND_HOST = \"0.0.0.0\";\n\n/**\n * Number of successful transactions before recycling the database client\n * Prevents long-running connection issues and stale connections\n */\nexport const DB_CLIENT_RECYCLE_COUNT = 1500;\n\n/**\n * Block intervals for periodic event emission\n * Used for operations that should run at regular block intervals\n */\nexport const PERIODIC_INTERVALS = {\n  /** Emit periodic event every 50 blocks */\n  SMALL: 50,\n  /** Emit periodic event every 100 blocks */\n  MEDIUM: 100,\n  /** Emit periodic event every 1000 blocks - used for performance logging */\n  LARGE: 1000,\n} as const;\n\n/**\n * Pagination limits for blockchain queries\n */\nexport const PAGINATION_LIMITS = {\n  /** Default limit for validator queries */\n  VALIDATORS: 1000n,\n  /** Default limit for delegation queries */\n  DELEGATIONS: 250n,\n} as const;\n\n/**\n * Batch size for streaming genesis file processing\n * Number of entries to process at once from genesis JSON\n */\nexport const GENESIS_BATCH_SIZE = 1000;\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,qBAAqB;;;;AAKlC,MAAa,uBAAuB;;;;AAKpC,MAAa,4BAA4B;;;;AAKzC,MAAa,0BAA0B;;;;AAKvC,MAAa,8BAA8B;;;;;AAM3C,MAAa,qBAAqB;;;;;AAMlC,MAAa,iBAAiB;;;;;AAM9B,MAAa,2BAA2B;;;;;;AAOxC,MAAa,yBAAyB;;;;AAKtC,MAAa,sBAAsB;;;;AAKnC,MAAa,qBAAqB;;;;;;AAOlC,MAAa,yBAAyB;;;;AAKtC,MAAa,oBAAoB;;;;;AAMjC,MAAa,0BAA0B;;;;;AAMvC,MAAa,qBAAqB;CAEhC,OAAO;CAEP,QAAQ;CAER,OAAO;CACR;;;;AAKD,MAAa,oBAAoB;CAE/B,YAAY;CAEZ,aAAa;CACd;;;;;AAMD,MAAa,qBAAqB"}

package/dist/constants.d.cts

@@ -36,10 +36,34 @@ declare const CONNECT_TIMEOUT_MS = 10000;
  */
 declare const RPC_TIMEOUT_MS = 20000;
 /**
- * Timeout for block queue dequeue operations in milliseconds
- * If no block is available within this time, an error will be thrown
+ * @deprecated Waiting for a block is no longer bounded by a timeout: an idle chain is not an
+ * error. Kept as an export for compatibility; see IDLE_CHECK_INTERVAL_MS.
  */
 declare const QUEUE_DEQUEUE_TIMEOUT_MS = 30000;
+/**
+ * How long the indexer waits without any block announcement before checking the chain height.
+ * If the chain has moved on without us the subscription is dead and a recovery is triggered;
+ * if the chain is simply idle (halt, upgrade) the indexer reports WAITING and checks again.
+ */
+declare const IDLE_CHECK_INTERVAL_MS = 30000;
+/**
+ * Delay before the first restart after a failure; doubles on every consecutive failure
+ */
+declare const RETRY_BASE_DELAY_MS = 5000;
+/**
+ * Upper bound for the restart delay
+ */
+declare const RETRY_MAX_DELAY_MS = 300000;
+/**
+ * Consecutive processing failures on the same block before the indexer gives up with a
+ * fatal-error. A block that keeps failing after its data was fetched is a bug or bad data, not
+ * an outage, and retrying it forever hides the problem.
+ */
+declare const MAX_FAILURES_PER_BLOCK = 5;
+/**
+ * Address the health check and metrics servers bind to unless configured otherwise
+ */
+declare const DEFAULT_BIND_HOST = "0.0.0.0";
 /**
  * Number of successful transactions before recycling the database client
  * Prevents long-running connection issues and stale connections
@@ -72,5 +96,5 @@ declare const PAGINATION_LIMITS: {
  */
 declare const GENESIS_BATCH_SIZE = 1000;
 //#endregion
-export { CONNECT_TIMEOUT_MS, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS };
+export { CONNECT_TIMEOUT_MS, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_BIND_HOST, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, IDLE_CHECK_INTERVAL_MS, MAX_FAILURES_PER_BLOCK, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RETRY_BASE_DELAY_MS, RETRY_MAX_DELAY_MS, RPC_TIMEOUT_MS };
 //# sourceMappingURL=constants.d.cts.map

package/dist/constants.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.cts","names":[],"sources":["../src/constants.ts"],"sourcesContent":[],"mappings":";;AAUA;AAKA;AAKA;AAKA;AAKA;AAMA;AAMA;AAMA;AAMa,cA5CA,kBAAA,GA4CuB,GAAA;AAMpC;AAYA;AAWA;cApEa,oBAAA;;;;cAKA,yBAAA;;;;cAKA,uBAAA;;;;cAKA,2BAAA;;;;;cAMA,kBAAA;;;;;cAMA,cAAA;;;;;cAMA,wBAAA;;;;;cAMA,uBAAA;;;;;cAMA;;;;;;;;;;;cAYA;;;;;;;;;;cAWA,kBAAA"}
+{"version":3,"file":"constants.d.cts","names":[],"sources":["../src/constants.ts"],"sourcesContent":[],"mappings":";;AAUA;AAKA;AAKA;AAKA;AAKA;AAMA;AAMA;AAMA;AAOa,cA7CA,kBAAA,GA6CsB,GAAA;AAKnC;AAKA;AAOA;AAKa,cA9DA,oBAAA,GA8DiB,CAAA;AAM9B;AAMA;AAYA;AAWa,cA5FA,yBAAA,GA4FkB,IAAA;;;;cAvFlB,uBAAA;;;;cAKA,2BAAA;;;;;cAMA,kBAAA;;;;;cAMA,cAAA;;;;;cAMA,wBAAA;;;;;;cAOA,sBAAA;;;;cAKA,mBAAA;;;;cAKA,kBAAA;;;;;;cAOA,sBAAA;;;;cAKA,iBAAA;;;;;cAMA,uBAAA;;;;;cAMA;;;;;;;;;;;cAYA;;;;;;;;;;cAWA,kBAAA"}

package/dist/constants.d.mts

@@ -36,10 +36,34 @@ declare const CONNECT_TIMEOUT_MS = 10000;
  */
 declare const RPC_TIMEOUT_MS = 20000;
 /**
- * Timeout for block queue dequeue operations in milliseconds
- * If no block is available within this time, an error will be thrown
+ * @deprecated Waiting for a block is no longer bounded by a timeout: an idle chain is not an
+ * error. Kept as an export for compatibility; see IDLE_CHECK_INTERVAL_MS.
  */
 declare const QUEUE_DEQUEUE_TIMEOUT_MS = 30000;
+/**
+ * How long the indexer waits without any block announcement before checking the chain height.
+ * If the chain has moved on without us the subscription is dead and a recovery is triggered;
+ * if the chain is simply idle (halt, upgrade) the indexer reports WAITING and checks again.
+ */
+declare const IDLE_CHECK_INTERVAL_MS = 30000;
+/**
+ * Delay before the first restart after a failure; doubles on every consecutive failure
+ */
+declare const RETRY_BASE_DELAY_MS = 5000;
+/**
+ * Upper bound for the restart delay
+ */
+declare const RETRY_MAX_DELAY_MS = 300000;
+/**
+ * Consecutive processing failures on the same block before the indexer gives up with a
+ * fatal-error. A block that keeps failing after its data was fetched is a bug or bad data, not
+ * an outage, and retrying it forever hides the problem.
+ */
+declare const MAX_FAILURES_PER_BLOCK = 5;
+/**
+ * Address the health check and metrics servers bind to unless configured otherwise
+ */
+declare const DEFAULT_BIND_HOST = "0.0.0.0";
 /**
  * Number of successful transactions before recycling the database client
  * Prevents long-running connection issues and stale connections
@@ -72,5 +96,5 @@ declare const PAGINATION_LIMITS: {
  */
 declare const GENESIS_BATCH_SIZE = 1000;
 //#endregion
-export { CONNECT_TIMEOUT_MS, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS };
+export { CONNECT_TIMEOUT_MS, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_BIND_HOST, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, IDLE_CHECK_INTERVAL_MS, MAX_FAILURES_PER_BLOCK, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RETRY_BASE_DELAY_MS, RETRY_MAX_DELAY_MS, RPC_TIMEOUT_MS };
 //# sourceMappingURL=constants.d.mts.map

package/dist/constants.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.mts","names":[],"sources":["../src/constants.ts"],"sourcesContent":[],"mappings":";;AAUA;AAKA;AAKA;AAKA;AAKA;AAMA;AAMA;AAMA;AAMa,cA5CA,kBAAA,GA4CuB,GAAA;AAMpC;AAYA;AAWA;cApEa,oBAAA;;;;cAKA,yBAAA;;;;cAKA,uBAAA;;;;cAKA,2BAAA;;;;;cAMA,kBAAA;;;;;cAMA,cAAA;;;;;cAMA,wBAAA;;;;;cAMA,uBAAA;;;;;cAMA;;;;;;;;;;;cAYA;;;;;;;;;;cAWA,kBAAA"}
+{"version":3,"file":"constants.d.mts","names":[],"sources":["../src/constants.ts"],"sourcesContent":[],"mappings":";;AAUA;AAKA;AAKA;AAKA;AAKA;AAMA;AAMA;AAMA;AAOa,cA7CA,kBAAA,GA6CsB,GAAA;AAKnC;AAKA;AAOA;AAKa,cA9DA,oBAAA,GA8DiB,CAAA;AAM9B;AAMA;AAYA;AAWa,cA5FA,yBAAA,GA4FkB,IAAA;;;;cAvFlB,uBAAA;;;;cAKA,2BAAA;;;;;cAMA,kBAAA;;;;;cAMA,cAAA;;;;;cAMA,wBAAA;;;;;;cAOA,sBAAA;;;;cAKA,mBAAA;;;;cAKA,kBAAA;;;;;;cAOA,sBAAA;;;;cAKA,iBAAA;;;;;cAMA,uBAAA;;;;;cAMA;;;;;;;;;;;cAYA;;;;;;;;;;cAWA,kBAAA"}

package/dist/constants.mjs

@@ -36,11 +36,35 @@ const CONNECT_TIMEOUT_MS = 1e4;
 */
 const RPC_TIMEOUT_MS = 2e4;
 /**
-* Timeout for block queue dequeue operations in milliseconds
-* If no block is available within this time, an error will be thrown
+* @deprecated Waiting for a block is no longer bounded by a timeout: an idle chain is not an
+* error. Kept as an export for compatibility; see IDLE_CHECK_INTERVAL_MS.
 */
 const QUEUE_DEQUEUE_TIMEOUT_MS = 3e4;
 /**
+* How long the indexer waits without any block announcement before checking the chain height.
+* If the chain has moved on without us the subscription is dead and a recovery is triggered;
+* if the chain is simply idle (halt, upgrade) the indexer reports WAITING and checks again.
+*/
+const IDLE_CHECK_INTERVAL_MS = 3e4;
+/**
+* Delay before the first restart after a failure; doubles on every consecutive failure
+*/
+const RETRY_BASE_DELAY_MS = 5e3;
+/**
+* Upper bound for the restart delay
+*/
+const RETRY_MAX_DELAY_MS = 3e5;
+/**
+* Consecutive processing failures on the same block before the indexer gives up with a
+* fatal-error. A block that keeps failing after its data was fetched is a bug or bad data, not
+* an outage, and retrying it forever hides the problem.
+*/
+const MAX_FAILURES_PER_BLOCK = 5;
+/**
+* Address the health check and metrics servers bind to unless configured otherwise
+*/
+const DEFAULT_BIND_HOST = "0.0.0.0";
+/**
 * Number of successful transactions before recycling the database client
 * Prevents long-running connection issues and stale connections
 */
@@ -68,5 +92,5 @@ const PAGINATION_LIMITS = {
 const GENESIS_BATCH_SIZE = 1e3;
 
 //#endregion
-export { CONNECT_TIMEOUT_MS, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS };
+export { CONNECT_TIMEOUT_MS, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_BIND_HOST, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, IDLE_CHECK_INTERVAL_MS, MAX_FAILURES_PER_BLOCK, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RETRY_BASE_DELAY_MS, RETRY_MAX_DELAY_MS, RPC_TIMEOUT_MS };
 //# sourceMappingURL=constants.mjs.map

package/dist/constants.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.mjs","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Configuration constants for the Eclesia indexer\n * These values control performance, timeouts, and connection management\n */\n\n/**\n * Number of blocks to prefetch and keep in the processing queue\n * Higher values increase memory usage but improve throughput\n * Recommended range: 300-1000 depending on block size and available memory\n */\nexport const DEFAULT_BATCH_SIZE = 500;\n\n/**\n * Default start height for indexing when no previous height is found\n */\nexport const DEFAULT_START_HEIGHT = 1;\n\n/**\n * Default port for health check HTTP server\n */\nexport const DEFAULT_HEALTH_CHECK_PORT = 8888;\n\n/**\n * Default port for Prometheus metrics server\n */\nexport const DEFAULT_PROMETHEUS_PORT = 9090;\n\n/**\n * Default polling interval in milliseconds when using polling mode instead of WebSocket\n */\nexport const DEFAULT_POLLING_INTERVAL_MS = 5000;\n\n/**\n * Timeout for connecting to the Tendermint RPC in milliseconds\n * If connection is not established within this time, it will be aborted\n  */\nexport const CONNECT_TIMEOUT_MS = 10000;\n\n/**\n * Timeout for RPC calls in milliseconds\n * If a call takes longer than this, it will be rejected\n */\nexport const RPC_TIMEOUT_MS = 20000;\n\n/**\n * Timeout for block queue dequeue operations in milliseconds\n * If no block is available within this time, an error will be thrown\n */\nexport const QUEUE_DEQUEUE_TIMEOUT_MS = 30000;\n\n/**\n * Number of successful transactions before recycling the database client\n * Prevents long-running connection issues and stale connections\n */\nexport const DB_CLIENT_RECYCLE_COUNT = 1500;\n\n/**\n * Block intervals for periodic event emission\n * Used for operations that should run at regular block intervals\n */\nexport const PERIODIC_INTERVALS = {\n  /** Emit periodic event every 50 blocks */\n  SMALL: 50,\n  /** Emit periodic event every 100 blocks */\n  MEDIUM: 100,\n  /** Emit periodic event every 1000 blocks - used for performance logging */\n  LARGE: 1000,\n} as const;\n\n/**\n * Pagination limits for blockchain queries\n */\nexport const PAGINATION_LIMITS = {\n  /** Default limit for validator queries */\n  VALIDATORS: 1000n,\n  /** Default limit for delegation queries */\n  DELEGATIONS: 250n,\n} as const;\n\n/**\n * Batch size for streaming genesis file processing\n * Number of entries to process at once from genesis JSON\n */\nexport const GENESIS_BATCH_SIZE = 1000;\n"],"mappings":";;;;;;;;;;AAUA,MAAa,qBAAqB;;;;AAKlC,MAAa,uBAAuB;;;;AAKpC,MAAa,4BAA4B;;;;AAKzC,MAAa,0BAA0B;;;;AAKvC,MAAa,8BAA8B;;;;;AAM3C,MAAa,qBAAqB;;;;;AAMlC,MAAa,iBAAiB;;;;;AAM9B,MAAa,2BAA2B;;;;;AAMxC,MAAa,0BAA0B;;;;;AAMvC,MAAa,qBAAqB;CAEhC,OAAO;CAEP,QAAQ;CAER,OAAO;CACR;;;;AAKD,MAAa,oBAAoB;CAE/B,YAAY;CAEZ,aAAa;CACd;;;;;AAMD,MAAa,qBAAqB"}
+{"version":3,"file":"constants.mjs","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Configuration constants for the Eclesia indexer\n * These values control performance, timeouts, and connection management\n */\n\n/**\n * Number of blocks to prefetch and keep in the processing queue\n * Higher values increase memory usage but improve throughput\n * Recommended range: 300-1000 depending on block size and available memory\n */\nexport const DEFAULT_BATCH_SIZE = 500;\n\n/**\n * Default start height for indexing when no previous height is found\n */\nexport const DEFAULT_START_HEIGHT = 1;\n\n/**\n * Default port for health check HTTP server\n */\nexport const DEFAULT_HEALTH_CHECK_PORT = 8888;\n\n/**\n * Default port for Prometheus metrics server\n */\nexport const DEFAULT_PROMETHEUS_PORT = 9090;\n\n/**\n * Default polling interval in milliseconds when using polling mode instead of WebSocket\n */\nexport const DEFAULT_POLLING_INTERVAL_MS = 5000;\n\n/**\n * Timeout for connecting to the Tendermint RPC in milliseconds\n * If connection is not established within this time, it will be aborted\n  */\nexport const CONNECT_TIMEOUT_MS = 10000;\n\n/**\n * Timeout for RPC calls in milliseconds\n * If a call takes longer than this, it will be rejected\n */\nexport const RPC_TIMEOUT_MS = 20000;\n\n/**\n * @deprecated Waiting for a block is no longer bounded by a timeout: an idle chain is not an\n * error. Kept as an export for compatibility; see IDLE_CHECK_INTERVAL_MS.\n */\nexport const QUEUE_DEQUEUE_TIMEOUT_MS = 30000;\n\n/**\n * How long the indexer waits without any block announcement before checking the chain height.\n * If the chain has moved on without us the subscription is dead and a recovery is triggered;\n * if the chain is simply idle (halt, upgrade) the indexer reports WAITING and checks again.\n */\nexport const IDLE_CHECK_INTERVAL_MS = 30000;\n\n/**\n * Delay before the first restart after a failure; doubles on every consecutive failure\n */\nexport const RETRY_BASE_DELAY_MS = 5000;\n\n/**\n * Upper bound for the restart delay\n */\nexport const RETRY_MAX_DELAY_MS = 300000;\n\n/**\n * Consecutive processing failures on the same block before the indexer gives up with a\n * fatal-error. A block that keeps failing after its data was fetched is a bug or bad data, not\n * an outage, and retrying it forever hides the problem.\n */\nexport const MAX_FAILURES_PER_BLOCK = 5;\n\n/**\n * Address the health check and metrics servers bind to unless configured otherwise\n */\nexport const DEFAULT_BIND_HOST = \"0.0.0.0\";\n\n/**\n * Number of successful transactions before recycling the database client\n * Prevents long-running connection issues and stale connections\n */\nexport const DB_CLIENT_RECYCLE_COUNT = 1500;\n\n/**\n * Block intervals for periodic event emission\n * Used for operations that should run at regular block intervals\n */\nexport const PERIODIC_INTERVALS = {\n  /** Emit periodic event every 50 blocks */\n  SMALL: 50,\n  /** Emit periodic event every 100 blocks */\n  MEDIUM: 100,\n  /** Emit periodic event every 1000 blocks - used for performance logging */\n  LARGE: 1000,\n} as const;\n\n/**\n * Pagination limits for blockchain queries\n */\nexport const PAGINATION_LIMITS = {\n  /** Default limit for validator queries */\n  VALIDATORS: 1000n,\n  /** Default limit for delegation queries */\n  DELEGATIONS: 250n,\n} as const;\n\n/**\n * Batch size for streaming genesis file processing\n * Number of entries to process at once from genesis JSON\n */\nexport const GENESIS_BATCH_SIZE = 1000;\n"],"mappings":";;;;;;;;;;AAUA,MAAa,qBAAqB;;;;AAKlC,MAAa,uBAAuB;;;;AAKpC,MAAa,4BAA4B;;;;AAKzC,MAAa,0BAA0B;;;;AAKvC,MAAa,8BAA8B;;;;;AAM3C,MAAa,qBAAqB;;;;;AAMlC,MAAa,iBAAiB;;;;;AAM9B,MAAa,2BAA2B;;;;;;AAOxC,MAAa,yBAAyB;;;;AAKtC,MAAa,sBAAsB;;;;AAKnC,MAAa,qBAAqB;;;;;;AAOlC,MAAa,yBAAyB;;;;AAKtC,MAAa,oBAAoB;;;;;AAMjC,MAAa,0BAA0B;;;;;AAMvC,MAAa,qBAAqB;CAEhC,OAAO;CAEP,QAAQ;CAER,OAAO;CACR;;;;AAKD,MAAa,oBAAoB;CAE/B,YAAY;CAEZ,aAAa;CACd;;;;;AAMD,MAAa,qBAAqB"}

package/dist/emitter/index.cjs

@@ -11,8 +11,17 @@ var EclesiaEmitter = class {
 	emitter = new events.EventEmitter();
 	/** Map tracking the number of handlers registered for each event type */
 	handled = /* @__PURE__ */ new Map();
-	/** WeakMap storing wrapper functions for proper cleanup */
+	/** Wrappers registered per handler and event name, so off() removes exactly what on() added */
 	handlerMap = /* @__PURE__ */ new WeakMap();
+	/** Raw handlers per event name in registration order, for callers that await them one by one */
+	rawHandlers = /* @__PURE__ */ new Map();
+	/**
+	* Handlers registered for an event, in registration order.
+	* @param eventName - Event name
+	*/
+	handlersFor(eventName) {
+		return this.rawHandlers.get(eventName) ?? [];
+	}
 	/**
 	* Creates a new EclesiaEmitter instance
 	* Sets max listeners to 0 (unlimited) to handle many modules
@@ -47,18 +56,27 @@ var EclesiaEmitter = class {
 				});
 			}
 		};
-		this.handlerMap.set(handler, wrapper);
+		const byEvent = this.handlerMap.get(handler) ?? /* @__PURE__ */ new Map();
+		const wrappers = byEvent.get(eventName) ?? [];
+		wrappers.push(wrapper);
+		byEvent.set(eventName, wrappers);
+		this.handlerMap.set(handler, byEvent);
+		const raw = this.rawHandlers.get(eventName) ?? [];
+		raw.push(handler);
+		this.rawHandlers.set(eventName, raw);
 		this.emitter.on(eventName, wrapper);
 	}
 	off(eventName, handler) {
+		const wrappers = this.handlerMap.get(handler)?.get(eventName);
+		if (!wrappers || wrappers.length === 0) return;
+		const wrapper = wrappers.pop();
+		this.emitter.off(eventName, wrapper);
+		const raw = this.rawHandlers.get(eventName) ?? [];
+		const index = raw.lastIndexOf(handler);
+		if (index >= 0) raw.splice(index, 1);
 		const count = this.handled.get(eventName);
 		if (count && count > 1) this.handled.set(eventName, count - 1);
 		else this.handled.delete(eventName);
-		const wrapper = this.handlerMap.get(handler);
-		if (wrapper) {
-			this.emitter.off(eventName, wrapper);
-			this.handlerMap.delete(handler);
-		}
 	}
 };
 

package/dist/emitter/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["EventEmitter"],"sources":["../../src/emitter/index.ts"],"sourcesContent":["import {\n  EventEmitter,\n} from \"node:events\";\n\nimport {\n  WithHeightAndUUID,\n} from \"../types/index.js\";\n\n/**\n * Custom event emitter that provides type-safe event handling for blockchain indexing\n * Extends Node.js EventEmitter with UUID tracking and error handling capabilities\n */\nexport class EclesiaEmitter {\n  /** Internal Node.js EventEmitter instance */\n  private emitter = new EventEmitter();\n\n  /** Map tracking the number of handlers registered for each event type */\n  public handled = new Map<string, number>();\n\n  /** WeakMap storing wrapper functions for proper cleanup */\n  private handlerMap = new WeakMap();\n\n  /**\n   * Creates a new EclesiaEmitter instance\n   * Sets max listeners to 0 (unlimited) to handle many modules\n   */\n  constructor() {\n    this.emitter.setMaxListeners(0);\n  }\n\n  emit<EType extends keyof (WithHeightAndUUID<EventMap>) & string>(\n    eventName: EType,\n    eventArg: WithHeightAndUUID<EventMap>[EType] & {\n      uuid?: string\n    },\n  ) {\n    if (this.handled.has(eventName)) {\n      this.emitter.emit(\n        eventName, eventArg,\n      );\n    }\n    else {\n      this.emitter.emit(\n        \"_unhandled\", {\n          type: eventName as string,\n          event: eventArg,\n          uuid: eventArg.uuid,\n        },\n      );\n    }\n  }\n\n  on<TEventName extends keyof WithHeightAndUUID<EventMap> & string | \"_unhandled\">(\n    eventName: TEventName,\n    handler: TEventName extends \"_unhandled\"\n      ? (eventArg: {\n        type: string\n        event: unknown\n        uuid: string\n      }) => void\n      : (eventArg: TEventName extends keyof WithHeightAndUUID<EventMap> ? WithHeightAndUUID<EventMap>[TEventName] : never) => void,\n  ) {\n    const count = this.handled.get(eventName);\n    if (count) {\n      this.handled.set(\n        eventName, count + 1,\n      );\n    }\n    else {\n      this.handled.set(\n        eventName, 1,\n      );\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const wrapper = async (eventData: any) => {\n      try {\n        await handler(eventData);\n        if (eventName !== \"uuid\" && eventName !== \"_unhandled\" && eventData.uuid) {\n          this.emit(\n            \"uuid\", {\n              status: true,\n              uuid: eventData.uuid,\n            },\n          );\n        }\n      }\n      catch (error) {\n        if (eventName !== \"uuid\" && eventName !== \"_unhandled\" && eventData.uuid) {\n          this.emit(\n            \"uuid\", {\n              status: false,\n              error: error as string,\n              uuid: eventData.uuid,\n            },\n          );\n        }\n      }\n    };\n    this.handlerMap.set(\n      handler, wrapper,\n    );\n    this.emitter.on(\n      eventName, wrapper,\n    );\n  }\n\n  off<TEventName extends keyof WithHeightAndUUID<EventMap> & string>(\n    eventName: TEventName,\n    handler: (eventArg: WithHeightAndUUID<EventMap>[TEventName]) => void,\n  ) {\n    const count = this.handled.get(eventName);\n    if (count && count > 1) {\n      this.handled.set(\n        eventName, count - 1,\n      );\n    }\n    else {\n      this.handled.delete(eventName);\n    }\n    const wrapper = this.handlerMap.get(handler);\n    if (wrapper) {\n      this.emitter.off(\n        eventName, wrapper,\n      );\n      this.handlerMap.delete(handler);\n    }\n  }\n}\n"],"mappings":";;;;;;;;AAYA,IAAa,iBAAb,MAA4B;;CAE1B,AAAQ,UAAU,IAAIA,qBAAc;;CAGpC,AAAO,0BAAU,IAAI,KAAqB;;CAG1C,AAAQ,6BAAa,IAAI,SAAS;;;;;CAMlC,cAAc;AACZ,OAAK,QAAQ,gBAAgB,EAAE;;CAGjC,KACE,WACA,UAGA;AACA,MAAI,KAAK,QAAQ,IAAI,UAAU,CAC7B,MAAK,QAAQ,KACX,WAAW,SACZ;MAGD,MAAK,QAAQ,KACX,cAAc;GACZ,MAAM;GACN,OAAO;GACP,MAAM,SAAS;GAChB,CACF;;CAIL,GACE,WACA,SAOA;EACA,MAAM,QAAQ,KAAK,QAAQ,IAAI,UAAU;AACzC,MAAI,MACF,MAAK,QAAQ,IACX,WAAW,QAAQ,EACpB;MAGD,MAAK,QAAQ,IACX,WAAW,EACZ;EAGH,MAAM,UAAU,OAAO,cAAmB;AACxC,OAAI;AACF,UAAM,QAAQ,UAAU;AACxB,QAAI,cAAc,UAAU,cAAc,gBAAgB,UAAU,KAClE,MAAK,KACH,QAAQ;KACN,QAAQ;KACR,MAAM,UAAU;KACjB,CACF;YAGE,OAAO;AACZ,QAAI,cAAc,UAAU,cAAc,gBAAgB,UAAU,KAClE,MAAK,KACH,QAAQ;KACN,QAAQ;KACD;KACP,MAAM,UAAU;KACjB,CACF;;;AAIP,OAAK,WAAW,IACd,SAAS,QACV;AACD,OAAK,QAAQ,GACX,WAAW,QACZ;;CAGH,IACE,WACA,SACA;EACA,MAAM,QAAQ,KAAK,QAAQ,IAAI,UAAU;AACzC,MAAI,SAAS,QAAQ,EACnB,MAAK,QAAQ,IACX,WAAW,QAAQ,EACpB;MAGD,MAAK,QAAQ,OAAO,UAAU;EAEhC,MAAM,UAAU,KAAK,WAAW,IAAI,QAAQ;AAC5C,MAAI,SAAS;AACX,QAAK,QAAQ,IACX,WAAW,QACZ;AACD,QAAK,WAAW,OAAO,QAAQ"}
+{"version":3,"file":"index.cjs","names":["EventEmitter"],"sources":["../../src/emitter/index.ts"],"sourcesContent":["import {\n  EventEmitter,\n} from \"node:events\";\n\nimport {\n  WithHeightAndUUID,\n} from \"../types/index.js\";\n\n/**\n * Custom event emitter that provides type-safe event handling for blockchain indexing\n * Extends Node.js EventEmitter with UUID tracking and error handling capabilities\n */\nexport class EclesiaEmitter {\n  /** Internal Node.js EventEmitter instance */\n  private emitter = new EventEmitter();\n\n  /** Map tracking the number of handlers registered for each event type */\n  public handled = new Map<string, number>();\n\n  /** Wrappers registered per handler and event name, so off() removes exactly what on() added */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private handlerMap = new WeakMap<object, Map<string, Array<(eventData: any) => Promise<void>>>>();\n\n  /** Raw handlers per event name in registration order, for callers that await them one by one */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private rawHandlers = new Map<string, Array<(eventData: any) => unknown>>();\n\n  /**\n   * Handlers registered for an event, in registration order.\n   * @param eventName - Event name\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  handlersFor(eventName: string): ReadonlyArray<(eventData: any) => unknown> {\n    return this.rawHandlers.get(eventName) ?? [];\n  }\n\n  /**\n   * Creates a new EclesiaEmitter instance\n   * Sets max listeners to 0 (unlimited) to handle many modules\n   */\n  constructor() {\n    this.emitter.setMaxListeners(0);\n  }\n\n  emit<EType extends keyof (WithHeightAndUUID<EventMap>) & string>(\n    eventName: EType,\n    eventArg: WithHeightAndUUID<EventMap>[EType] & {\n      uuid?: string\n    },\n  ) {\n    if (this.handled.has(eventName)) {\n      this.emitter.emit(\n        eventName, eventArg,\n      );\n    }\n    else {\n      this.emitter.emit(\n        \"_unhandled\", {\n          type: eventName as string,\n          event: eventArg,\n          uuid: eventArg.uuid,\n        },\n      );\n    }\n  }\n\n  on<TEventName extends keyof WithHeightAndUUID<EventMap> & string | \"_unhandled\">(\n    eventName: TEventName,\n    handler: TEventName extends \"_unhandled\"\n      ? (eventArg: {\n        type: string\n        event: unknown\n        uuid: string\n      }) => void\n      : (eventArg: TEventName extends keyof WithHeightAndUUID<EventMap> ? WithHeightAndUUID<EventMap>[TEventName] : never) => void,\n  ) {\n    const count = this.handled.get(eventName);\n    if (count) {\n      this.handled.set(\n        eventName, count + 1,\n      );\n    }\n    else {\n      this.handled.set(\n        eventName, 1,\n      );\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const wrapper = async (eventData: any) => {\n      try {\n        await handler(eventData);\n        if (eventName !== \"uuid\" && eventName !== \"_unhandled\" && eventData.uuid) {\n          this.emit(\n            \"uuid\", {\n              status: true,\n              uuid: eventData.uuid,\n            },\n          );\n        }\n      }\n      catch (error) {\n        if (eventName !== \"uuid\" && eventName !== \"_unhandled\" && eventData.uuid) {\n          this.emit(\n            \"uuid\", {\n              status: false,\n              error: error as string,\n              uuid: eventData.uuid,\n            },\n          );\n        }\n      }\n    };\n    const byEvent = this.handlerMap.get(handler) ?? new Map();\n    const wrappers = byEvent.get(eventName) ?? [];\n    wrappers.push(wrapper);\n    byEvent.set(eventName, wrappers);\n    this.handlerMap.set(handler, byEvent);\n    const raw = this.rawHandlers.get(eventName) ?? [];\n    raw.push(handler as (eventData: unknown) => unknown);\n    this.rawHandlers.set(eventName, raw);\n    this.emitter.on(\n      eventName, wrapper,\n    );\n  }\n\n  off<TEventName extends keyof WithHeightAndUUID<EventMap> & string>(\n    eventName: TEventName,\n    handler: (eventArg: WithHeightAndUUID<EventMap>[TEventName]) => void,\n  ) {\n    const wrappers = this.handlerMap.get(handler)?.get(eventName);\n    if (!wrappers || wrappers.length === 0) {\n      // Never registered for this event: nothing to remove, and the handled count must not\n      // drop, or emit() would route to _unhandled while real handlers are still attached\n      return;\n    }\n    const wrapper = wrappers.pop()!;\n    this.emitter.off(\n      eventName, wrapper,\n    );\n    const raw = this.rawHandlers.get(eventName) ?? [];\n    const index = raw.lastIndexOf(handler as (eventData: unknown) => unknown);\n    if (index >= 0) {\n      raw.splice(index, 1);\n    }\n    const count = this.handled.get(eventName);\n    if (count && count > 1) {\n      this.handled.set(\n        eventName, count - 1,\n      );\n    }\n    else {\n      this.handled.delete(eventName);\n    }\n  }\n}\n"],"mappings":";;;;;;;;AAYA,IAAa,iBAAb,MAA4B;;CAE1B,AAAQ,UAAU,IAAIA,qBAAc;;CAGpC,AAAO,0BAAU,IAAI,KAAqB;;CAI1C,AAAQ,6BAAa,IAAI,SAAwE;;CAIjG,AAAQ,8BAAc,IAAI,KAAiD;;;;;CAO3E,YAAY,WAA+D;AACzE,SAAO,KAAK,YAAY,IAAI,UAAU,IAAI,EAAE;;;;;;CAO9C,cAAc;AACZ,OAAK,QAAQ,gBAAgB,EAAE;;CAGjC,KACE,WACA,UAGA;AACA,MAAI,KAAK,QAAQ,IAAI,UAAU,CAC7B,MAAK,QAAQ,KACX,WAAW,SACZ;MAGD,MAAK,QAAQ,KACX,cAAc;GACZ,MAAM;GACN,OAAO;GACP,MAAM,SAAS;GAChB,CACF;;CAIL,GACE,WACA,SAOA;EACA,MAAM,QAAQ,KAAK,QAAQ,IAAI,UAAU;AACzC,MAAI,MACF,MAAK,QAAQ,IACX,WAAW,QAAQ,EACpB;MAGD,MAAK,QAAQ,IACX,WAAW,EACZ;EAGH,MAAM,UAAU,OAAO,cAAmB;AACxC,OAAI;AACF,UAAM,QAAQ,UAAU;AACxB,QAAI,cAAc,UAAU,cAAc,gBAAgB,UAAU,KAClE,MAAK,KACH,QAAQ;KACN,QAAQ;KACR,MAAM,UAAU;KACjB,CACF;YAGE,OAAO;AACZ,QAAI,cAAc,UAAU,cAAc,gBAAgB,UAAU,KAClE,MAAK,KACH,QAAQ;KACN,QAAQ;KACD;KACP,MAAM,UAAU;KACjB,CACF;;;EAIP,MAAM,UAAU,KAAK,WAAW,IAAI,QAAQ,oBAAI,IAAI,KAAK;EACzD,MAAM,WAAW,QAAQ,IAAI,UAAU,IAAI,EAAE;AAC7C,WAAS,KAAK,QAAQ;AACtB,UAAQ,IAAI,WAAW,SAAS;AAChC,OAAK,WAAW,IAAI,SAAS,QAAQ;EACrC,MAAM,MAAM,KAAK,YAAY,IAAI,UAAU,IAAI,EAAE;AACjD,MAAI,KAAK,QAA2C;AACpD,OAAK,YAAY,IAAI,WAAW,IAAI;AACpC,OAAK,QAAQ,GACX,WAAW,QACZ;;CAGH,IACE,WACA,SACA;EACA,MAAM,WAAW,KAAK,WAAW,IAAI,QAAQ,EAAE,IAAI,UAAU;AAC7D,MAAI,CAAC,YAAY,SAAS,WAAW,EAGnC;EAEF,MAAM,UAAU,SAAS,KAAK;AAC9B,OAAK,QAAQ,IACX,WAAW,QACZ;EACD,MAAM,MAAM,KAAK,YAAY,IAAI,UAAU,IAAI,EAAE;EACjD,MAAM,QAAQ,IAAI,YAAY,QAA2C;AACzE,MAAI,SAAS,EACX,KAAI,OAAO,OAAO,EAAE;EAEtB,MAAM,QAAQ,KAAK,QAAQ,IAAI,UAAU;AACzC,MAAI,SAAS,QAAQ,EACnB,MAAK,QAAQ,IACX,WAAW,QAAQ,EACpB;MAGD,MAAK,QAAQ,OAAO,UAAU"}

package/dist/emitter/index.d.cts

@@ -11,8 +11,15 @@ declare class EclesiaEmitter {
   private emitter;
   /** Map tracking the number of handlers registered for each event type */
   handled: Map<string, number>;
-  /** WeakMap storing wrapper functions for proper cleanup */
+  /** Wrappers registered per handler and event name, so off() removes exactly what on() added */
   private handlerMap;
+  /** Raw handlers per event name in registration order, for callers that await them one by one */
+  private rawHandlers;
+  /**
+   * Handlers registered for an event, in registration order.
+   * @param eventName - Event name
+   */
+  handlersFor(eventName: string): ReadonlyArray<(eventData: any) => unknown>;
   /**
    * Creates a new EclesiaEmitter instance
    * Sets max listeners to 0 (unlimited) to handle many modules

package/dist/emitter/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/emitter/index.ts"],"sourcesContent":[],"mappings":";;;;;;AAYA;;AAkB8C,cAlBjC,cAAA,CAkBiC;EAAlB;EACb,QAAA,OAAA;EACiB;EAAlB,OAAA,EAfE,GAeF,CAAA,MAAA,EAAA,MAAA,CAAA;EAA4B;EAoBM,QAAA,UAAA;EAAlB;;;;EAQgC,WAAA,CAAA;EAAlB,IAAA,CAAA,cAAA,MAAA,CA9BhB,iBA8BgB,CA9BE,QA8BF,CAAA,CAAA,GAAA,MAAA,CAAA,CAAA,SAAA,EA7B7B,KA6B6B,EAAA,QAAA,EA5B9B,iBA4B8B,CA5BZ,QA4BY,CAAA,CA5BF,KA4BE,CAAA,GAAA;IAAgD,IAAA,CAAA,EAAA,MAAA;EAAlB,CAAA,CAAA,EAAA,IAAA;EAA4B,EAAA,CAAA,mBAAA,MARxE,iBAQwE,CARtD,QAQsD,CAAA,GAAA,MAAA,GAAA,YAAA,CAAA,CAAA,SAAA,EAPvF,UAOuF,EAAA,OAAA,EANzF,UAMyF,SAAA,YAAA,GAAA,CAAA,QAAA,EAAA;IA8CrD,IAAA,EAAA,MAAA;IAAlB,KAAA,EAAA,OAAA;IAChB,IAAA,EAAA,MAAA;EAC2B,CAAA,EAAA,GAAA,IAAA,GAAA,CAAA,QAAA,EAhDvB,UAgDuB,SAAA,MAhDE,iBAgDF,CAhDoB,QAgDpB,CAAA,GAhDgC,iBAgDhC,CAhDkD,QAgDlD,CAAA,CAhD4D,UAgD5D,CAAA,GAAA,KAAA,EAAA,GAAA,IAAA,CAAA,EAAA,IAAA;EAAlB,GAAA,CAAA,mBAAA,MAFO,iBAEP,CAFyB,QAEzB,CAAA,GAAA,MAAA,CAAA,CAAA,SAAA,EADT,UACS,EAAA,OAAA,EAAA,CAAA,QAAA,EAAA,iBAAA,CAAkB,QAAlB,CAAA,CAA4B,UAA5B,CAAA,EAAA,GAAA,IAAA,CAAA,EAAA,IAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/emitter/index.ts"],"sourcesContent":[],"mappings":";;;;;;AAYA;;AAoBkC,cApBrB,cAAA,CAoBqB;EAYY;EAAlB,QAAA,OAAA;EACb;EACiB,OAAA,EA7BhB,GA6BgB,CAAA,MAAA,EAAA,MAAA,CAAA;EAAlB;EAA4B,QAAA,UAAA;EAoBM;EAAlB,QAAA,WAAA;EACf;;;;EAO6B,WAAA,CAAA,SAAA,EAAA,MAAA,CAAA,EA1CV,aA0CU,CAAA,CAAA,SAAA,EAAA,GAAA,EAAA,GAAA,OAAA,CAAA;EAAgD;;;;EAmD7D,WAAA,CAAA;EAChB,IAAA,CAAA,cAAA,MAAA,CAlFa,iBAkFb,CAlF+B,QAkF/B,CAAA,CAAA,GAAA,MAAA,CAAA,CAAA,SAAA,EAjFA,KAiFA,EAAA,QAAA,EAhFD,iBAgFC,CAhFiB,QAgFjB,CAAA,CAhF2B,KAgF3B,CAAA,GAAA;IAC2B,IAAA,CAAA,EAAA,MAAA;EAAlB,CAAA,CAAA,EAAA,IAAA;EAA4B,EAAA,CAAA,mBAAA,MA7DtB,iBA6DsB,CA7DJ,QA6DI,CAAA,GAAA,MAAA,GAAA,YAAA,CAAA,CAAA,SAAA,EA5DrC,UA4DqC,EAAA,OAAA,EA3DvC,UA2DuC,SAAA,YAAA,GAAA,CAAA,QAAA,EAAA;IAAU,IAAA,EAAA,MAAA;;;0BArD3C,yBAAyB,kBAAkB,YAAY,kBAAkB,UAAU;+BAmDvE,kBAAkB,+BAClC,gCACS,kBAAkB,UAAU"}

package/dist/emitter/index.d.mts

@@ -11,8 +11,15 @@ declare class EclesiaEmitter {
   private emitter;
   /** Map tracking the number of handlers registered for each event type */
   handled: Map<string, number>;
-  /** WeakMap storing wrapper functions for proper cleanup */
+  /** Wrappers registered per handler and event name, so off() removes exactly what on() added */
   private handlerMap;
+  /** Raw handlers per event name in registration order, for callers that await them one by one */
+  private rawHandlers;
+  /**
+   * Handlers registered for an event, in registration order.
+   * @param eventName - Event name
+   */
+  handlersFor(eventName: string): ReadonlyArray<(eventData: any) => unknown>;
   /**
    * Creates a new EclesiaEmitter instance
    * Sets max listeners to 0 (unlimited) to handle many modules

package/dist/emitter/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/emitter/index.ts"],"sourcesContent":[],"mappings":";;;;;;AAYA;;AAkB8C,cAlBjC,cAAA,CAkBiC;EAAlB;EACb,QAAA,OAAA;EACiB;EAAlB,OAAA,EAfE,GAeF,CAAA,MAAA,EAAA,MAAA,CAAA;EAA4B;EAoBM,QAAA,UAAA;EAAlB;;;;EAQgC,WAAA,CAAA;EAAlB,IAAA,CAAA,cAAA,MAAA,CA9BhB,iBA8BgB,CA9BE,QA8BF,CAAA,CAAA,GAAA,MAAA,CAAA,CAAA,SAAA,EA7B7B,KA6B6B,EAAA,QAAA,EA5B9B,iBA4B8B,CA5BZ,QA4BY,CAAA,CA5BF,KA4BE,CAAA,GAAA;IAAgD,IAAA,CAAA,EAAA,MAAA;EAAlB,CAAA,CAAA,EAAA,IAAA;EAA4B,EAAA,CAAA,mBAAA,MARxE,iBAQwE,CARtD,QAQsD,CAAA,GAAA,MAAA,GAAA,YAAA,CAAA,CAAA,SAAA,EAPvF,UAOuF,EAAA,OAAA,EANzF,UAMyF,SAAA,YAAA,GAAA,CAAA,QAAA,EAAA;IA8CrD,IAAA,EAAA,MAAA;IAAlB,KAAA,EAAA,OAAA;IAChB,IAAA,EAAA,MAAA;EAC2B,CAAA,EAAA,GAAA,IAAA,GAAA,CAAA,QAAA,EAhDvB,UAgDuB,SAAA,MAhDE,iBAgDF,CAhDoB,QAgDpB,CAAA,GAhDgC,iBAgDhC,CAhDkD,QAgDlD,CAAA,CAhD4D,UAgD5D,CAAA,GAAA,KAAA,EAAA,GAAA,IAAA,CAAA,EAAA,IAAA;EAAlB,GAAA,CAAA,mBAAA,MAFO,iBAEP,CAFyB,QAEzB,CAAA,GAAA,MAAA,CAAA,CAAA,SAAA,EADT,UACS,EAAA,OAAA,EAAA,CAAA,QAAA,EAAA,iBAAA,CAAkB,QAAlB,CAAA,CAA4B,UAA5B,CAAA,EAAA,GAAA,IAAA,CAAA,EAAA,IAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/emitter/index.ts"],"sourcesContent":[],"mappings":";;;;;;AAYA;;AAoBkC,cApBrB,cAAA,CAoBqB;EAYY;EAAlB,QAAA,OAAA;EACb;EACiB,OAAA,EA7BhB,GA6BgB,CAAA,MAAA,EAAA,MAAA,CAAA;EAAlB;EAA4B,QAAA,UAAA;EAoBM;EAAlB,QAAA,WAAA;EACf;;;;EAO6B,WAAA,CAAA,SAAA,EAAA,MAAA,CAAA,EA1CV,aA0CU,CAAA,CAAA,SAAA,EAAA,GAAA,EAAA,GAAA,OAAA,CAAA;EAAgD;;;;EAmD7D,WAAA,CAAA;EAChB,IAAA,CAAA,cAAA,MAAA,CAlFa,iBAkFb,CAlF+B,QAkF/B,CAAA,CAAA,GAAA,MAAA,CAAA,CAAA,SAAA,EAjFA,KAiFA,EAAA,QAAA,EAhFD,iBAgFC,CAhFiB,QAgFjB,CAAA,CAhF2B,KAgF3B,CAAA,GAAA;IAC2B,IAAA,CAAA,EAAA,MAAA;EAAlB,CAAA,CAAA,EAAA,IAAA;EAA4B,EAAA,CAAA,mBAAA,MA7DtB,iBA6DsB,CA7DJ,QA6DI,CAAA,GAAA,MAAA,GAAA,YAAA,CAAA,CAAA,SAAA,EA5DrC,UA4DqC,EAAA,OAAA,EA3DvC,UA2DuC,SAAA,YAAA,GAAA,CAAA,QAAA,EAAA;IAAU,IAAA,EAAA,MAAA;;;0BArD3C,yBAAyB,kBAAkB,YAAY,kBAAkB,UAAU;+BAmDvE,kBAAkB,+BAClC,gCACS,kBAAkB,UAAU"}

package/dist/emitter/index.mjs

@@ -10,8 +10,17 @@ var EclesiaEmitter = class {
 	emitter = new EventEmitter();
 	/** Map tracking the number of handlers registered for each event type */
 	handled = /* @__PURE__ */ new Map();
-	/** WeakMap storing wrapper functions for proper cleanup */
+	/** Wrappers registered per handler and event name, so off() removes exactly what on() added */
 	handlerMap = /* @__PURE__ */ new WeakMap();
+	/** Raw handlers per event name in registration order, for callers that await them one by one */
+	rawHandlers = /* @__PURE__ */ new Map();
+	/**
+	* Handlers registered for an event, in registration order.
+	* @param eventName - Event name
+	*/
+	handlersFor(eventName) {
+		return this.rawHandlers.get(eventName) ?? [];
+	}
 	/**
 	* Creates a new EclesiaEmitter instance
 	* Sets max listeners to 0 (unlimited) to handle many modules
@@ -46,18 +55,27 @@ var EclesiaEmitter = class {
 				});
 			}
 		};
-		this.handlerMap.set(handler, wrapper);
+		const byEvent = this.handlerMap.get(handler) ?? /* @__PURE__ */ new Map();
+		const wrappers = byEvent.get(eventName) ?? [];
+		wrappers.push(wrapper);
+		byEvent.set(eventName, wrappers);
+		this.handlerMap.set(handler, byEvent);
+		const raw = this.rawHandlers.get(eventName) ?? [];
+		raw.push(handler);
+		this.rawHandlers.set(eventName, raw);
 		this.emitter.on(eventName, wrapper);
 	}
 	off(eventName, handler) {
+		const wrappers = this.handlerMap.get(handler)?.get(eventName);
+		if (!wrappers || wrappers.length === 0) return;
+		const wrapper = wrappers.pop();
+		this.emitter.off(eventName, wrapper);
+		const raw = this.rawHandlers.get(eventName) ?? [];
+		const index = raw.lastIndexOf(handler);
+		if (index >= 0) raw.splice(index, 1);
 		const count = this.handled.get(eventName);
 		if (count && count > 1) this.handled.set(eventName, count - 1);
 		else this.handled.delete(eventName);
-		const wrapper = this.handlerMap.get(handler);
-		if (wrapper) {
-			this.emitter.off(eventName, wrapper);
-			this.handlerMap.delete(handler);
-		}
 	}
 };
 

package/dist/emitter/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/emitter/index.ts"],"sourcesContent":["import {\n  EventEmitter,\n} from \"node:events\";\n\nimport {\n  WithHeightAndUUID,\n} from \"../types/index.js\";\n\n/**\n * Custom event emitter that provides type-safe event handling for blockchain indexing\n * Extends Node.js EventEmitter with UUID tracking and error handling capabilities\n */\nexport class EclesiaEmitter {\n  /** Internal Node.js EventEmitter instance */\n  private emitter = new EventEmitter();\n\n  /** Map tracking the number of handlers registered for each event type */\n  public handled = new Map<string, number>();\n\n  /** WeakMap storing wrapper functions for proper cleanup */\n  private handlerMap = new WeakMap();\n\n  /**\n   * Creates a new EclesiaEmitter instance\n   * Sets max listeners to 0 (unlimited) to handle many modules\n   */\n  constructor() {\n    this.emitter.setMaxListeners(0);\n  }\n\n  emit<EType extends keyof (WithHeightAndUUID<EventMap>) & string>(\n    eventName: EType,\n    eventArg: WithHeightAndUUID<EventMap>[EType] & {\n      uuid?: string\n    },\n  ) {\n    if (this.handled.has(eventName)) {\n      this.emitter.emit(\n        eventName, eventArg,\n      );\n    }\n    else {\n      this.emitter.emit(\n        \"_unhandled\", {\n          type: eventName as string,\n          event: eventArg,\n          uuid: eventArg.uuid,\n        },\n      );\n    }\n  }\n\n  on<TEventName extends keyof WithHeightAndUUID<EventMap> & string | \"_unhandled\">(\n    eventName: TEventName,\n    handler: TEventName extends \"_unhandled\"\n      ? (eventArg: {\n        type: string\n        event: unknown\n        uuid: string\n      }) => void\n      : (eventArg: TEventName extends keyof WithHeightAndUUID<EventMap> ? WithHeightAndUUID<EventMap>[TEventName] : never) => void,\n  ) {\n    const count = this.handled.get(eventName);\n    if (count) {\n      this.handled.set(\n        eventName, count + 1,\n      );\n    }\n    else {\n      this.handled.set(\n        eventName, 1,\n      );\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const wrapper = async (eventData: any) => {\n      try {\n        await handler(eventData);\n        if (eventName !== \"uuid\" && eventName !== \"_unhandled\" && eventData.uuid) {\n          this.emit(\n            \"uuid\", {\n              status: true,\n              uuid: eventData.uuid,\n            },\n          );\n        }\n      }\n      catch (error) {\n        if (eventName !== \"uuid\" && eventName !== \"_unhandled\" && eventData.uuid) {\n          this.emit(\n            \"uuid\", {\n              status: false,\n              error: error as string,\n              uuid: eventData.uuid,\n            },\n          );\n        }\n      }\n    };\n    this.handlerMap.set(\n      handler, wrapper,\n    );\n    this.emitter.on(\n      eventName, wrapper,\n    );\n  }\n\n  off<TEventName extends keyof WithHeightAndUUID<EventMap> & string>(\n    eventName: TEventName,\n    handler: (eventArg: WithHeightAndUUID<EventMap>[TEventName]) => void,\n  ) {\n    const count = this.handled.get(eventName);\n    if (count && count > 1) {\n      this.handled.set(\n        eventName, count - 1,\n      );\n    }\n    else {\n      this.handled.delete(eventName);\n    }\n    const wrapper = this.handlerMap.get(handler);\n    if (wrapper) {\n      this.emitter.off(\n        eventName, wrapper,\n      );\n      this.handlerMap.delete(handler);\n    }\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,iBAAb,MAA4B;;CAE1B,AAAQ,UAAU,IAAI,cAAc;;CAGpC,AAAO,0BAAU,IAAI,KAAqB;;CAG1C,AAAQ,6BAAa,IAAI,SAAS;;;;;CAMlC,cAAc;AACZ,OAAK,QAAQ,gBAAgB,EAAE;;CAGjC,KACE,WACA,UAGA;AACA,MAAI,KAAK,QAAQ,IAAI,UAAU,CAC7B,MAAK,QAAQ,KACX,WAAW,SACZ;MAGD,MAAK,QAAQ,KACX,cAAc;GACZ,MAAM;GACN,OAAO;GACP,MAAM,SAAS;GAChB,CACF;;CAIL,GACE,WACA,SAOA;EACA,MAAM,QAAQ,KAAK,QAAQ,IAAI,UAAU;AACzC,MAAI,MACF,MAAK,QAAQ,IACX,WAAW,QAAQ,EACpB;MAGD,MAAK,QAAQ,IACX,WAAW,EACZ;EAGH,MAAM,UAAU,OAAO,cAAmB;AACxC,OAAI;AACF,UAAM,QAAQ,UAAU;AACxB,QAAI,cAAc,UAAU,cAAc,gBAAgB,UAAU,KAClE,MAAK,KACH,QAAQ;KACN,QAAQ;KACR,MAAM,UAAU;KACjB,CACF;YAGE,OAAO;AACZ,QAAI,cAAc,UAAU,cAAc,gBAAgB,UAAU,KAClE,MAAK,KACH,QAAQ;KACN,QAAQ;KACD;KACP,MAAM,UAAU;KACjB,CACF;;;AAIP,OAAK,WAAW,IACd,SAAS,QACV;AACD,OAAK,QAAQ,GACX,WAAW,QACZ;;CAGH,IACE,WACA,SACA;EACA,MAAM,QAAQ,KAAK,QAAQ,IAAI,UAAU;AACzC,MAAI,SAAS,QAAQ,EACnB,MAAK,QAAQ,IACX,WAAW,QAAQ,EACpB;MAGD,MAAK,QAAQ,OAAO,UAAU;EAEhC,MAAM,UAAU,KAAK,WAAW,IAAI,QAAQ;AAC5C,MAAI,SAAS;AACX,QAAK,QAAQ,IACX,WAAW,QACZ;AACD,QAAK,WAAW,OAAO,QAAQ"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/emitter/index.ts"],"sourcesContent":["import {\n  EventEmitter,\n} from \"node:events\";\n\nimport {\n  WithHeightAndUUID,\n} from \"../types/index.js\";\n\n/**\n * Custom event emitter that provides type-safe event handling for blockchain indexing\n * Extends Node.js EventEmitter with UUID tracking and error handling capabilities\n */\nexport class EclesiaEmitter {\n  /** Internal Node.js EventEmitter instance */\n  private emitter = new EventEmitter();\n\n  /** Map tracking the number of handlers registered for each event type */\n  public handled = new Map<string, number>();\n\n  /** Wrappers registered per handler and event name, so off() removes exactly what on() added */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private handlerMap = new WeakMap<object, Map<string, Array<(eventData: any) => Promise<void>>>>();\n\n  /** Raw handlers per event name in registration order, for callers that await them one by one */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private rawHandlers = new Map<string, Array<(eventData: any) => unknown>>();\n\n  /**\n   * Handlers registered for an event, in registration order.\n   * @param eventName - Event name\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  handlersFor(eventName: string): ReadonlyArray<(eventData: any) => unknown> {\n    return this.rawHandlers.get(eventName) ?? [];\n  }\n\n  /**\n   * Creates a new EclesiaEmitter instance\n   * Sets max listeners to 0 (unlimited) to handle many modules\n   */\n  constructor() {\n    this.emitter.setMaxListeners(0);\n  }\n\n  emit<EType extends keyof (WithHeightAndUUID<EventMap>) & string>(\n    eventName: EType,\n    eventArg: WithHeightAndUUID<EventMap>[EType] & {\n      uuid?: string\n    },\n  ) {\n    if (this.handled.has(eventName)) {\n      this.emitter.emit(\n        eventName, eventArg,\n      );\n    }\n    else {\n      this.emitter.emit(\n        \"_unhandled\", {\n          type: eventName as string,\n          event: eventArg,\n          uuid: eventArg.uuid,\n        },\n      );\n    }\n  }\n\n  on<TEventName extends keyof WithHeightAndUUID<EventMap> & string | \"_unhandled\">(\n    eventName: TEventName,\n    handler: TEventName extends \"_unhandled\"\n      ? (eventArg: {\n        type: string\n        event: unknown\n        uuid: string\n      }) => void\n      : (eventArg: TEventName extends keyof WithHeightAndUUID<EventMap> ? WithHeightAndUUID<EventMap>[TEventName] : never) => void,\n  ) {\n    const count = this.handled.get(eventName);\n    if (count) {\n      this.handled.set(\n        eventName, count + 1,\n      );\n    }\n    else {\n      this.handled.set(\n        eventName, 1,\n      );\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const wrapper = async (eventData: any) => {\n      try {\n        await handler(eventData);\n        if (eventName !== \"uuid\" && eventName !== \"_unhandled\" && eventData.uuid) {\n          this.emit(\n            \"uuid\", {\n              status: true,\n              uuid: eventData.uuid,\n            },\n          );\n        }\n      }\n      catch (error) {\n        if (eventName !== \"uuid\" && eventName !== \"_unhandled\" && eventData.uuid) {\n          this.emit(\n            \"uuid\", {\n              status: false,\n              error: error as string,\n              uuid: eventData.uuid,\n            },\n          );\n        }\n      }\n    };\n    const byEvent = this.handlerMap.get(handler) ?? new Map();\n    const wrappers = byEvent.get(eventName) ?? [];\n    wrappers.push(wrapper);\n    byEvent.set(eventName, wrappers);\n    this.handlerMap.set(handler, byEvent);\n    const raw = this.rawHandlers.get(eventName) ?? [];\n    raw.push(handler as (eventData: unknown) => unknown);\n    this.rawHandlers.set(eventName, raw);\n    this.emitter.on(\n      eventName, wrapper,\n    );\n  }\n\n  off<TEventName extends keyof WithHeightAndUUID<EventMap> & string>(\n    eventName: TEventName,\n    handler: (eventArg: WithHeightAndUUID<EventMap>[TEventName]) => void,\n  ) {\n    const wrappers = this.handlerMap.get(handler)?.get(eventName);\n    if (!wrappers || wrappers.length === 0) {\n      // Never registered for this event: nothing to remove, and the handled count must not\n      // drop, or emit() would route to _unhandled while real handlers are still attached\n      return;\n    }\n    const wrapper = wrappers.pop()!;\n    this.emitter.off(\n      eventName, wrapper,\n    );\n    const raw = this.rawHandlers.get(eventName) ?? [];\n    const index = raw.lastIndexOf(handler as (eventData: unknown) => unknown);\n    if (index >= 0) {\n      raw.splice(index, 1);\n    }\n    const count = this.handled.get(eventName);\n    if (count && count > 1) {\n      this.handled.set(\n        eventName, count - 1,\n      );\n    }\n    else {\n      this.handled.delete(eventName);\n    }\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,iBAAb,MAA4B;;CAE1B,AAAQ,UAAU,IAAI,cAAc;;CAGpC,AAAO,0BAAU,IAAI,KAAqB;;CAI1C,AAAQ,6BAAa,IAAI,SAAwE;;CAIjG,AAAQ,8BAAc,IAAI,KAAiD;;;;;CAO3E,YAAY,WAA+D;AACzE,SAAO,KAAK,YAAY,IAAI,UAAU,IAAI,EAAE;;;;;;CAO9C,cAAc;AACZ,OAAK,QAAQ,gBAAgB,EAAE;;CAGjC,KACE,WACA,UAGA;AACA,MAAI,KAAK,QAAQ,IAAI,UAAU,CAC7B,MAAK,QAAQ,KACX,WAAW,SACZ;MAGD,MAAK,QAAQ,KACX,cAAc;GACZ,MAAM;GACN,OAAO;GACP,MAAM,SAAS;GAChB,CACF;;CAIL,GACE,WACA,SAOA;EACA,MAAM,QAAQ,KAAK,QAAQ,IAAI,UAAU;AACzC,MAAI,MACF,MAAK,QAAQ,IACX,WAAW,QAAQ,EACpB;MAGD,MAAK,QAAQ,IACX,WAAW,EACZ;EAGH,MAAM,UAAU,OAAO,cAAmB;AACxC,OAAI;AACF,UAAM,QAAQ,UAAU;AACxB,QAAI,cAAc,UAAU,cAAc,gBAAgB,UAAU,KAClE,MAAK,KACH,QAAQ;KACN,QAAQ;KACR,MAAM,UAAU;KACjB,CACF;YAGE,OAAO;AACZ,QAAI,cAAc,UAAU,cAAc,gBAAgB,UAAU,KAClE,MAAK,KACH,QAAQ;KACN,QAAQ;KACD;KACP,MAAM,UAAU;KACjB,CACF;;;EAIP,MAAM,UAAU,KAAK,WAAW,IAAI,QAAQ,oBAAI,IAAI,KAAK;EACzD,MAAM,WAAW,QAAQ,IAAI,UAAU,IAAI,EAAE;AAC7C,WAAS,KAAK,QAAQ;AACtB,UAAQ,IAAI,WAAW,SAAS;AAChC,OAAK,WAAW,IAAI,SAAS,QAAQ;EACrC,MAAM,MAAM,KAAK,YAAY,IAAI,UAAU,IAAI,EAAE;AACjD,MAAI,KAAK,QAA2C;AACpD,OAAK,YAAY,IAAI,WAAW,IAAI;AACpC,OAAK,QAAQ,GACX,WAAW,QACZ;;CAGH,IACE,WACA,SACA;EACA,MAAM,WAAW,KAAK,WAAW,IAAI,QAAQ,EAAE,IAAI,UAAU;AAC7D,MAAI,CAAC,YAAY,SAAS,WAAW,EAGnC;EAEF,MAAM,UAAU,SAAS,KAAK;AAC9B,OAAK,QAAQ,IACX,WAAW,QACZ;EACD,MAAM,MAAM,KAAK,YAAY,IAAI,UAAU,IAAI,EAAE;EACjD,MAAM,QAAQ,IAAI,YAAY,QAA2C;AACzE,MAAI,SAAS,EACX,KAAI,OAAO,OAAO,EAAE;EAEtB,MAAM,QAAQ,KAAK,QAAQ,IAAI,UAAU;AACzC,MAAI,SAAS,QAAQ,EACnB,MAAK,QAAQ,IACX,WAAW,QAAQ,EACpB;MAGD,MAAK,QAAQ,OAAO,UAAU"}

package/dist/index.cjs

@@ -15,6 +15,7 @@ exports.CircularBuffer = require_index$3.CircularBuffer;
 exports.ConfigurationError = require_index$1.ConfigurationError;
 exports.DB_CLIENT_RECYCLE_COUNT = require_constants.DB_CLIENT_RECYCLE_COUNT;
 exports.DEFAULT_BATCH_SIZE = require_constants.DEFAULT_BATCH_SIZE;
+exports.DEFAULT_BIND_HOST = require_constants.DEFAULT_BIND_HOST;
 exports.DEFAULT_HEALTH_CHECK_PORT = require_constants.DEFAULT_HEALTH_CHECK_PORT;
 exports.DEFAULT_POLLING_INTERVAL_MS = require_constants.DEFAULT_POLLING_INTERVAL_MS;
 exports.DEFAULT_PROMETHEUS_PORT = require_constants.DEFAULT_PROMETHEUS_PORT;
@@ -22,10 +23,13 @@ exports.DEFAULT_START_HEIGHT = require_constants.DEFAULT_START_HEIGHT;
 exports.DatabaseError = require_index$1.DatabaseError;
 exports.EcleciaIndexer = require_index$6.EcleciaIndexer;
 exports.EclesiaEmitter = require_index.EclesiaEmitter;
+exports.EclesiaIndexer = require_index$6.EclesiaIndexer;
 exports.GENESIS_BATCH_SIZE = require_constants.GENESIS_BATCH_SIZE;
 exports.GenesisError = require_index$1.GenesisError;
+exports.IDLE_CHECK_INTERVAL_MS = require_constants.IDLE_CHECK_INTERVAL_MS;
 exports.IndexerError = require_index$1.IndexerError;
 exports.IndexerMetrics = require_index$2.IndexerMetrics;
+exports.MAX_FAILURES_PER_BLOCK = require_constants.MAX_FAILURES_PER_BLOCK;
 Object.defineProperty(exports, 'Mocks', {
   enumerable: true,
   get: function () {
@@ -37,6 +41,8 @@ exports.PAGINATION_LIMITS = require_constants.PAGINATION_LIMITS;
 exports.PERIODIC_INTERVALS = require_constants.PERIODIC_INTERVALS;
 exports.PromiseQueue = require_index$3.PromiseQueue;
 exports.QUEUE_DEQUEUE_TIMEOUT_MS = require_constants.QUEUE_DEQUEUE_TIMEOUT_MS;
+exports.RETRY_BASE_DELAY_MS = require_constants.RETRY_BASE_DELAY_MS;
+exports.RETRY_MAX_DELAY_MS = require_constants.RETRY_MAX_DELAY_MS;
 exports.RPCError = require_index$1.RPCError;
 exports.RPC_TIMEOUT_MS = require_constants.RPC_TIMEOUT_MS;
 Object.defineProperty(exports, 'Types', {