update multiplexability handling to use getMultiplicity method

Author: Rn86222

src/store/componentEvaluator.ts

@@ -34,7 +34,7 @@ function createInput(
 					);
 					const bitWidth = multiplexability.isMultiplexable
 						? 1
-						: multiplexability.multiplicity;
+						: multiplexability.getMultiplicity(nodePins);
 					return Array<boolean>(bitWidth).fill(false);
 				});
 		input[key] = values;
@@ -58,7 +58,7 @@ function createOutputShape(
 		if (multiplexability.isMultiplexable) {
 			return 1;
 		}
-		return multiplexability.multiplicity;
+		return multiplexability.getMultiplicity(nodePins);
 	});
 	const outputShape = multiplicity.map((multiplicity) => ({ multiplicity }));
 	return outputShape;

src/store/componentPin.ts

@@ -15,7 +15,7 @@ import {
 	or,
 	xor,
 } from "./intrinsics/definitions";
-import type { CCNodePinId } from "./nodePin";
+import type { CCNodePin, CCNodePinId } from "./nodePin";
 
 export type CCComponentPin = {
 	readonly id: CCComponentPinId;
@@ -47,7 +47,11 @@ export type CCPinImplementation = CCNodePinId | null;
 
 export type CCPinMultiplexability =
 	| { isMultiplexable: true }
-	| { isMultiplexable: false; multiplicity: number };
+	| {
+			isMultiplexable: false;
+			getMultiplicity: (nodePins: CCNodePin[]) => number;
+	  };
+// | { isMultiplexable: false; multiplicity: number };
 
 export type CCComponentPinMultiplexability =
 	| CCPinMultiplexability
@@ -264,16 +268,52 @@ export class CCComponentPinStore extends EventEmitter<CCComponentPinStoreEvents>
 				return "undecidable";
 			}
 			case nullthrows(aggregate.outputPin.id): {
-				return "undecidable";
+				const getMultiplicity = (nodePins: CCNodePin[]): number => {
+					const multiplicity = nodePins
+						.filter((pin) => {
+							const componentPin = this.#store.componentPins.get(
+								pin.componentPinId,
+							);
+							invariant(componentPin);
+							return componentPin.type === "input";
+						})
+						.reduce((acc, pin) => {
+							invariant(pin.userSpecifiedBitWidth);
+							return acc + pin.userSpecifiedBitWidth;
+						}, 0);
+					return multiplicity;
+				};
+				return {
+					isMultiplexable: false,
+					getMultiplicity,
+				};
 			}
 			case nullthrows(decompose.outputPin.id): {
 				return "undecidable";
 			}
 			case nullthrows(decompose.inputPin.In.id): {
-				return "undecidable";
+				const getMultiplicity = (nodePins: CCNodePin[]): number => {
+					const multiplicity = nodePins
+						.filter((pin) => {
+							const componentPin = this.#store.componentPins.get(
+								pin.componentPinId,
+							);
+							invariant(componentPin);
+							return componentPin.type === "output";
+						})
+						.reduce((acc, pin) => {
+							invariant(pin.userSpecifiedBitWidth);
+							return acc + pin.userSpecifiedBitWidth;
+						}, 0);
+					return multiplicity;
+				};
+				return {
+					isMultiplexable: false,
+					getMultiplicity,
+				};
 			}
 			case nullthrows(broadcast.inputPin.In.id): {
-				return { isMultiplexable: false, multiplicity: 1 };
+				return { isMultiplexable: false, getMultiplicity: () => 1 };
 			}
 			case nullthrows(broadcast.outputPin.id): {
 				return "undecidable";

src/store/nodePin.ts

@@ -194,7 +194,10 @@ export class CCNodePinStore extends EventEmitter<CCNodePinStoreEvents> {
 					userSpecifiedBitWidth,
 					"Multiplexability of undecidable pin must be contained in multiplexabilityEnv",
 				);
-				return { isMultiplexable: false, multiplicity: userSpecifiedBitWidth };
+				return {
+					isMultiplexable: false,
+					getMultiplicity: () => userSpecifiedBitWidth,
+				};
 			}
 			if (!givenPinMultiplexability.isMultiplexable) {
 				return givenPinMultiplexability;