I looked at the sample project template folder and did not see a .js or .cjs file showing how to work with multi-value.

This post is helpful for multi-value inputs, but how do we populate multi-value outputs as well in Node?

You can combine multiple outputs with a separator-that-doesn't-appear-in-your-data (e.g., the | character) into a single string and then using the Split token function to create a multi-value token from that output.  Note that the separator can be multiple characters and even use tokens.

The output string can be created from an array of values using JavaScript's array.join method.

And, yes, this is a workaround--as far as I know, there is no direct support for outputting a multi-value token in a NodeJS script.

Oh I see, I can't select Multi-Value for the output fields in the rule. I saw it but didn't realize it was not selectable. This will work as a workaround. Thanks!

I am not having any luck with this function, for example if I send a single token with 2 values

1. Hello
2. World

I get back "Hello,World" which is just my 2 values in a single comma delimited string

Therefore if I send values

1. Hello,World
2. World,Hello

I get back "Hello,World,World,Hello" which looks like 4 values not 2

How do we actually For Each on the values we receive from the start?

If your data contains commas, you can't use comma as your separator.  I suggest using something like | (bar) or even multiple characters together (e.g. |||) such that it's guaranteed to be unique relative to your data.
 

Here's a full example (script + workflow):

Script

var getArgumentMap = function (args) {
    let argMap = {};
    if (args == null) {
        console.error("Invalid arguments.");
    }
    for (let i = 2; i < args.length; i++) {
        try {
            let arg = args[i];
            let idx = arg.indexOf('=');
            if (idx > 0) {
                let key = arg.substring(0, idx);
                let val = arg.substring(idx + 1);
                argMap[key] = val
            }
        }
        catch (e) {
            console.error(`Could not parse arguments: ${args}`);
            throw e;
        }
    }
    return argMap;
};

var setOutputsFromObject = function (obj) {
	for (var key in obj) {
		console.log(`${key}:${obj[key]}`);
	}
};

var unwrapValue = function(value) {
	if (value[0] === "'" && value[value.length - 1] === "'" )
		return value.substr(1, value.length - 2);
	else
		return value;
}

var inputs = getArgumentMap(process.argv);


var unquotedList = unwrapValue(inputs['List']);
var unquotedValue = unwrapValue(inputs['ValueToAppend']);

var list = JSON.parse(unquotedList);
var valueToAdd = JSON.parse(unquotedValue);

list.push(valueToAdd);

var joinedList = list.join('|');

setOutputsFromObject({ 'UpdatedList': joinedList });

Workflow

Workflow Instance Results

Side Note: since my script using JSON.Parse to parse the input multivalue token, I needed to wrap my values in quotation marks.  Depending on your data, you may be able to do it the easier way of using a JavaScript split function.  Or you might not even have a multivalue input token.

Ok so multi-valued inputs are turned into a comma delimited string by the system, there is no way to receive an array that we can cycle through the raw values. This means we must use some character to wrap the contents of each value and make sure this character is never used in the values.

That is more troublesome then I thought. I was expecting to receive an array I could cycle through the raw values and work with any values that might be passed to the rule.