Please address the comments from this code review:

## Overall Comments
- The CLI option definitions for all artifact naming overrides are very repetitive; consider abstracting them into a shared descriptor array or helper to reduce duplication and simplify future additions.
- Default values for artifact names (e.g. "besu-node", "besu-genesis") are defined in multiple places (code, tests, Helm charts); centralizing these constants into a single shared module will ensure consistency and ease maintenance.
- The resolveText helper in runBootstrap closely mirrors resolveCount—extracting a generic `resolveOption` utility to handle both numeric and text prompts could streamline the logic and cut down on boilerplate.

## Individual Comments

### Comment 1
<location> `charts/network/charts/network-bootstrapper/templates/job.yaml:49-53` </location>
<code_context>
+            {{- $resolvedServiceName := default "besu-node" (default (get $globalNodes "serviceName") .Values.settings.staticNodeServiceName) }}
</code_context>

<issue_to_address>
**suggestion:** Helm template logic for resolving global overrides is nested and may be confusing.

Extracting the nested logic into helper templates or adding documentation on value precedence would improve maintainability.
</issue_to_address>

### Comment 2
<location> `src/cli/build-command.ts:173-175` </location>
<code_context>
 ): string[] => {
   const normalizedDomain = normalizeStaticNodeDomain(domain);
   const normalizedNamespace = normalizeStaticNodeNamespace(namespace);
+  const hostServiceName =
+    normalizeStaticNodeNamespace(serviceName) ?? serviceName;
+  const podNamePrefix = normalizeStaticNodeNamespace(podPrefix) ?? podPrefix;

   return nodes.map((node) => {
</code_context>

<issue_to_address>
**suggestion:** Normalization of serviceName and podPrefix may be unnecessary or inconsistent.

Ensure normalization is only applied to serviceName and podPrefix if they are meant to represent namespaces, as unnecessary normalization could cause issues.

```suggestion
  const hostServiceName = serviceName;
  const podNamePrefix = podPrefix;
```
</issue_to_address>

### Comment 3
<location> `src/cli/build-command.ts:262` </location>
<code_context>
     DEFAULT_VALIDATOR_COUNT
   );

+  const staticNodeServiceName = await resolveText(
+    "Static node service name",
+    staticNodeServiceNameOption,
</code_context>

<issue_to_address>
**issue (complexity):** Consider replacing the repeated resolveText calls with a loop over a config array to streamline the code.

You can collapse all five of your nearly‐identical `resolveText` calls into one loop over a small config array. For example:

```ts
// inside runBootstrap, replace individual calls with...

const textFields = [
  { key: "staticNodeServiceName",  label: "Static node service name",        provided: staticNodeServiceNameOption, defaultVal: DEFAULT_STATIC_NODE_SERVICE_NAME },
  { key: "staticNodePodPrefix",    label: "Static node pod prefix",          provided: staticNodePodPrefixOption,   defaultVal: DEFAULT_STATIC_NODE_POD_PREFIX },
  { key: "genesisConfigMapName",   label: "Genesis ConfigMap name",          provided: genesisConfigmapNameOption,   defaultVal: DEFAULT_GENESIS_CONFIGMAP_NAME },
  { key: "staticNodesConfigMapName", label: "Static nodes ConfigMap name",   provided: staticNodesConfigmapNameOption, defaultVal: DEFAULT_STATIC_NODES_CONFIGMAP_NAME },
  { key: "faucetArtifactPrefix",   label: "Faucet artifact prefix",          provided: faucetArtifactPrefixOption,   defaultVal: DEFAULT_FAUCET_ARTIFACT_PREFIX },
] as const;

const results = await Promise.all(
  textFields.map(f => resolveText(f.label, f.provided, f.defaultVal))
);

// destructure into named variables in order
const [
  staticNodeServiceName,
  staticNodePodPrefix,
  genesisConfigMapName,
  staticNodesConfigMapName,
  faucetArtifactPrefix
] = results;
```

This keeps all prompts exactly the same but removes ~20 lines of boilerplate.
</issue_to_address>

### Comment 4
<location> `src/cli/output.ts:189` </location>
<code_context>
 };

-const createValidatorSpecs = (nodes: readonly IndexedNode[]): ConfigMapSpec[] =>
+const createValidatorSpecs = (
+  nodes: readonly IndexedNode[],
+  validatorPrefix: string
</code_context>

<issue_to_address>
**issue (complexity):** Consider introducing a factory function to encapsulate artifact naming logic and return bound spec-creator functions.

You can collapse all of those “pass-the-prefix-everywhere” calls into a small factory that captures your `ArtifactNames` up-front and returns bound spec-creators. For example:

```ts
// new helper at top
function makeSpecFactory(names: ArtifactNames) {
  return {
    validatorSpecs: (nodes: IndexedNode[]): ConfigMapSpec[] =>
      nodes.flatMap<ConfigMapSpec>(node => {
        const ord = node.index - 1;
        const base = `${names.validatorPrefix}-${ord}`;
        return [
          { name:`${base}-address`,      key:"address",      value:node.address },
          { name:`${base}-private-key`,  key:"privateKey",   value:node.privateKey },
          { name:`${base}-enode`,        key:"enode",        value:node.enode },
          { name:`${base}-pubkey`,       key:"publicKey",    value:node.publicKey },
        ];
      }),
    faucetConfigSpecs: (faucet: GeneratedNodeKey): ConfigMapSpec[] => [
      { name:`${names.faucetPrefix}-address`, key:"address",   value:faucet.address },
      { name:`${names.faucetPrefix}-pubkey`,  key:"publicKey", value:faucet.publicKey },
    ],
    faucetSecretSpecs: (faucet: GeneratedNodeKey): SecretSpec[] => [
      { name:`${names.faucetPrefix}-private-key`, key:"privateKey", value:faucet.privateKey },
    ],
  };
}
```

Then in both `outputToFile` and `outputToKubernetes` you only need:

```ts
const { validatorSpecs, faucetConfigSpecs, faucetSecretSpecs } =
  makeSpecFactory(payload.artifactNames);

const vSpecs = validatorSpecs(payload.validators);
const fCfg  = faucetConfigSpecs(payload.faucet);
const fSec  = faucetSecretSpecs(payload.faucet);

// …use vSpecs, fCfg, fSec in writes/upserts…
```

This:

- removes the need to pass prefixes into every call  
- keeps all functionality the same  
- localizes naming logic to one small helper.
</issue_to_address>

### Comment 5
<location> `src/cli/output.test.ts:335` </location>
<code_context>
     }
   });

