@ensnode/ensnode-sdk 0.0.0-next-20260423165635 → 0.0.0-next-20260424124838

package/dist/index.cjs

@@ -82,6 +82,7 @@ __export(index_exports, {
   buildBlockRefRange: () => buildBlockRefRange,
   buildCrossChainIndexingStatusSnapshotOmnichain: () => buildCrossChainIndexingStatusSnapshotOmnichain,
   buildEncodedReferrer: () => buildEncodedReferrer,
+  buildEnsIndexerStackInfo: () => buildEnsIndexerStackInfo,
   buildEnsNodeStackInfo: () => buildEnsNodeStackInfo,
   buildEnsRainbowClientLabelSet: () => buildEnsRainbowClientLabelSet,
   buildIndexedBlockranges: () => buildIndexedBlockranges,
@@ -93,6 +94,7 @@ __export(index_exports, {
   buildUnvalidatedCrossChainIndexingStatusSnapshot: () => buildUnvalidatedCrossChainIndexingStatusSnapshot,
   buildUnvalidatedEnsApiPublicConfig: () => buildUnvalidatedEnsApiPublicConfig,
   buildUnvalidatedEnsIndexerPublicConfig: () => buildUnvalidatedEnsIndexerPublicConfig,
+  buildUnvalidatedEnsIndexerStackInfo: () => buildUnvalidatedEnsIndexerStackInfo,
   buildUnvalidatedEnsNodeStackInfo: () => buildUnvalidatedEnsNodeStackInfo,
   buildUnvalidatedOmnichainIndexingStatusSnapshot: () => buildUnvalidatedOmnichainIndexingStatusSnapshot,
   buildUnvalidatedRealtimeIndexingStatusProjection: () => buildUnvalidatedRealtimeIndexingStatusProjection,
@@ -117,6 +119,7 @@ __export(index_exports, {
   deserializeEnsIndexerConfigResponse: () => deserializeEnsIndexerConfigResponse,
   deserializeEnsIndexerIndexingStatusResponse: () => deserializeEnsIndexerIndexingStatusResponse,
   deserializeEnsIndexerPublicConfig: () => deserializeEnsIndexerPublicConfig,
+  deserializeEnsIndexerStackInfo: () => deserializeEnsIndexerStackInfo,
   deserializeEnsNodeStackInfo: () => deserializeEnsNodeStackInfo,
   deserializeErrorResponse: () => deserializeErrorResponse2,
   deserializeIndexingStatusResponse: () => deserializeIndexingStatusResponse,
@@ -223,6 +226,7 @@ __export(index_exports, {
   serializeEnsIndexerConfigResponse: () => serializeEnsIndexerConfigResponse,
   serializeEnsIndexerIndexingStatusResponse: () => serializeEnsIndexerIndexingStatusResponse,
   serializeEnsIndexerPublicConfig: () => serializeEnsIndexerPublicConfig,
+  serializeEnsIndexerStackInfo: () => serializeEnsIndexerStackInfo,
   serializeEnsNodeStackInfo: () => serializeEnsNodeStackInfo,
   serializeIndexedChainIds: () => serializeIndexedChainIds,
   serializeIndexingStatusResponse: () => serializeIndexingStatusResponse,
@@ -250,7 +254,9 @@ __export(index_exports, {
   validateCrossChainIndexingStatusSnapshot: () => validateCrossChainIndexingStatusSnapshot,
   validateEnsIndexerPublicConfig: () => validateEnsIndexerPublicConfig,
   validateEnsIndexerPublicConfigCompatibility: () => validateEnsIndexerPublicConfigCompatibility,
+  validateEnsIndexerStackInfo: () => validateEnsIndexerStackInfo,
   validateEnsIndexerVersionInfo: () => validateEnsIndexerVersionInfo,
+  validateEnsNodeStackInfo: () => validateEnsNodeStackInfo,
   validateOmnichainIndexingStatusSnapshot: () => validateOmnichainIndexingStatusSnapshot,
   validateRealtimeIndexingStatusProjection: () => validateRealtimeIndexingStatusProjection,
   validateSupportedLabelSetAndVersion: () => validateSupportedLabelSetAndVersion
@@ -574,14 +580,15 @@ var makeLabelSetIdSchema = (valueLabel = "Label set ID") => {
 var makeLabelSetVersionSchema = (valueLabel = "Label set version") => makeNonNegativeIntegerSchema(valueLabel);
 var makeLabelSetVersionStringSchema = (valueLabel = "Label set version") => import_v42.z.coerce.number({ error: `${valueLabel} must be a non-negative integer` }).pipe(makeLabelSetVersionSchema(valueLabel));
 var makeEnsRainbowPublicConfigSchema = (valueLabel = "EnsRainbowPublicConfig") => import_v42.z.object({
-  version: import_v42.z.string().nonempty({ error: `${valueLabel}.version must be a non-empty string.` }),
-  labelSet: import_v42.z.object({
-    labelSetId: makeLabelSetIdSchema(`${valueLabel}.labelSet.labelSetId`),
+  serverLabelSet: import_v42.z.object({
+    labelSetId: makeLabelSetIdSchema(`${valueLabel}.serverLabelSet.labelSetId`),
     highestLabelSetVersion: makeLabelSetVersionSchema(
-      `${valueLabel}.labelSet.highestLabelSetVersion`
+      `${valueLabel}.serverLabelSet.highestLabelSetVersion`
     )
   }),
-  recordsCount: makeNonNegativeIntegerSchema(`${valueLabel}.recordsCount`)
+  versionInfo: import_v42.z.object({
+    ensRainbow: import_v42.z.string().nonempty({ error: `${valueLabel}.versionInfo.ensRainbow must be a non-empty string.` })
+  })
 });
 
 // src/shared/collections.ts
@@ -606,8 +613,8 @@ var PluginName = /* @__PURE__ */ ((PluginName2) => {
 // src/ensindexer/config/is-subgraph-compatible.ts
 function isSubgraphCompatible(config) {
   const onlySubgraphPluginActivated = config.plugins.length === 1 && config.plugins[0] === "subgraph" /* Subgraph */;
-  const isSubgraphLabelSet = config.labelSet.labelSetId === "subgraph" && config.labelSet.labelSetVersion === 0;
-  const isEnsTestEnvLabelSet = config.labelSet.labelSetId === "ens-test-env" && config.labelSet.labelSetVersion === 0;
+  const isSubgraphLabelSet = config.clientLabelSet.labelSetId === "subgraph" && config.clientLabelSet.labelSetVersion === 0;
+  const isEnsTestEnvLabelSet = config.clientLabelSet.labelSetId === "ens-test-env" && config.clientLabelSet.labelSetVersion === 0;
   const labelSetIsSubgraphCompatible = isSubgraphLabelSet || config.namespace === import_datasources2.ENSNamespaceIds.EnsTestEnv && isEnsTestEnvLabelSet;
   return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
 }
@@ -705,13 +712,13 @@ function invariant_isSubgraphCompatibleRequirements(ctx) {
     ctx.issues.push({
       code: "custom",
       input: config,
-      message: `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active and labelSet must be {labelSetId: "subgraph", labelSetVersion: 0}`
+      message: `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active and 'clientLabelSet' must be {labelSetId: "subgraph", labelSetVersion: 0}`
     });
   }
 }
 function invariant_ensRainbowSupportedLabelSetAndVersion(ctx) {
-  const clientLabelSet = ctx.value.labelSet;
-  const serverLabelSet = ctx.value.ensRainbowPublicConfig.labelSet;
+  const { clientLabelSet } = ctx.value;
+  const { serverLabelSet } = ctx.value.ensRainbowPublicConfig;
   try {
     validateSupportedLabelSetAndVersion(serverLabelSet, clientLabelSet);
   } catch (error) {
@@ -732,7 +739,7 @@ var makeEnsIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") =
   isSubgraphCompatible: import_v43.z.boolean({
     error: `${valueLabel}.isSubgraphCompatible must be a boolean value.`
   }),
-  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
+  clientLabelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.clientLabelSet`),
   namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
   plugins: makePluginsListSchema(`${valueLabel}.plugins`),
   versionInfo: makeEnsIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
@@ -746,7 +753,7 @@ var makeSerializedEnsIndexerPublicConfigSchema = (valueLabel = "Serialized ENSIn
   isSubgraphCompatible: import_v43.z.boolean({
     error: `${valueLabel}.isSubgraphCompatible must be a boolean value.`
   }),
-  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
+  clientLabelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.clientLabelSet`),
   namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
   plugins: makePluginsListSchema(`${valueLabel}.plugins`),
   versionInfo: makeEnsIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
@@ -846,7 +853,7 @@ function serializeEnsIndexerPublicConfig(config) {
     ensRainbowPublicConfig,
     indexedChainIds,
     isSubgraphCompatible: isSubgraphCompatible2,
-    labelSet,
+    clientLabelSet,
     namespace,
     plugins,
     versionInfo
@@ -856,7 +863,7 @@ function serializeEnsIndexerPublicConfig(config) {
     ensRainbowPublicConfig,
     indexedChainIds: serializeIndexedChainIds(indexedChainIds),
     isSubgraphCompatible: isSubgraphCompatible2,
-    labelSet,
+    clientLabelSet,
     namespace,
     plugins,
     versionInfo
@@ -2101,21 +2108,21 @@ function validateEnsIndexerPublicConfigCompatibility(configA, configB) {
       ].join(" ")
     );
   }
-  if (configA.labelSet.labelSetId !== configB.labelSet.labelSetId) {
+  if (configA.clientLabelSet.labelSetId !== configB.clientLabelSet.labelSetId) {
     throw new Error(
       [
-        `'labelSet.labelSetId' must be compatible.`,
-        `Stored Config 'labelSet.labelSetId': '${configA.labelSet.labelSetId}'.`,
-        `Current Config 'labelSet.labelSetId': '${configB.labelSet.labelSetId}'.`
+        `'clientLabelSet.labelSetId' must be compatible.`,
+        `Stored Config 'clientLabelSet.labelSetId': '${configA.clientLabelSet.labelSetId}'.`,
+        `Current Config 'clientLabelSet.labelSetId': '${configB.clientLabelSet.labelSetId}'.`
       ].join(" ")
     );
   }
-  if (configA.labelSet.labelSetVersion !== configB.labelSet.labelSetVersion) {
+  if (configA.clientLabelSet.labelSetVersion !== configB.clientLabelSet.labelSetVersion) {
     throw new Error(
       [
-        `'labelSet.labelSetVersion' must be compatible.`,
-        `Stored Config 'labelSet.labelSetVersion': '${configA.labelSet.labelSetVersion}'.`,
-        `Current Config 'labelSet.labelSetVersion': '${configB.labelSet.labelSetVersion}'.`
+        `'clientLabelSet.labelSetVersion' must be compatible.`,
+        `Stored Config 'clientLabelSet.labelSetVersion': '${configA.clientLabelSet.labelSetVersion}'.`,
+        `Current Config 'clientLabelSet.labelSetVersion': '${configB.clientLabelSet.labelSetVersion}'.`
       ].join(" ")
     );
   }
@@ -2206,12 +2213,12 @@ function validateEnsIndexerVersionInfo(unvalidatedVersionInfo) {
 }
 
 // src/ensnode/api/indexing-status/deserialize.ts
-var import_v427 = require("zod/v4");
+var import_v428 = require("zod/v4");
 
 // src/stack-info/deserialize/ensnode-stack-info.ts
-var import_v425 = require("zod/v4");
+var import_v426 = require("zod/v4");
 
-// src/stack-info/zod-schemas/ensnode-stack-info.ts
+// src/stack-info/zod-schemas/ensindexer-stack-info.ts
 var import_v424 = require("zod/v4");
 
 // src/ensdb/zod-schemas/config.ts
@@ -2220,49 +2227,134 @@ var makeEnsDbVersionInfoSchema = (valueLabel) => {
   const label = valueLabel ?? "EnsDbVersionInfo";
   return import_v423.z.object({
     postgresql: import_v423.z.string().nonempty(`${label}.postgresql must be a non-empty string`).describe("Version of the PostgreSQL server hosting the ENSDb instance.")
-  }).describe(label);
+  });
 };
 var makeEnsDbPublicConfigSchema = (valueLabel) => {
   const label = valueLabel ?? "EnsDbPublicConfig";
   return import_v423.z.object({
     versionInfo: makeEnsDbVersionInfoSchema(`${label}.versionInfo`)
-  }).describe(label);
+  });
 };
 
-// src/stack-info/zod-schemas/ensnode-stack-info.ts
-function makeSerializedEnsNodeStackInfoSchema(valueLabel) {
-  const label = valueLabel ?? "ENSNodeStackInfo";
+// src/stack-info/zod-schemas/ensindexer-stack-info.ts
+function makeSerializedEnsIndexerStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSIndexerStackInfo";
   return import_v424.z.object({
-    ensApi: makeSerializedEnsApiPublicConfigSchema(`${label}.ensApi`),
     ensDb: makeEnsDbPublicConfigSchema(`${label}.ensDb`),
     ensIndexer: makeSerializedEnsIndexerPublicConfigSchema(`${label}.ensIndexer`),
-    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`).optional()
+    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`)
   });
 }
-function makeEnsNodeStackInfoSchema(valueLabel) {
-  const label = valueLabel ?? "ENSNodeStackInfo";
+function invariant_ensRainbowCompatibilityWithEnsIndexer(ctx) {
+  const { ensIndexer, ensRainbow } = ctx.value;
+  const { clientLabelSet } = ensIndexer;
+  const { serverLabelSet } = ensRainbow;
+  if (clientLabelSet.labelSetId !== serverLabelSet.labelSetId) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `ENSRainbow's label set (id: ${serverLabelSet.labelSetId}) must be the same as ENSIndexer's label set (id: ${clientLabelSet.labelSetId}).`
+    });
+  }
+  if (clientLabelSet.labelSetVersion > serverLabelSet.highestLabelSetVersion) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `ENSRainbow's server label set version (highest: ${serverLabelSet.highestLabelSetVersion}) must be greater than or equal to ENSIndexer's client label set version (current: ${clientLabelSet.labelSetVersion}).`
+    });
+  }
+}
+function makeEnsIndexerStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSIndexerStackInfo";
   return import_v424.z.object({
-    ensApi: makeEnsApiPublicConfigSchema(`${label}.ensApi`),
     ensDb: makeEnsDbPublicConfigSchema(`${label}.ensDb`),
     ensIndexer: makeEnsIndexerPublicConfigSchema(`${label}.ensIndexer`),
-    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`).optional()
+    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`)
+  }).check(invariant_ensRainbowCompatibilityWithEnsIndexer);
+}
+
+// src/stack-info/zod-schemas/ensnode-stack-info.ts
+function invariant_ensApiCompatibilityWithEnsIndexerAndEnsRainbow(ctx) {
+  const { ensApi, ensIndexer, ensRainbow } = ctx.value;
+  if (ensIndexer.versionInfo.ensDb !== ensApi.versionInfo.ensApi) {
+    ctx.issues.push({
+      code: "custom",
+      path: ["ensIndexer", "versionInfo", "ensDb"],
+      input: ensIndexer.versionInfo.ensDb,
+      message: `Version Mismatch: ENSDB@${ensIndexer.versionInfo.ensDb} !== ENSApi@${ensApi.versionInfo.ensApi}`
+    });
+  }
+  if (ensIndexer.versionInfo.ensIndexer !== ensApi.versionInfo.ensApi) {
+    ctx.issues.push({
+      code: "custom",
+      path: ["ensIndexer", "versionInfo", "ensIndexer"],
+      input: ensIndexer.versionInfo.ensIndexer,
+      message: `Version Mismatch: ENSIndexer@${ensIndexer.versionInfo.ensIndexer} !== ENSApi@${ensApi.versionInfo.ensApi}`
+    });
+  }
+  if (ensRainbow.versionInfo.ensRainbow !== ensApi.versionInfo.ensApi) {
+    ctx.issues.push({
+      code: "custom",
+      path: ["ensRainbow", "versionInfo", "ensRainbow"],
+      input: ensRainbow.versionInfo.ensRainbow,
+      message: `Version Mismatch: ENSRainbow@${ensRainbow.versionInfo.ensRainbow} !== ENSApi@${ensApi.versionInfo.ensApi}`
+    });
+  }
+  if (ensIndexer.versionInfo.ensNormalize !== ensApi.versionInfo.ensNormalize) {
+    ctx.issues.push({
+      code: "custom",
+      path: ["ensIndexer", "versionInfo", "ensNormalize"],
+      input: ensIndexer.versionInfo.ensNormalize,
+      message: `Dependency Version Mismatch: '@adraffy/ens-normalize' version must be the same between ENSIndexer and ENSApi. Found ENSApi@${ensApi.versionInfo.ensNormalize} and ENSIndexer@${ensIndexer.versionInfo.ensNormalize}`
+    });
+  }
+}
+function makeSerializedEnsNodeStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSNodeStackInfo";
+  return makeSerializedEnsIndexerStackInfoSchema(label).extend({
+    ensApi: makeSerializedEnsApiPublicConfigSchema(`${label}.ensApi`)
   });
 }
+function makeEnsNodeStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSNodeStackInfo";
+  return makeEnsIndexerStackInfoSchema(label).extend({
+    ensApi: makeEnsApiPublicConfigSchema(`${label}.ensApi`)
+  }).check(invariant_ensApiCompatibilityWithEnsIndexerAndEnsRainbow).check(invariant_ensRainbowCompatibilityWithEnsIndexer);
+}
+
+// src/stack-info/deserialize/ensindexer-stack-info.ts
+var import_v425 = require("zod/v4");
+function buildUnvalidatedEnsIndexerStackInfo(serializedStackInfo) {
+  const { ensDb, ensRainbow } = serializedStackInfo;
+  const ensIndexer = buildUnvalidatedEnsIndexerPublicConfig(serializedStackInfo.ensIndexer);
+  return {
+    ensDb,
+    ensIndexer,
+    ensRainbow
+  };
+}
+function deserializeEnsIndexerStackInfo(maybeStackInfo, valueLabel) {
+  const parsed = makeSerializedEnsIndexerStackInfoSchema(valueLabel).transform(buildUnvalidatedEnsIndexerStackInfo).pipe(makeEnsIndexerStackInfoSchema(valueLabel)).safeParse(maybeStackInfo);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize EnsIndexerStackInfo:
+${(0, import_v425.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
 
 // src/stack-info/deserialize/ensnode-stack-info.ts
 function buildUnvalidatedEnsNodeStackInfo(serializedStackInfo) {
-  const { ensApi, ensIndexer, ...rest } = serializedStackInfo;
   return {
-    ...rest,
-    ensApi: buildUnvalidatedEnsApiPublicConfig(ensApi),
-    ensIndexer: buildUnvalidatedEnsIndexerPublicConfig(ensIndexer)
+    ...buildUnvalidatedEnsIndexerStackInfo(serializedStackInfo),
+    ensApi: buildUnvalidatedEnsApiPublicConfig(serializedStackInfo.ensApi)
   };
 }
 function deserializeEnsNodeStackInfo(maybeStackInfo, valueLabel) {
   const parsed = makeSerializedEnsNodeStackInfoSchema(valueLabel).transform(buildUnvalidatedEnsNodeStackInfo).pipe(makeEnsNodeStackInfoSchema(valueLabel)).safeParse(maybeStackInfo);
   if (parsed.error) {
     throw new Error(`Cannot deserialize EnsNodeStackInfo:
-${(0, import_v425.prettifyError)(parsed.error)}
+${(0, import_v426.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2282,25 +2374,25 @@ var EnsApiIndexingStatusResponseCodes = {
 var IndexingStatusResponseCodes = EnsApiIndexingStatusResponseCodes;
 
 // src/ensnode/api/indexing-status/zod-schemas.ts
-var import_v426 = require("zod/v4");
-var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v426.z.strictObject({
-  responseCode: import_v426.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
+var import_v427 = require("zod/v4");
+var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v427.z.strictObject({
+  responseCode: import_v427.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel),
   stackInfo: makeEnsNodeStackInfoSchema(valueLabel)
 });
-var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v426.z.strictObject({
-  responseCode: import_v426.z.literal(EnsApiIndexingStatusResponseCodes.Error)
+var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v427.z.strictObject({
+  responseCode: import_v427.z.literal(EnsApiIndexingStatusResponseCodes.Error)
 });
-var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v426.z.discriminatedUnion("responseCode", [
+var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v427.z.discriminatedUnion("responseCode", [
   makeEnsApiIndexingStatusResponseOkSchema(valueLabel),
   makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
 ]);
-var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v426.z.object({
-  responseCode: import_v426.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
+var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v427.z.object({
+  responseCode: import_v427.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel),
   stackInfo: makeSerializedEnsNodeStackInfoSchema(valueLabel)
 });
-var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v426.z.discriminatedUnion("responseCode", [
+var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v427.z.discriminatedUnion("responseCode", [
   makeSerializedEnsApiIndexingStatusResponseOkSchema(valueLabel),
   makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
 ]);
@@ -2322,7 +2414,7 @@ function deserializeEnsApiIndexingStatusResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize EnsApiIndexingStatusResponse:
-${(0, import_v427.prettifyError)(parsed.error)}
+${(0, import_v428.prettifyError)(parsed.error)}
 `
     );
   }
@@ -2330,13 +2422,26 @@ ${(0, import_v427.prettifyError)(parsed.error)}
 }
 var deserializeIndexingStatusResponse = deserializeEnsApiIndexingStatusResponse;
 
+// src/stack-info/serialize/ensindexer-stack-info.ts
+function serializeEnsIndexerStackInfo(stackInfo) {
+  const {
+    ensDb: serializedEnsDbPublicConfig,
+    ensRainbow: serializedEnsRainbowPublicConfig,
+    ensIndexer
+  } = stackInfo;
+  const serializedEnsIndexerPublicConfig = serializeEnsIndexerPublicConfig(ensIndexer);
+  return {
+    ensDb: serializedEnsDbPublicConfig,
+    ensIndexer: serializedEnsIndexerPublicConfig,
+    ensRainbow: serializedEnsRainbowPublicConfig
+  };
+}
+
 // src/stack-info/serialize/ensnode-stack-info.ts
 function serializeEnsNodeStackInfo(stackInfo) {
   return {
-    ensApi: serializeEnsApiPublicConfig(stackInfo.ensApi),
-    ensDb: stackInfo.ensDb,
-    ensIndexer: serializeEnsIndexerPublicConfig(stackInfo.ensIndexer),
-    ensRainbow: stackInfo.ensRainbow
+    ...serializeEnsIndexerStackInfo(stackInfo),
+    ensApi: serializeEnsApiPublicConfig(stackInfo.ensApi)
   };
 }
 
@@ -2356,11 +2461,11 @@ function serializeEnsApiIndexingStatusResponse(response) {
 var serializeIndexingStatusResponse = serializeEnsApiIndexingStatusResponse;
 
 // src/ensnode/api/name-tokens/deserialize.ts
-var import_v432 = require("zod/v4");
+var import_v433 = require("zod/v4");
 
 // src/ensnode/api/name-tokens/zod-schemas.ts
 var import_enssdk5 = require("enssdk");
-var import_v431 = require("zod/v4");
+var import_v432 = require("zod/v4");
 
 // src/tokenscope/name-token.ts
 var import_enssdk4 = require("enssdk");
@@ -2402,17 +2507,17 @@ var makeContractMatcher = (namespace, b) => (datasourceName, contractName) => {
 // src/tokenscope/assets.ts
 var import_enssdk3 = require("enssdk");
 var import_viem6 = require("viem");
-var import_v429 = require("zod/v4");
+var import_v430 = require("zod/v4");
 
 // src/tokenscope/zod-schemas.ts
 var import_caip2 = require("caip");
 var import_enssdk2 = require("enssdk");
 var import_viem5 = require("viem");
-var import_v428 = require("zod/v4");
-var tokenIdSchemaSerializable = import_v428.z.string();
-var tokenIdSchemaNative = import_v428.z.preprocess(
+var import_v429 = require("zod/v4");
+var tokenIdSchemaSerializable = import_v429.z.string();
+var tokenIdSchemaNative = import_v429.z.preprocess(
   (v) => typeof v === "string" ? BigInt(v) : v,
-  import_v428.z.bigint().positive()
+  import_v429.z.bigint().positive()
 );
 function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false) {
   if (serializable) {
@@ -2422,13 +2527,13 @@ function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false
   }
 }
 var makeAssetIdSchema = (valueLabel = "Asset ID Schema", serializable) => {
-  return import_v428.z.object({
-    assetNamespace: import_v428.z.enum(import_enssdk2.AssetNamespaces),
+  return import_v429.z.object({
+    assetNamespace: import_v429.z.enum(import_enssdk2.AssetNamespaces),
     contract: makeAccountIdSchema(valueLabel),
     tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
   });
 };
-var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v428.z.preprocess((v) => {
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v429.z.preprocess((v) => {
   if (typeof v === "string") {
     const result = new import_caip2.AssetId(v);
     return {
@@ -2452,20 +2557,20 @@ function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v428.z.object({
-  ownershipType: import_v428.z.literal(NameTokenOwnershipTypes.NameWrapper),
+var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v429.z.object({
+  ownershipType: import_v429.z.literal(NameTokenOwnershipTypes.NameWrapper),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v428.z.object({
-  ownershipType: import_v428.z.literal(NameTokenOwnershipTypes.FullyOnchain),
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v429.z.object({
+  ownershipType: import_v429.z.literal(NameTokenOwnershipTypes.FullyOnchain),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v428.z.object({
-  ownershipType: import_v428.z.literal(NameTokenOwnershipTypes.Burned),
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v429.z.object({
+  ownershipType: import_v429.z.literal(NameTokenOwnershipTypes.Burned),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
-var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v428.z.object({
-  ownershipType: import_v428.z.literal(NameTokenOwnershipTypes.Unknown),
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v429.z.object({
+  ownershipType: import_v429.z.literal(NameTokenOwnershipTypes.Unknown),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
 function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
@@ -2478,16 +2583,16 @@ function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v428.z.discriminatedUnion("ownershipType", [
+var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v429.z.discriminatedUnion("ownershipType", [
   makeNameTokenOwnershipNameWrapperSchema(valueLabel),
   makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
   makeNameTokenOwnershipBurnedSchema(valueLabel),
   makeNameTokenOwnershipUnknownSchema(valueLabel)
 ]);
-var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v428.z.object({
+var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v429.z.object({
   token: makeAssetIdSchema(`${valueLabel}.token`, serializable),
   ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
-  mintStatus: import_v428.z.enum(NFTMintStatuses)
+  mintStatus: import_v429.z.enum(NFTMintStatuses)
 });
 
 // src/tokenscope/assets.ts
@@ -2503,7 +2608,7 @@ function deserializeAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AssetId:
-${(0, import_v429.prettifyError)(parsed.error)}
+${(0, import_v430.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2513,7 +2618,7 @@ function parseAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot parse AssetId:
-${(0, import_v429.prettifyError)(parsed.error)}
+${(0, import_v430.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2814,10 +2919,10 @@ function getNameTokenOwnership(namespaceId, name, owner) {
 }
 
 // src/ensnode/api/shared/errors/zod-schemas.ts
-var import_v430 = require("zod/v4");
-var makeErrorResponseSchema = () => import_v430.z.object({
-  message: import_v430.z.string(),
-  details: import_v430.z.optional(import_v430.z.unknown())
+var import_v431 = require("zod/v4");
+var makeErrorResponseSchema = () => import_v431.z.object({
+  message: import_v431.z.string(),
+  details: import_v431.z.optional(import_v431.z.unknown())
 });
 
 // src/ensnode/api/name-tokens/response.ts
@@ -2856,10 +2961,10 @@ var NameTokensResponseErrorCodes = {
 };
 
 // src/ensnode/api/name-tokens/zod-schemas.ts
-var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v431.z.object({
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v432.z.object({
   domainId: makeNodeSchema(`${valueLabel}.domainId`),
   name: makeReinterpretedNameSchema(valueLabel),
-  tokens: import_v431.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
+  tokens: import_v432.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
   expiresAt: makeUnixTimestampSchema(`${valueLabel}.expiresAt`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 }).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
@@ -2901,32 +3006,32 @@ var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", seria
     });
   }
 });
-var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v431.z.strictObject({
-  responseCode: import_v431.z.literal(NameTokensResponseCodes.Ok),
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v432.z.strictObject({
+  responseCode: import_v432.z.literal(NameTokensResponseCodes.Ok),
   registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`, serializable)
 });
-var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v431.z.strictObject({
-  responseCode: import_v431.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v431.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v432.z.strictObject({
+  responseCode: import_v432.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v432.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
   error: makeErrorResponseSchema()
 });
-var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v431.z.strictObject({
-  responseCode: import_v431.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v431.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v432.z.strictObject({
+  responseCode: import_v432.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v432.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
   error: makeErrorResponseSchema()
 });
-var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v431.z.strictObject({
-  responseCode: import_v431.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v431.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v432.z.strictObject({
+  responseCode: import_v432.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v432.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
   error: makeErrorResponseSchema()
 });
-var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v431.z.discriminatedUnion("errorCode", [
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v432.z.discriminatedUnion("errorCode", [
   makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
   makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
   makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
 ]);
 var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response", serializable) => {
-  return import_v431.z.discriminatedUnion("responseCode", [
+  return import_v432.z.discriminatedUnion("responseCode", [
     makeNameTokensResponseOkSchema(valueLabel, serializable ?? false),
     makeNameTokensResponseErrorSchema(valueLabel)
   ]);
@@ -2939,7 +3044,7 @@ function deserializedNameTokensResponse(maybeResponse) {
   );
   if (parsed.error) {
     throw new Error(`Cannot deserialize NameTokensResponse:
-${(0, import_v432.prettifyError)(parsed.error)}
+${(0, import_v433.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -3013,14 +3118,14 @@ function serializeNameTokensResponse(response) {
 }
 
 // src/ensnode/api/registrar-actions/deserialize.ts
-var import_v436 = require("zod/v4");
+var import_v437 = require("zod/v4");
 
 // src/ensnode/api/registrar-actions/zod-schemas.ts
 var import_enssdk7 = require("enssdk");
-var import_v435 = require("zod/v4");
+var import_v436 = require("zod/v4");
 
 // src/registrars/zod-schemas.ts
-var import_v433 = require("zod/v4");
+var import_v434 = require("zod/v4");
 
 // src/registrars/encoded-referrer.ts
 var import_enssdk6 = require("enssdk");
@@ -3094,11 +3199,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v433.z.object({
+var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v434.z.object({
   subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
   node: makeNodeSchema(`${valueLabel} Node`)
 });
-var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v433.z.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v434.z.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -3114,18 +3219,18 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v433.z.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v434.z.union([
   // pricing available
-  import_v433.z.object({
+  import_v434.z.object({
     baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
     premium: makePriceEthSchema(`${valueLabel} Premium`),
     total: makePriceEthSchema(`${valueLabel} Total`)
   }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
   // pricing unknown
-  import_v433.z.object({
-    baseCost: import_v433.z.null(),
-    premium: import_v433.z.null(),
-    total: import_v433.z.null()
+  import_v434.z.object({
+    baseCost: import_v434.z.null(),
+    premium: import_v434.z.null(),
+    total: import_v434.z.null()
   }).transform((v) => v)
 ]);
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
@@ -3148,9 +3253,9 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
     });
   }
 }
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v433.z.union([
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v434.z.union([
   // referral available
-  import_v433.z.object({
+  import_v434.z.object({
     encodedReferrer: makeHexStringSchema(
       { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
       `${valueLabel} Encoded Referrer`
@@ -3158,9 +3263,9 @@ var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral
     decodedReferrer: makeNormalizedAddressSchema(`${valueLabel} Decoded Referrer`)
   }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
   // referral not applicable
-  import_v433.z.object({
-    encodedReferrer: import_v433.z.null(),
-    decodedReferrer: import_v433.z.null()
+  import_v434.z.object({
+    encodedReferrer: import_v434.z.null(),
+    decodedReferrer: import_v434.z.null()
   })
 ]);
 function invariant_eventIdsInitialElementIsTheActionId(ctx) {
@@ -3173,9 +3278,9 @@ function invariant_eventIdsInitialElementIsTheActionId(ctx) {
     });
   }
 }
-var EventIdSchema = import_v433.z.string().nonempty();
-var EventIdsSchema = import_v433.z.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchemaWithoutCheck = (valueLabel = "Base Registrar Action") => import_v433.z.object({
+var EventIdSchema = import_v434.z.string().nonempty();
+var EventIdsSchema = import_v434.z.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchemaWithoutCheck = (valueLabel = "Base Registrar Action") => import_v434.z.object({
   id: EventIdSchema,
   incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
   registrant: makeNormalizedAddressSchema(`${valueLabel} Registrant`),
@@ -3190,36 +3295,36 @@ var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => ma
   invariant_eventIdsInitialElementIsTheActionId
 );
 var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v433.z.literal(RegistrarActionTypes.Registration)
+  type: import_v434.z.literal(RegistrarActionTypes.Registration)
 });
 var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v433.z.literal(RegistrarActionTypes.Renewal)
+  type: import_v434.z.literal(RegistrarActionTypes.Renewal)
 });
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v433.z.discriminatedUnion("type", [
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v434.z.discriminatedUnion("type", [
   makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
   makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
 ]);
 
 // src/ensnode/api/shared/pagination/zod-schemas.ts
-var import_v434 = require("zod/v4");
+var import_v435 = require("zod/v4");
 
 // src/ensnode/api/shared/pagination/request.ts
 var RECORDS_PER_PAGE_DEFAULT = 10;
 var RECORDS_PER_PAGE_MAX = 100;
 
 // src/ensnode/api/shared/pagination/zod-schemas.ts
-var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v434.z.object({
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v435.z.object({
   page: makePositiveIntegerSchema(`${valueLabel}.page`),
   recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
     RECORDS_PER_PAGE_MAX,
     `${valueLabel}.recordsPerPage must not exceed ${RECORDS_PER_PAGE_MAX}`
   )
 });
-var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v434.z.object({
-  totalRecords: import_v434.z.literal(0),
-  totalPages: import_v434.z.literal(1),
-  hasNext: import_v434.z.literal(false),
-  hasPrev: import_v434.z.literal(false)
+var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v435.z.object({
+  totalRecords: import_v435.z.literal(0),
+  totalPages: import_v435.z.literal(1),
+  hasNext: import_v435.z.literal(false),
+  hasPrev: import_v435.z.literal(false)
 }).extend(makeRequestPageParamsSchema(valueLabel).shape);
 function invariant_responsePageWithRecordsIsCorrect(ctx) {
   const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
@@ -3254,15 +3359,15 @@ function invariant_responsePageWithRecordsIsCorrect(ctx) {
     });
   }
 }
-var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v434.z.object({
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v435.z.object({
   totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: import_v434.z.boolean(),
-  hasPrev: import_v434.z.boolean(),
+  hasNext: import_v435.z.boolean(),
+  hasPrev: import_v435.z.boolean(),
   startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
   endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
 }).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
-var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v434.z.union([
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v435.z.union([
   makeResponsePageContextSchemaWithNoRecords(valueLabel),
   makeResponsePageContextSchemaWithRecords(valueLabel)
 ]);
@@ -3292,21 +3397,21 @@ function invariant_registrationLifecycleNodeMatchesName(ctx) {
     });
   }
 }
-var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v435.z.object({
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v436.z.object({
   action: makeRegistrarActionSchema(valueLabel),
   name: makeReinterpretedNameSchema(valueLabel)
 }).check(invariant_registrationLifecycleNodeMatchesName);
-var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v435.z.object({
-  responseCode: import_v435.z.literal(RegistrarActionsResponseCodes.Ok),
-  registrarActions: import_v435.z.array(makeNamedRegistrarActionSchema(valueLabel)),
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v436.z.object({
+  responseCode: import_v436.z.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: import_v436.z.array(makeNamedRegistrarActionSchema(valueLabel)),
   pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
-var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v435.z.strictObject({
-  responseCode: import_v435.z.literal(RegistrarActionsResponseCodes.Error),
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v436.z.strictObject({
+  responseCode: import_v436.z.literal(RegistrarActionsResponseCodes.Error),
   error: makeErrorResponseSchema()
 });
-var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v435.z.discriminatedUnion("responseCode", [
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v436.z.discriminatedUnion("responseCode", [
   makeRegistrarActionsResponseOkSchema(valueLabel),
   makeRegistrarActionsResponseErrorSchema(valueLabel)
 ]);
@@ -3317,7 +3422,7 @@ function deserializeRegistrarActionsResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize RegistrarActionsResponse:
-${(0, import_v436.prettifyError)(parsed.error)}
+${(0, import_v437.prettifyError)(parsed.error)}
 `
     );
   }
@@ -3454,12 +3559,12 @@ function serializeRegistrarActionsResponse(response) {
 }
 
 // src/ensnode/api/shared/errors/deserialize.ts
-var import_v437 = require("zod/v4");
+var import_v438 = require("zod/v4");
 function deserializeErrorResponse2(maybeErrorResponse) {
   const parsed = makeErrorResponseSchema().safeParse(maybeErrorResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ErrorResponse:
-${(0, import_v437.prettifyError)(parsed.error)}
+${(0, import_v438.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4026,14 +4131,14 @@ function isResolvedIdentity(identity) {
 }
 
 // src/indexing-status/deserialize/chain-indexing-status-snapshot.ts
-var import_v438 = require("zod/v4");
+var import_v439 = require("zod/v4");
 function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(maybeSnapshot);
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into ChainIndexingStatusSnapshot:
-${(0, import_v438.prettifyError)(parsed.error)}
+${(0, import_v439.prettifyError)(parsed.error)}
 `
     );
   }
@@ -4051,26 +4156,26 @@ function createRealtimeIndexingStatusProjection(snapshot, now) {
 }
 
 // src/indexing-status/validate/chain-indexing-status-snapshot.ts
-var import_v439 = require("zod/v4");
+var import_v440 = require("zod/v4");
 function validateChainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid ChainIndexingStatusSnapshot:
-${(0, import_v439.prettifyError)(parsed.error)}
+${(0, import_v440.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
 // src/indexing-status/validate/realtime-indexing-status-projection.ts
-var import_v440 = require("zod/v4");
+var import_v441 = require("zod/v4");
 function validateRealtimeIndexingStatusProjection(unvalidatedProjection, valueLabel) {
   const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedProjection);
   if (parsed.error) {
     throw new Error(`Invalid RealtimeIndexingStatusProjection:
-${(0, import_v440.prettifyError)(parsed.error)}
+${(0, import_v441.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4253,13 +4358,13 @@ var import_getUnixTime2 = require("date-fns/getUnixTime");
 var import_getUnixTime = require("date-fns/getUnixTime");
 
 // src/shared/deserialize.ts
-var import_v441 = __toESM(require("zod/v4"), 1);
+var import_v442 = __toESM(require("zod/v4"), 1);
 function deserializeChainId(maybeChainId, valueLabel) {
   const schema = makeChainIdStringSchema(valueLabel);
   const parsed = schema.safeParse(maybeChainId);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ChainId:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v442.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4269,7 +4374,7 @@ function deserializeDatetime(maybeDatetime, valueLabel) {
   const parsed = schema.safeParse(maybeDatetime);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Datetime:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v442.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4279,7 +4384,7 @@ function deserializeUnixTimestamp(maybeTimestamp, valueLabel) {
   const parsed = schema.safeParse(maybeTimestamp);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Unix Timestamp:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v442.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4289,7 +4394,7 @@ function deserializeUrl(maybeUrl, valueLabel) {
   const parsed = schema.safeParse(maybeUrl);
   if (parsed.error) {
     throw new Error(`Cannot deserialize URL:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v442.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4299,7 +4404,7 @@ function deserializeBlockNumber(maybeBlockNumber, valueLabel) {
   const parsed = schema.safeParse(maybeBlockNumber);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockNumber:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v442.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4309,17 +4414,17 @@ function deserializeBlockRef(maybeBlockRef, valueLabel) {
   const parsed = schema.safeParse(maybeBlockRef);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockRef:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v442.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 function deserializeDuration(maybeDuration, valueLabel) {
-  const schema = import_v441.default.coerce.number().pipe(makeDurationSchema(valueLabel));
+  const schema = import_v442.default.coerce.number().pipe(makeDurationSchema(valueLabel));
   const parsed = schema.safeParse(maybeDuration);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize Duration:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v442.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4329,7 +4434,7 @@ function parseAccountId(maybeAccountId, valueLabel) {
   const parsed = schema.safeParse(maybeAccountId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AccountId:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v442.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4339,7 +4444,7 @@ function deserializePriceEth(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceEth:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v442.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4349,7 +4454,7 @@ function deserializePriceUsdc(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceUsdc:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v442.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4359,7 +4464,7 @@ function deserializePriceDai(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceDai:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v442.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4638,14 +4743,45 @@ function isWebSocketProtocol(url) {
   return ["ws:", "wss:"].includes(url.protocol);
 }
 
-// src/stack-info/ensnode-stack-info.ts
-function buildEnsNodeStackInfo(ensApiPublicConfig, ensDbPublicConfig) {
-  return {
-    ensApi: ensApiPublicConfig,
+// src/stack-info/validate/ensindexer-stack-info.ts
+var import_v443 = require("zod/v4");
+function validateEnsIndexerStackInfo(maybeStackInfo, valueLabel) {
+  const parsed = makeEnsIndexerStackInfoSchema(valueLabel).safeParse(maybeStackInfo);
+  if (parsed.error) {
+    throw new Error(`Cannot validate EnsIndexerStackInfo:
+${(0, import_v443.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/stack-info/ensindexer-stack-info.ts
+function buildEnsIndexerStackInfo(ensDbPublicConfig, ensIndexerPublicConfig, ensRainbowPublicConfig) {
+  return validateEnsIndexerStackInfo({
     ensDb: ensDbPublicConfig,
-    ensIndexer: ensApiPublicConfig.ensIndexerPublicConfig,
-    ensRainbow: ensApiPublicConfig.ensIndexerPublicConfig.ensRainbowPublicConfig
-  };
+    ensIndexer: ensIndexerPublicConfig,
+    ensRainbow: ensRainbowPublicConfig
+  });
+}
+
+// src/stack-info/validate/ensnode-stack-info.ts
+var import_v444 = require("zod/v4");
+function validateEnsNodeStackInfo(maybeStackInfo, valueLabel) {
+  const parsed = makeEnsNodeStackInfoSchema(valueLabel).safeParse(maybeStackInfo);
+  if (parsed.error) {
+    throw new Error(`Cannot validate EnsNodeStackInfo:
+${(0, import_v444.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/stack-info/ensnode-stack-info.ts
+function buildEnsNodeStackInfo(ensApiPublicConfig, ensDbPublicConfig, ensIndexerPublicConfig, ensRainbowPublicConfig) {
+  return validateEnsNodeStackInfo({
+    ...buildEnsIndexerStackInfo(ensDbPublicConfig, ensIndexerPublicConfig, ensRainbowPublicConfig),
+    ensApi: ensApiPublicConfig
+  });
 }
 
 // src/subgraph-api/prerequisites.ts