+  test("kubernetes output respects custom artifact names", async () => {
+    const originalLoad = (KubeConfig.prototype as any).loadFromCluster;
+    const originalMake = (KubeConfig.prototype as any).makeApiClient;
</code_context>

<issue_to_address>
**issue (complexity):** Consider extracting Kubernetes test stubs and common assertions into helper functions to reduce repetition and clarify each test's unique logic.

Here’s one way you can DRY-up the Kubernetes tests by extracting the client/file stub and common assertions into helpers.  You’ll end up with each test only describing its unique bits:

```ts
// in test/utils/kube.ts
import { CoreV1Api, KubeConfig } from "@kubernetes/client-node";
import { Bun } from "bun";

// returns stubs & a restore() fn
export function setupKubeMocks() {
  const createdConfigMaps: string[] = [];
  const createdSecrets: string[] = [];
  const originalLoad = (KubeConfig.prototype as any).loadFromCluster;
  const originalMake = (KubeConfig.prototype as any).makeApiClient;
  const originalFile = (Bun as any).file;

  ;(KubeConfig.prototype as any).loadFromCluster = () => {};
  ;(KubeConfig.prototype as any).makeApiClient = () =>
    ({
      listNamespacedConfigMap: () => Promise.resolve(),
      listNamespacedSecret: () => Promise.resolve(),
      createNamespacedConfigMap: ({ body }) => {
        createdConfigMaps.push(body.metadata.name);
        return Promise.resolve();
      },
      createNamespacedSecret: ({ body }) => {
        createdSecrets.push(body.metadata.name);
        return Promise.resolve();
      },
    } as unknown as CoreV1Api);

  ;(Bun as any).file = () =>
    ({ text: () => Promise.resolve("custom-namespace") } as any);

  return {
    createdConfigMaps,
    createdSecrets,
    restore() {
      (KubeConfig.prototype as any).loadFromCluster = originalLoad;
      (KubeConfig.prototype as any).makeApiClient = originalMake;
      (Bun as any).file = originalFile;
    },
  };
}

// in test/utils/assert.ts
export function expectNames(
  actual: string[],
  expected: string[],
) {
  expected.forEach(name => expect(actual).toContain(name));
}
```

Then your new test shrinks to:

```ts
import { setupKubeMocks } from "./utils/kube";
import { expectNames } from "./utils/assert";

test("kubernetes output respects custom artifact names", async () => {
  const { createdConfigMaps, createdSecrets, restore } = setupKubeMocks();
  try {
    const payload = {
      ...samplePayload,
      artifactNames: {
        faucetPrefix: "custom-faucet",
        validatorPrefix: "custom-validator",
        genesisConfigMapName: "custom-genesis",
        staticNodesConfigMapName: "custom-static",
      },
      staticNodes: [
        staticNodeUri(
          sampleValidator,
          SAMPLE_STATIC_DOMAIN,
          DEFAULT_STATIC_NODE_PORT,
          DEFAULT_STATIC_NODE_DISCOVERY_PORT,
          SAMPLE_STATIC_NAMESPACE,
          "custom-service",
          "custom-validator",
        ),
      ],
    };

    await outputResult("kubernetes", payload);

    expectNames(
      createdConfigMaps.sort(),
      ["custom-genesis", "custom-static", "custom-validator-0-address", "custom-faucet-address"],
    );
    expectNames(
      createdSecrets.sort(),
      ["custom-faucet-private-key", "custom-validator-0-private-key"],
    );
  } finally {
    restore();
  }
});
```

This removes the repeated stubbing/teardown and the verbose per‐name loops, leaving only what’s unique to each test.
</issue_to_address>