diff --git a/src/webapp/components/uploader/js/UploaderCompatibility-Infusion1.2.js b/src/webapp/components/uploader/js/UploaderCompatibility-Infusion1.2.js
index 29aa817898..8bb216d11c 100644
--- a/src/webapp/components/uploader/js/UploaderCompatibility-Infusion1.2.js
+++ b/src/webapp/components/uploader/js/UploaderCompatibility-Infusion1.2.js
@@ -31,7 +31,7 @@ var fluid_1_5 = fluid_1_5 || {};
 
     fluid.compat.fluid_1_2.uploader.optionsRules = {
         "components": {
-            expander: [
+            transform: [
                 {
                     type: "fluid.transforms.value",
                     inputPath: "components",
@@ -44,7 +44,7 @@ var fluid_1_5 = fluid_1_5 || {};
                         "strategy": {
                             "options": {
                                 "flashMovieSettings": {
-                                    expander: {
+                                    transform: {
                                         type: "fluid.transforms.value",
                                         value: {
                                             "flashURL": "uploadManager.options.flashURL",
@@ -67,7 +67,7 @@ var fluid_1_5 = fluid_1_5 || {};
             ]
         },
         "queueSettings": {
-            expander: {
+            transform: {
                 type: "fluid.transforms.firstValue",
                 values: ["queueSettings", "uploadManager.options"]
             }
diff --git a/src/webapp/components/uploader/js/UploaderCompatibility-Infusion1.3.js b/src/webapp/components/uploader/js/UploaderCompatibility-Infusion1.3.js
index 67e88f098c..eb0c86d03f 100644
--- a/src/webapp/components/uploader/js/UploaderCompatibility-Infusion1.3.js
+++ b/src/webapp/components/uploader/js/UploaderCompatibility-Infusion1.3.js
@@ -67,7 +67,7 @@ var fluid_1_5 = fluid_1_5 || {};
         "mergePolicy": "mergePolicy",
         
         "queueSettings.fileTypes": {
-            expander: {
+            transform: {
                 type: "fluid.compat.fluid_1_3.uploader.fileTypeTransformer", 
                 inputPath: "queueSettings.fileTypes"
             }
diff --git a/src/webapp/framework/core/js/ModelTransformation.js b/src/webapp/framework/core/js/ModelTransformation.js
index b5339d39dc..15bc5a3219 100644
--- a/src/webapp/framework/core/js/ModelTransformation.js
+++ b/src/webapp/framework/core/js/ModelTransformation.js
@@ -62,7 +62,7 @@ var fluid = fluid || fluid_1_5;
     // unsupported, NON-API function
     fluid.model.transform.pathToRule = function (inputPath) {
         return {
-            expander: {
+            transform: {
                 type: "fluid.transforms.value",
                 inputPath: inputPath
             }
@@ -72,7 +72,7 @@ var fluid = fluid || fluid_1_5;
     // unsupported, NON-API function    
     fluid.model.transform.valueToRule = function (value) {
         return {
-            expander: {
+            transform: {
                 type: "fluid.transforms.literalValue",
                 value: value
             }
@@ -86,46 +86,46 @@ var fluid = fluid || fluid_1_5;
         return !prefix ? suffix : (!suffix ? prefix : prefix + "." + suffix);
     };
 
-    fluid.model.transform.accumulateInputPath = function (inputPath, expander, paths) {
+    fluid.model.transform.accumulateInputPath = function (inputPath, transform, paths) {
         if (inputPath !== undefined) {
-            paths.push(fluid.model.composePaths(expander.inputPrefix, inputPath));
+            paths.push(fluid.model.composePaths(transform.inputPrefix, inputPath));
         }
     };
 
-    fluid.model.transform.accumulateStandardInputPath = function (input, expandSpec, expander, paths) {
-        fluid.model.transform.getValue(undefined, expandSpec[input], expander);    
-        fluid.model.transform.accumulateInputPath(expandSpec[input + "Path"], expander, paths);
+    fluid.model.transform.accumulateStandardInputPath = function (input, transformSpec, transform, paths) {
+        fluid.model.transform.getValue(undefined, transformSpec[input], transform);    
+        fluid.model.transform.accumulateInputPath(transformSpec[input + "Path"], transform, paths);
     };
 
-    fluid.model.transform.accumulateMultiInputPaths = function (inputVariables, expandSpec, expander, paths) {
+    fluid.model.transform.accumulateMultiInputPaths = function (inputVariables, transformSpec, transform, paths) {
         fluid.each(inputVariables, function (v, k) {
-            fluid.model.transform.accumulateStandardInputPath(k, expandSpec, expander, paths);
+            fluid.model.transform.accumulateStandardInputPath(k, transformSpec, transform, paths);
         });
     };
 
-    fluid.model.transform.getValue = function (inputPath, value, expander) {
+    fluid.model.transform.getValue = function (inputPath, value, transform) {
         var togo;
         if (inputPath !== undefined) { // NB: We may one day want to reverse the crazy jQuery-like convention that "no path means root path"
-            togo = fluid.get(expander.source, fluid.model.composePaths(expander.inputPrefix, inputPath), expander.resolverGetConfig);
+            togo = fluid.get(transform.source, fluid.model.composePaths(transform.inputPrefix, inputPath), transform.resolverGetConfig);
         }
         if (togo === undefined) {
-            togo = fluid.isPrimitive(value) ? value : expander.expand(value);
+            togo = fluid.isPrimitive(value) ? value : transform.expand(value);
         }
         return togo;
     };
     
     // distinguished value which indicates that a transformation rule supplied a 
     // non-default output path, and so the user should be prevented from making use of it
-    // in a compound expander definition
+    // in a compound transform definition
     fluid.model.transform.NONDEFAULT_OUTPUT_PATH_RETURN = {};
     
-    fluid.model.transform.setValue = function (userOutputPath, value, expander, merge) {
+    fluid.model.transform.setValue = function (userOutputPath, value, transform, merge) {
         // avoid crosslinking to input object - this might be controlled by a "nocopy" option in future
         var toset = fluid.copy(value); 
-        var outputPath = fluid.model.composePaths(expander.outputPrefix, userOutputPath);
+        var outputPath = fluid.model.composePaths(transform.outputPrefix, userOutputPath);
         // TODO: custom resolver config here to create non-hash output model structure
         if (toset !== undefined) {
-            expander.applier.requestChange(outputPath, toset, merge ? "MERGE" : undefined);
+            transform.applier.requestChange(outputPath, toset, merge ? "MERGE" : undefined);
         }
         return userOutputPath ? fluid.model.transform.NONDEFAULT_OUTPUT_PATH_RETURN : toset;
     };
@@ -135,8 +135,8 @@ var fluid = fluid || fluid_1_5;
      * or expanding otherwise. <def> defines the default value if unableto resolve the key. If no
      * default value is given undefined is returned
      */
-    fluid.model.transform.resolveParam = function (expandSpec, expander, key, def) {
-        var val = fluid.model.transform.getValue(expandSpec[key + "Path"], expandSpec[key], expander);
+    fluid.model.transform.resolveParam = function (transformSpec, transform, key, def) {
+        var val = fluid.model.transform.getValue(transformSpec[key + "Path"], transformSpec[key], transform);
         return (val !== undefined) ? val : def;
     };
 
@@ -189,20 +189,20 @@ var fluid = fluid || fluid_1_5;
     };
 
         
-    // TODO: prefixApplier is an expander which is currently unused and untested
-    fluid.model.transform.prefixApplier = function (expandSpec, expander) {
-        if (expandSpec.inputPrefix) {
-            expander.inputPrefixOp.push(expandSpec.inputPrefix);
+    // TODO: prefixApplier is a transform which is currently unused and untested
+    fluid.model.transform.prefixApplier = function (transformSpec, transform) {
+        if (transformSpec.inputPrefix) {
+            transform.inputPrefixOp.push(transformSpec.inputPrefix);
         }
-        if (expandSpec.outputPrefix) {
-            expander.outputPrefixOp.push(expandSpec.outputPrefix);
+        if (transformSpec.outputPrefix) {
+            transform.outputPrefixOp.push(transformSpec.outputPrefix);
         }
-        expander.expand(expandSpec.value);
-        if (expandSpec.inputPrefix) {
-            expander.inputPrefixOp.pop();
+        transform.expand(transformSpec.value);
+        if (transformSpec.inputPrefix) {
+            transform.inputPrefixOp.pop();
         }
-        if (expandSpec.outputPrefix) {
-            expander.outputPrefixOp.pop();
+        if (transformSpec.outputPrefix) {
+            transform.outputPrefixOp.pop();
         }
     };
     
@@ -211,85 +211,85 @@ var fluid = fluid || fluid_1_5;
     });
     
     // unsupported, NON-API function
-    fluid.model.makePathStack = function (expander, prefixName) {
-        var stack = expander[prefixName + "Stack"] = [];
-        expander[prefixName] = "";
+    fluid.model.makePathStack = function (transform, prefixName) {
+        var stack = transform[prefixName + "Stack"] = [];
+        transform[prefixName] = "";
         return {
             push: function (prefix) {
-                var newPath = fluid.model.composePaths(expander[prefixName], prefix);
-                stack.push(expander[prefixName]);
-                expander[prefixName] = newPath;
+                var newPath = fluid.model.composePaths(transform[prefixName], prefix);
+                stack.push(transform[prefixName]);
+                transform[prefixName] = newPath;
             },
             pop: function () {
-                expander[prefixName] = stack.pop();
+                transform[prefixName] = stack.pop();
             }
         };
     };
     
     // unsupported, NON-API function
-    fluid.model.transform.expandExpander = function (expandSpec, expander) {
-        var typeName = expandSpec.type;
+    fluid.model.transform.expandTransform = function (transformSpec, transform) {
+        var typeName = transformSpec.type;
         if (!typeName) {
-            fluid.fail("Transformation record is missing a type name: ", expandSpec);
+            fluid.fail("Transformation record is missing a type name: ", transformSpec);
         }
         if (typeName.indexOf(".") === -1) {
             typeName = "fluid.transforms." + typeName;
         }
-        var expanderFn = fluid.getGlobalValue(typeName);
+        var transformFn = fluid.getGlobalValue(typeName);
         var expdef = fluid.defaults(typeName);
-        if (typeof(expanderFn) !== "function") {
+        if (typeof(transformFn) !== "function") {
             fluid.fail("Transformation record specifies transformation function with name " + 
-                expandSpec.type + " which is not a function - ", expanderFn);
+                transformSpec.type + " which is not a function - ", transformFn);
         }
         if (!fluid.hasGrade(expdef, "fluid.transformFunction")) {
             // If no suitable grade is set up, assume that it is intended to be used as a standardTransformFunction
             expdef = fluid.defaults("fluid.standardTransformFunction");
         }
-        var expanderArgs = [expandSpec, expander];
+        var transformArgs = [transformSpec, transform];
         if (fluid.hasGrade(expdef, "fluid.standardInputTransformFunction")) {
-            if (expandSpec.input !== undefined) { 
-                expandSpec.value = expandSpec.input; // alias input and value
+            if (transformSpec.input !== undefined) { 
+                transformSpec.value = transformSpec.input; // alias input and value
             }
-            var expanded = fluid.model.transform.getValue(expandSpec.inputPath, expandSpec.value, expander);
-            expanderArgs.unshift(expanded);
+            var expanded = fluid.model.transform.getValue(transformSpec.inputPath, transformSpec.value, transform);
+            transformArgs.unshift(expanded);
         } else if (fluid.hasGrade(expdef, "fluid.multiInputTransformFunction")) {
             var inputs = {};
             fluid.each(expdef.inputVariables, function (v, k) {
-                var input = fluid.model.transform.getValue(expandSpec[k + "Path"], expandSpec[k], expander);
+                var input = fluid.model.transform.getValue(transformSpec[k + "Path"], transformSpec[k], transform);
                 inputs[k] = (input !== undefined) ? input : v; // if no match, assign default
             });
-            expanderArgs.unshift(inputs);
+            transformArgs.unshift(inputs);
         }
-        var transformed = expanderFn.apply(null, expanderArgs);
+        var transformed = transformFn.apply(null, transformArgs);
         if (fluid.hasGrade(expdef, "fluid.standardOutputTransformFunction")) {
-            transformed = fluid.model.transform.setValue(expandSpec.outputPath, transformed, expander, expandSpec.merge);
+            transformed = fluid.model.transform.setValue(transformSpec.outputPath, transformed, transform, transformSpec.merge);
         }
         return transformed;
     };
     
     // unsupported, NON-API function    
-    fluid.model.transform.expandWildcards = function (expander, source) {
+    fluid.model.transform.expandWildcards = function (transform, source) {
         fluid.each(source, function (value, key) {
-            var q = expander.queuedExpanders;
-            expander.pathOp.push(fluid.pathUtil.escapeSegment(key.toString()));
+            var q = transform.queuedTransforms;
+            transform.pathOp.push(fluid.pathUtil.escapeSegment(key.toString()));
             for (var i = 0; i < q.length; ++i) {
-                if (fluid.pathUtil.matchPath(q[i].matchPath, expander.path, true)) {
-                    var esCopy = fluid.copy(q[i].expandSpec);
+                if (fluid.pathUtil.matchPath(q[i].matchPath, transform.path, true)) {
+                    var esCopy = fluid.copy(q[i].transformSpec);
                     if (esCopy.inputPath === undefined || fluid.model.transform.hasWildcard(esCopy.inputPath)) {
                         esCopy.inputPath = "";
                     }
                     // TODO: allow some kind of interpolation for output path
-                    expander.inputPrefixOp.push(expander.path);
-                    expander.outputPrefixOp.push(expander.path);
-                    fluid.model.transform.expandExpander(esCopy, expander);
-                    expander.outputPrefixOp.pop();
-                    expander.inputPrefixOp.pop();
+                    transform.inputPrefixOp.push(transform.path);
+                    transform.outputPrefixOp.push(transform.path);
+                    fluid.model.transform.expandTransform(esCopy, transform);
+                    transform.outputPrefixOp.pop();
+                    transform.inputPrefixOp.pop();
                 }
             }
             if (!fluid.isPrimitive(value)) {
-                fluid.model.transform.expandWildcards(expander, value);
+                fluid.model.transform.expandWildcards(transform, value);
             }
-            expander.pathOp.pop();
+            transform.pathOp.pop();
         });
     };
     
@@ -299,18 +299,18 @@ var fluid = fluid || fluid_1_5;
     };
     
     // unsupported, NON-API function
-    fluid.model.transform.maybePushWildcard = function (expandSpec, expander) {
+    fluid.model.transform.maybePushWildcard = function (transformSpec, transform) {
         var hw = fluid.model.transform.hasWildcard;
         var matchPath;
-        if (hw(expandSpec.inputPath)) {
-            matchPath = fluid.model.composePaths(expander.inputPrefix, expandSpec.inputPath);
+        if (hw(transformSpec.inputPath)) {
+            matchPath = fluid.model.composePaths(transform.inputPrefix, transformSpec.inputPath);
         }
-        else if (hw(expander.outputPrefix) || hw(expandSpec.outputPath)) {
-            matchPath = fluid.model.composePaths(expander.outputPrefix, expandSpec.outputPath);
+        else if (hw(transform.outputPrefix) || hw(transformSpec.outputPath)) {
+            matchPath = fluid.model.composePaths(transform.outputPrefix, transformSpec.outputPath);
         }
                          
         if (matchPath) {
-            expander.queuedExpanders.push({expandSpec: expandSpec, outputPrefix: expander.outputPrefix, inputPrefix: expander.inputPrefix, matchPath: matchPath});
+            transform.queuedTransforms.push({transformSpec: transformSpec, outputPrefix: transform.outputPrefix, inputPrefix: transform.inputPrefix, matchPath: matchPath});
             return true;
         }
         return false;
@@ -323,103 +323,103 @@ var fluid = fluid || fluid_1_5;
     
     // Three handler functions operating the (currently) three different processing modes
     // unsupported, NON-API function
-    fluid.model.transform.handleExpandExpander = function (expandSpec, expander) {
-        if (fluid.model.transform.maybePushWildcard(expandSpec, expander)) {
+    fluid.model.transform.handleExpandTransform = function (transformSpec, transform) {
+        if (fluid.model.transform.maybePushWildcard(transformSpec, transform)) {
             return;
         }
         else {
-            return fluid.model.transform.expandExpander(expandSpec, expander);
+            return fluid.model.transform.expandTransform(transformSpec, transform);
         }
     };
     // unsupported, NON-API function
-    fluid.model.transform.handleInvertExpander = function (expandSpec, expander, expdef) {
+    fluid.model.transform.handleInvertTransform = function (transformSpec, transform, expdef) {
         var invertor = expdef.invertConfiguration;
         if (invertor) {
-            var inverted = fluid.invokeGlobalFunction(invertor, [expandSpec, expander]);
-            expander.inverted.push(inverted);
+            var inverted = fluid.invokeGlobalFunction(invertor, [transformSpec, transform]);
+            transform.inverted.push(inverted);
         }
     };
     
     // unsupported, NON-API function
-    fluid.model.transform.handlerCollectExpander = function (expandSpec, expander, expdef) {
+    fluid.model.transform.handlerCollectTransform = function (transformSpec, transform, expdef) {
         var standardInput = fluid.hasGrade(expdef, "fluid.standardInputTransformFunction");
         var multiInput = fluid.hasGrade(expdef, "fluid.multiInputTransformFunction");
 
         if (standardInput) {
-            fluid.model.transform.accumulateStandardInputPath("input", expandSpec, expander, expander.inputPaths);
+            fluid.model.transform.accumulateStandardInputPath("input", transformSpec, transform, transform.inputPaths);
         } else if (multiInput) {
-            fluid.model.transform.accumulateMultiInputPaths(expdef.inputVariables, expandSpec, expander, expander.inputPaths);
+            fluid.model.transform.accumulateMultiInputPaths(expdef.inputVariables, transformSpec, transform, transform.inputPaths);
         } else {
             var collector = expdef.collectInputPaths;
             if (collector) {
-                var collected = fluid.makeArray(fluid.invokeGlobalFunction(collector, [expandSpec, expander]));
-                expander.inputPaths = expander.inputPaths.concat(collected);
+                var collected = fluid.makeArray(fluid.invokeGlobalFunction(collector, [transformSpec, transform]));
+                transform.inputPaths = transform.inputPaths.concat(collected);
             }
         }
     };
     
     // unsupported, NON-API function
-    fluid.model.transform.expandValue = function (rule, expander) {
+    fluid.model.transform.expandValue = function (rule, transform) {
         if (typeof(rule) === "string") {
             rule = fluid.model.transform.pathToRule(rule);
         }
         // special dispensation to allow "value" at top level
         // TODO: Proper escaping rules
-        else if (rule.value && expander.outputPrefix !== "") {
+        else if (rule.value && transform.outputPrefix !== "") {
             rule = fluid.model.transform.valueToRule(rule.value);
         }
         var togo;
-        if (rule.expander) {
-            var expanders = fluid.makeArray(rule.expander);
-            for (var i = 0; i < expanders.length; ++i) {
-                var expandSpec = expanders[i];
-                var expdef = fluid.defaults(expandSpec.type);
-                var returned = expander.expanderHandler(expandSpec, expander, expdef);
+        if (rule.transform) {
+            var transforms = fluid.makeArray(rule.transform);
+            for (var i = 0; i < transforms.length; ++i) {
+                var transformSpec = transforms[i];
+                var expdef = fluid.defaults(transformSpec.type);
+                var returned = transform.transformHandler(transformSpec, transform, expdef);
                 if (returned !== undefined) {
                     togo = returned;
                 }
             }
         }
         fluid.each(rule, function (value, key) {
-            if (key !== "expander") {
-                expander.outputPrefixOp.push(key);
-                // TODO: Note that result by convention is discarded otherwise value expanders will cascade in a faulty way 
-                var result = expander.expand(value, expander); 
-                expander.outputPrefixOp.pop();
+            if (key !== "transform") {
+                transform.outputPrefixOp.push(key);
+                // TODO: Note that result by convention is discarded otherwise value transforms will cascade in a faulty way 
+                var result = transform.expand(value, transform); 
+                transform.outputPrefixOp.pop();
             }
         });
         return togo;
     };
     
     // unsupported, NON-API function
-    fluid.model.transform.makeExpander = function (expander, handleFn, expandFn) {
-        expandFn = expandFn || fluid.model.transform.expandValue;
-        expander.expand = function (rules) {
-            return expandFn(rules, expander);
+    fluid.model.transform.makeTransform = function (transform, handleFn, transformFn) {
+        transformFn = transformFn || fluid.model.transform.expandValue;
+        transform.expand = function (rules) {
+            return transformFn(rules, transform);
         };
-        expander.outputPrefixOp = fluid.model.makePathStack(expander, "outputPrefix");
-        expander.inputPrefixOp = fluid.model.makePathStack(expander, "inputPrefix");
-        expander.expanderHandler = handleFn;
+        transform.outputPrefixOp = fluid.model.makePathStack(transform, "outputPrefix");
+        transform.inputPrefixOp = fluid.model.makePathStack(transform, "inputPrefix");
+        transform.transformHandler = handleFn;
     };
     
     fluid.model.transform.invertConfiguration = function (rules) {
-        var expander = {
+        var transform = {
             inverted: []
         };
-        fluid.model.transform.makeExpander(expander, fluid.model.transform.handleInvertExpander);
-        expander.expand(rules);
+        fluid.model.transform.makeTransform(transform, fluid.model.transform.handleInvertTransform);
+        transform.expand(rules);
         return {
-            expander: expander.inverted
+            transform: transform.inverted
         };
     };
     
     fluid.model.transform.collectInputPaths = function (rules) {
-        var expander = {
+        var transform = {
             inputPaths: []
         };
-        fluid.model.transform.makeExpander(expander, fluid.model.transform.handlerCollectExpander);
-        expander.expand(rules);
-        return expander.inputPaths;        
+        fluid.model.transform.makeTransform(transform, fluid.model.transform.handlerCollectTransform);
+        transform.expand(rules);
+        return transform.inputPaths;        
     };
     
     // unsupported, NON-API function
@@ -498,8 +498,8 @@ var fluid = fluid || fluid_1_5;
      * Rules objects take the form of:
      *   {
      *       "target.path": "value.el.path" || {
-     *          expander: {
-     *              type: "expander.function.path",
+     *          transform: {
+     *              type: "transform.function.path",
      *               ...
      *           }
      *       }
@@ -523,31 +523,31 @@ var fluid = fluid || fluid_1_5;
         setConfig.strategies = [fluid.model.defaultFetchStrategy, schemaStrategy ? fluid.model.transform.schemaToCreatorStrategy(schemaStrategy)
                 : fluid.model.defaultCreatorStrategy];
 
-        var expander = {
+        var transform = {
             source: source,
             target: schemaStrategy ? fluid.model.transform.defaultSchemaValue(schemaStrategy(null, "", 0, [""])) : {},
             resolverGetConfig: getConfig,
             queuedChanges: [],
-            queuedExpanders: [] // TODO: This is used only by wildcard applier - explain its operation
+            queuedTransforms: [] // TODO: This is used only by wildcard applier - explain its operation
         };
-        fluid.model.transform.makeExpander(expander, fluid.model.transform.handleExpandExpander);
-        expander.applier = {
+        fluid.model.transform.makeTransform(transform, fluid.model.transform.handleExpandTransform);
+        transform.applier = {
             fireChangeRequest: function (changeRequest) {
-                changeRequest.sequence = expander.queuedChanges.length;
-                expander.queuedChanges.push(changeRequest);
+                changeRequest.sequence = transform.queuedChanges.length;
+                transform.queuedChanges.push(changeRequest);
             }
         };
-        fluid.bindRequestChange(expander.applier);
-        expander.finalApplier = fluid.makeChangeApplier(expander.target, {resolverSetConfig: setConfig});
+        fluid.bindRequestChange(transform.applier);
+        transform.finalApplier = fluid.makeChangeApplier(transform.target, {resolverSetConfig: setConfig});
         
-        expander.expand(rules);
-        if (expander.queuedExpanders.length > 0) {
-            expander.typeStack = [];
-            expander.pathOp = fluid.model.makePathStack(expander, "path");
-            fluid.model.transform.expandWildcards(expander, source);
+        transform.expand(rules);
+        if (transform.queuedTransforms.length > 0) {
+            transform.typeStack = [];
+            transform.pathOp = fluid.model.makePathStack(transform, "path");
+            fluid.model.transform.expandWildcards(transform, source);
         }
-        fluid.model.fireSortedChanges(expander.queuedChanges, expander.finalApplier);
-        return expander.target;    
+        fluid.model.fireSortedChanges(transform.queuedChanges, transform.finalApplier);
+        return transform.target;    
     };
     
     $.extend(fluid.model.transformWithRules, fluid.model.transform);
diff --git a/src/webapp/framework/core/js/ModelTransformationTransforms.js b/src/webapp/framework/core/js/ModelTransformationTransforms.js
index 80eb88032b..6c643473bc 100644
--- a/src/webapp/framework/core/js/ModelTransformationTransforms.js
+++ b/src/webapp/framework/core/js/ModelTransformationTransforms.js
@@ -37,12 +37,12 @@ var fluid = fluid || fluid_1_5;
 
     fluid.transforms.value = fluid.identity;
     
-    fluid.transforms.value.invert = function (expandSpec, expander) {
-        var togo = fluid.copy(expandSpec);
+    fluid.transforms.value.invert = function (transformSpec, transform) {
+        var togo = fluid.copy(transformSpec);
         // TODO: this will not behave correctly in the face of compound "value" which contains
-        // further expanders
-        togo.inputPath = fluid.model.composePaths(expander.outputPrefix, expandSpec.outputPath);
-        togo.outputPath = fluid.model.composePaths(expander.inputPrefix, expandSpec.inputPath);
+        // further transforms
+        togo.inputPath = fluid.model.composePaths(transform.outputPrefix, transformSpec.outputPath);
+        togo.outputPath = fluid.model.composePaths(transform.inputPrefix, transformSpec.inputPath);
         return togo;
     };
 
@@ -51,8 +51,8 @@ var fluid = fluid || fluid_1_5;
         gradeNames: "fluid.standardOutputTransformFunction"
     });
 
-    fluid.transforms.literalValue = function (expanderSpec) {
-        return expanderSpec.value;  
+    fluid.transforms.literalValue = function (transformSpec) {
+        return transformSpec.value;  
     };
     
 
@@ -85,9 +85,9 @@ var fluid = fluid || fluid_1_5;
         gradeNames: "fluid.transformFunction"
     });
 
-    fluid.transforms["delete"] = function (expandSpec, expander) {
-        var outputPath = fluid.model.composePaths(expander.outputPrefix, expandSpec.outputPath);
-        expander.applier.requestChange(outputPath, null, "DELETE");
+    fluid.transforms["delete"] = function (transformSpec, transform) {
+        var outputPath = fluid.model.composePaths(transform.outputPrefix, transformSpec.outputPath);
+        transform.applier.requestChange(outputPath, null, "DELETE");
     };
 
     
@@ -95,14 +95,14 @@ var fluid = fluid || fluid_1_5;
         gradeNames: "fluid.transformFunction"
     });
     
-    fluid.transforms.firstValue = function (expandSpec, expander) {
-        if (!expandSpec.values || !expandSpec.values.length) {
-            fluid.fail("firstValue transformer requires an array of values at path named \"values\", supplied", expandSpec);
+    fluid.transforms.firstValue = function (transformSpec, transform) {
+        if (!transformSpec.values || !transformSpec.values.length) {
+            fluid.fail("firstValue transformer requires an array of values at path named \"values\", supplied", transformSpec);
         }
-        for (var i = 0; i < expandSpec.values.length; i++) {
-            var value = expandSpec.values[i];
-            // TODO: problem here - all of these expanders will have their side-effects (setValue) even if only one is chosen 
-            var expanded = expander.expand(value);
+        for (var i = 0; i < transformSpec.values.length; i++) {
+            var value = transformSpec.values[i];
+            // TODO: problem here - all of these transforms will have their side-effects (setValue) even if only one is chosen 
+            var expanded = transform.expand(value);
             if (expanded !== undefined) {
                 return expanded;
             }
@@ -120,18 +120,18 @@ var fluid = fluid || fluid_1_5;
     });
 
     /* simple linear transformation */
-    fluid.transforms.linearScale = function (inputs, expandSpec, expander) {        
+    fluid.transforms.linearScale = function (inputs, transformSpec, transform) {        
         if (typeof(inputs.value) !== "number" || typeof(inputs.factor) !== "number" || typeof(inputs.offset) !== "number") {
             return undefined;
         }
         return inputs.value * inputs.factor + inputs.offset;
     };
 
-    fluid.transforms.linearScale.invert = function  (expandSpec, expander) {
-        var togo = fluid.copy(expandSpec);
+    fluid.transforms.linearScale.invert = function  (transformSpec, transform) {
+        var togo = fluid.copy(transformSpec);
         togo.type = "fluid.transforms.inverseLinearScale";
-        togo.valuePath = fluid.model.composePaths(expander.outputPrefix, expandSpec.outputPath);
-        togo.outputPath = fluid.model.composePaths(expander.inputPrefix, expandSpec.valuePath);
+        togo.valuePath = fluid.model.composePaths(transform.outputPrefix, transformSpec.outputPath);
+        togo.outputPath = fluid.model.composePaths(transform.inputPrefix, transformSpec.valuePath);
         return togo;
     };
 
@@ -145,7 +145,7 @@ var fluid = fluid || fluid_1_5;
     });
 
     /* inverse linear transformation y = (x-b)/a   where a=factor, b=offset and x=value */
-    fluid.transforms.inverseLinearScale = function (inputs, expandSpec, expander) {        
+    fluid.transforms.inverseLinearScale = function (inputs, transformSpec, transform) {        
         if (typeof(inputs.value) !== "number" || typeof(inputs.factor) !== "number" || typeof(inputs.offset) !== "number") {
             return undefined;
         }
@@ -176,8 +176,8 @@ var fluid = fluid || fluid_1_5;
         "||": function (a, b) { return a || b; }
     };
 
-    fluid.transforms.binaryOp = function (inputs, expandSpec, expander) {
-        var operator = fluid.model.transform.getValue(undefined, expandSpec.operator, expander);
+    fluid.transforms.binaryOp = function (inputs, transformSpec, transform) {
+        var operator = fluid.model.transform.getValue(undefined, transformSpec.operator, transform);
 
         var fun = fluid.transforms.binaryLookup[operator];
         return (fun === undefined || inputs.left === null || inputs.right === null) ? undefined : fun(inputs.left, inputs.right);
@@ -193,7 +193,7 @@ var fluid = fluid || fluid_1_5;
         }
     });
     
-    fluid.transforms.condition = function (inputs, expandSpec, expander) {
+    fluid.transforms.condition = function (inputs, transformSpec, transform) {
         if (inputs.condition === null) {
             return undefined;
         }
@@ -209,10 +209,10 @@ var fluid = fluid || fluid_1_5;
     });
 
     // unsupported, NON-API function    
-    fluid.model.transform.matchValueMapperFull = function (outerValue, expandSpec, expander) {
-        var o = expandSpec.options;
+    fluid.model.transform.matchValueMapperFull = function (outerValue, transformSpec, transform) {
+        var o = transformSpec.options;
         if (o.length === 0) {
-            fluid.fail("valueMapper supplied empty list of options: ", expandSpec);
+            fluid.fail("valueMapper supplied empty list of options: ", transformSpec);
         }
         if (o.length === 1) {
             return 0;
@@ -220,7 +220,7 @@ var fluid = fluid || fluid_1_5;
         var matchPower = []; 
         for (var i = 0; i < o.length; ++i) {
             var option = o[i];
-            var value = fluid.firstDefined(fluid.model.transform.getValue(option.inputPath, undefined, expander),
+            var value = fluid.firstDefined(fluid.model.transform.getValue(option.inputPath, undefined, transform),
                 outerValue);
             var matchCount = fluid.model.transform.matchValue(option.undefinedInputValue ? undefined : option.inputValue, value);
             matchPower[i] = {index: i, matchCount: matchCount};
@@ -229,32 +229,32 @@ var fluid = fluid || fluid_1_5;
         return matchPower[0].matchCount === matchPower[1].matchCount ? -1 : matchPower[0].index; 
     };
 
-    fluid.transforms.valueMapper = function (expandSpec, expander) {
-        if (!expandSpec.options) {
-            fluid.fail("demultiplexValue requires a list or hash of options at path named \"options\", supplied ", expandSpec);
+    fluid.transforms.valueMapper = function (transformSpec, transform) {
+        if (!transformSpec.options) {
+            fluid.fail("demultiplexValue requires a list or hash of options at path named \"options\", supplied ", transformSpec);
         }
-        var value = fluid.model.transform.getValue(expandSpec.inputPath, undefined, expander);
-        var deref = fluid.isArrayable(expandSpec.options) ? // long form with list of records    
+        var value = fluid.model.transform.getValue(transformSpec.inputPath, undefined, transform);
+        var deref = fluid.isArrayable(transformSpec.options) ? // long form with list of records    
             function (testVal) {
-                var index = fluid.model.transform.matchValueMapperFull(testVal, expandSpec, expander);
-                return index === -1 ? null : expandSpec.options[index];
+                var index = fluid.model.transform.matchValueMapperFull(testVal, transformSpec, transform);
+                return index === -1 ? null : transformSpec.options[index];
             } : 
             function (testVal) {
-                return expandSpec.options[testVal];
+                return transformSpec.options[testVal];
             };
       
         var indexed = deref(value);
         if (!indexed) {
             // if no branch matches, try again using this value - WARNING, this seriously
             // threatens invertibility
-            indexed = deref(expandSpec.defaultInputValue);
+            indexed = deref(transformSpec.defaultInputValue);
         }
         if (!indexed) {
             return;
         }
 
-        var outputPath = indexed.outputPath === undefined ? expandSpec.defaultOutputPath : indexed.outputPath;
-        expander.outputPrefixOp.push(outputPath);
+        var outputPath = indexed.outputPath === undefined ? transformSpec.defaultOutputPath : indexed.outputPath;
+        transform.outputPrefixOp.push(outputPath);
         var outputValue;
         if (fluid.isPrimitive(indexed)) {
             outputValue = indexed;
@@ -264,24 +264,24 @@ var fluid = fluid || fluid_1_5;
                 outputValue = undefined;
             } else {
                 // get value from outputValue or outputValuePath. If none is found set the outputValue to be that of defaultOutputValue (or undefined)
-                outputValue = fluid.model.transform.resolveParam(indexed, expander, "outputValue", undefined);
-                outputValue = (outputValue === undefined) ? expandSpec.defaultOutputValue : outputValue;
+                outputValue = fluid.model.transform.resolveParam(indexed, transform, "outputValue", undefined);
+                outputValue = (outputValue === undefined) ? transformSpec.defaultOutputValue : outputValue;
             }
         }
-        var togo = fluid.model.transform.setValue(undefined, outputValue, expander, expandSpec.merge);
-        expander.outputPrefixOp.pop();
+        var togo = fluid.model.transform.setValue(undefined, outputValue, transform, transformSpec.merge);
+        transform.outputPrefixOp.pop();
         return togo; 
     };
     
-    fluid.transforms.valueMapper.invert = function (expandSpec, expander) {
+    fluid.transforms.valueMapper.invert = function (transformSpec, transform) {
         var options = [];
         var togo = {
             type: "fluid.transforms.valueMapper",
             options: options
         };
-        var isArray = fluid.isArrayable(expandSpec.options);
+        var isArray = fluid.isArrayable(transformSpec.options);
         var findCustom = function (name) {
-            return fluid.find(expandSpec.options, function (option) {
+            return fluid.find(transformSpec.options, function (option) {
                 if (option[name]) {
                     return true;
                 }
@@ -290,26 +290,26 @@ var fluid = fluid || fluid_1_5;
         var anyCustomOutput = findCustom("outputPath");
         var anyCustomInput = findCustom("inputPath");
         if (!anyCustomOutput) {
-            togo.inputPath = fluid.model.composePaths(expander.outputPrefix, expandSpec.outputPath);
+            togo.inputPath = fluid.model.composePaths(transform.outputPrefix, transformSpec.outputPath);
         }
         if (!anyCustomInput) {
-            togo.defaultOutputPath = fluid.model.composePaths(expander.inputPrefix, expandSpec.inputPath);
+            togo.defaultOutputPath = fluid.model.composePaths(transform.inputPrefix, transformSpec.inputPath);
         }
         var def = fluid.firstDefined;
-        fluid.each(expandSpec.options, function (option, key) {
+        fluid.each(transformSpec.options, function (option, key) {
             var outOption = {};
-            var origInputValue = def(isArray ? option.inputValue : key, expandSpec.defaultInputValue);
+            var origInputValue = def(isArray ? option.inputValue : key, transformSpec.defaultInputValue);
             if (origInputValue === undefined) {
-                fluid.fail("Failure inverting configuration for valueMapper - inputValue could not be resolved for record " + key + ": ", expandSpec);
+                fluid.fail("Failure inverting configuration for valueMapper - inputValue could not be resolved for record " + key + ": ", transformSpec);
             }
             outOption.outputValue = origInputValue;
-            var origOutputValue = def(option.outputValue, expandSpec.defaultOutputValue);
-            outOption.inputValue = fluid.model.transform.getValue(option.outputValuePath, origOutputValue, expander);
+            var origOutputValue = def(option.outputValue, transformSpec.defaultOutputValue);
+            outOption.inputValue = fluid.model.transform.getValue(option.outputValuePath, origOutputValue, transform);
             if (anyCustomOutput) {
-                outOption.inputPath = fluid.model.composePaths(expander.outputPrefix, def(option.outputPath, expandSpec.outputPath));
+                outOption.inputPath = fluid.model.composePaths(transform.outputPrefix, def(option.outputPath, transformSpec.outputPath));
             }
             if (anyCustomInput) {
-                outOption.outputPath = fluid.model.composePaths(expander.inputPrefix, def(option.inputPath, expandSpec.inputPath));
+                outOption.outputPath = fluid.model.composePaths(transform.inputPrefix, def(option.inputPath, transformSpec.inputPath));
             }
             if (option.outputValuePath) {
                 outOption.inputValuePath = option.outputValuePath;
@@ -319,11 +319,11 @@ var fluid = fluid || fluid_1_5;
         return togo;
     };
     
-    fluid.transforms.valueMapper.collect = function (expandSpec, expander) {
+    fluid.transforms.valueMapper.collect = function (transformSpec, transform) {
         var togo = [];
-        fluid.model.transform.accumulateInputPath(expandSpec.inputPath, expander, togo);
-        fluid.each(expandSpec.options, function (option) {
-            fluid.model.transform.accumulateInputPath(option.inputPath, expander, togo);
+        fluid.model.transform.accumulateInputPath(transformSpec.inputPath, transform, togo);
+        fluid.each(transformSpec.options, function (option) {
+            fluid.model.transform.accumulateInputPath(option.inputPath, transform, togo);
         });
         return togo;
     };
@@ -336,40 +336,40 @@ var fluid = fluid || fluid_1_5;
     });
 
  
-    fluid.transforms.arrayToSetMembership = function (value, expandSpec, expander) {
-        var options = expandSpec.options;
+    fluid.transforms.arrayToSetMembership = function (value, transformSpec, transform) {
+        var options = transformSpec.options;
 
         if (!value || !fluid.isArrayable(value)) {
-            fluid.fail("arrayToSetMembership didn't find array at inputPath nor passed as value.", expandSpec);
+            fluid.fail("arrayToSetMembership didn't find array at inputPath nor passed as value.", transformSpec);
         }
         if (!options) {
             fluid.fail("arrayToSetMembership requires an options block set");
         }
 
-        if (expandSpec.presentValue === undefined) {
-            expandSpec.presentValue = true;
+        if (transformSpec.presentValue === undefined) {
+            transformSpec.presentValue = true;
         }
         
-        if (expandSpec.missingValue === undefined) {
-            expandSpec.missingValue = false;
+        if (transformSpec.missingValue === undefined) {
+            transformSpec.missingValue = false;
         }
 
         fluid.each(options, function (outPath, key) {
             // write to output path given in options the value <presentValue> or <missingValue> depending on whether key is found in user input
-            var outVal = (value.indexOf(key) !== -1) ? expandSpec.presentValue : expandSpec.missingValue;
-            fluid.model.transform.setValue(outPath, outVal, expander);
+            var outVal = (value.indexOf(key) !== -1) ? transformSpec.presentValue : transformSpec.missingValue;
+            fluid.model.transform.setValue(outPath, outVal, transform);
         });
         // TODO: Why does this transform make no return?
     };
 
-    fluid.transforms.arrayToSetMembership.invert = function (expandSpec, expander) {
-        var togo = fluid.copy(expandSpec);
+    fluid.transforms.arrayToSetMembership.invert = function (transformSpec, transform) {
+        var togo = fluid.copy(transformSpec);
         delete togo.inputPath;
         togo.type = "fluid.transforms.setMembershipToArray";
-        togo.outputPath = fluid.model.composePaths(expander.inputPrefix, expandSpec.inputPath);
+        togo.outputPath = fluid.model.composePaths(transform.inputPrefix, transformSpec.inputPath);
         var newOptions = {};
-        fluid.each(expandSpec.options, function (path, oldKey) {
-            var newKey = fluid.model.composePaths(expander.outputPrefix, path);
+        fluid.each(transformSpec.options, function (path, oldKey) {
+            var newKey = fluid.model.composePaths(transform.outputPrefix, path);
             newOptions[newKey] = oldKey;
         });
         togo.options = newOptions;
@@ -380,25 +380,25 @@ var fluid = fluid || fluid_1_5;
         gradeNames: ["fluid.standardOutputTransformFunction"]
     });
 
-    fluid.transforms.setMembershipToArray = function (expandSpec, expander) {
-        var options = expandSpec.options;
+    fluid.transforms.setMembershipToArray = function (transformSpec, transform) {
+        var options = transformSpec.options;
 
         if (!options) {
             fluid.fail("setMembershipToArray requires an options block specified");
         }
 
-        if (expandSpec.presentValue === undefined) {
-            expandSpec.presentValue = true;
+        if (transformSpec.presentValue === undefined) {
+            transformSpec.presentValue = true;
         }
         
-        if (expandSpec.missingValue === undefined) {
-            expandSpec.missingValue = false;
+        if (transformSpec.missingValue === undefined) {
+            transformSpec.missingValue = false;
         }
 
         var outputArr = [];
         fluid.each(options, function (arrVal, inPath) {
-            var val = fluid.model.transform.getValue(inPath, undefined, expander);
-            if (val === expandSpec.presentValue) {
+            var val = fluid.model.transform.getValue(inPath, undefined, transform);
+            if (val === transformSpec.presentValue) {
                 outputArr.push(arrVal);
             }
         });
@@ -409,9 +409,9 @@ var fluid = fluid || fluid_1_5;
     
     /**
      * Transforms the given array to an object.
-     * Uses the expandSpec.options.key values from each object within the array as new keys.
+     * Uses the transformSpec.options.key values from each object within the array as new keys.
      *
-     * For example, with expandSpec.key = "name" and an input object like this:
+     * For example, with transformSpec.key = "name" and an input object like this:
      *
      * {
      *   b: [
@@ -444,16 +444,16 @@ var fluid = fluid || fluid_1_5;
         }
     };
     
-    fluid.model.transform.expandInnerValues = function (inputPath, outputPath, expander, innerValues) {
-        var inputPrefixOp = expander.inputPrefixOp;
-        var outputPrefixOp = expander.outputPrefixOp;
+    fluid.model.transform.expandInnerValues = function (inputPath, outputPath, transform, innerValues) {
+        var inputPrefixOp = transform.inputPrefixOp;
+        var outputPrefixOp = transform.outputPrefixOp;
         var apply = fluid.model.transform.applyPaths;
         
         apply("push", inputPrefixOp, inputPath);
         apply("push", outputPrefixOp, outputPath);
         var expanded = {};
         fluid.each(innerValues, function (innerValue) {
-            var expandedInner = expander.expand(innerValue);
+            var expandedInner = transform.expand(innerValue);
             $.extend(true, expanded, expandedInner);
         });
         apply("pop", outputPrefixOp, outputPath);
@@ -468,15 +468,15 @@ var fluid = fluid || fluid_1_5;
         invertConfiguration: "fluid.transforms.arrayToObject.invert"
     });
 
-    fluid.transforms.arrayToObject = function (arr, expandSpec, expander) {
-        if (expandSpec.key === undefined) {
-            fluid.fail("arrayToObject requires a 'key' option.", expandSpec);
+    fluid.transforms.arrayToObject = function (arr, transformSpec, transform) {
+        if (transformSpec.key === undefined) {
+            fluid.fail("arrayToObject requires a 'key' option.", transformSpec);
         }
         if (!fluid.isArrayable(arr)) {
-            fluid.fail("arrayToObject didn't find array at inputPath.", expandSpec);
+            fluid.fail("arrayToObject didn't find array at inputPath.", transformSpec);
         }
         var newHash = {};
-        var pivot = expandSpec.key;
+        var pivot = transformSpec.key;
 
         fluid.each(arr, function (v, k) {
             // check that we have a pivot entry in the object and it's a valid type:            
@@ -489,21 +489,21 @@ var fluid = fluid || fluid_1_5;
             var content = fluid.copy(v);
             delete content[pivot];
             // fix sub Arrays if needed:
-            if (expandSpec.innerValue) {
-                content = fluid.model.transform.expandInnerValues([expander.inputPrefix, expandSpec.inputPath, k.toString()], 
-                    [newKey], expander, expandSpec.innerValue);
+            if (transformSpec.innerValue) {
+                content = fluid.model.transform.expandInnerValues([transform.inputPrefix, transformSpec.inputPath, k.toString()], 
+                    [newKey], transform, transformSpec.innerValue);
             }
             newHash[newKey] = content;
         });
         return newHash;
     };
 
-    fluid.transforms.arrayToObject.invert = function (expandSpec, expander) {
-        var togo = fluid.copy(expandSpec);
+    fluid.transforms.arrayToObject.invert = function (transformSpec, transform) {
+        var togo = fluid.copy(transformSpec);
         togo.type = "fluid.transforms.objectToArray";
-        togo.inputPath = fluid.model.composePaths(expander.outputPrefix, expandSpec.outputPath);
-        togo.outputPath = fluid.model.composePaths(expander.inputPrefix, expandSpec.inputPath);
-        // invert expanders from innerValue as well:
+        togo.inputPath = fluid.model.composePaths(transform.outputPrefix, transformSpec.outputPath);
+        togo.outputPath = fluid.model.composePaths(transform.inputPrefix, transformSpec.inputPath);
+        // invert transforms from innerValue as well:
         // TODO: The Model Transformations framework should be capable of this, but right now the
         // issue is that we use a "private contract" to operate the "innerValue" slot. We need to
         // spend time thinking of how this should be formalised
@@ -525,20 +525,20 @@ var fluid = fluid || fluid_1_5;
      * Transforms an object into array of objects.
      * This performs the inverse transform of fluid.transforms.arrayToObject.
      */
-    fluid.transforms.objectToArray = function (hash, expandSpec, expander) {
-        if (expandSpec.key === undefined) {
-            fluid.fail("objectToArray requires a 'key' option.", expandSpec);
+    fluid.transforms.objectToArray = function (hash, transformSpec, transform) {
+        if (transformSpec.key === undefined) {
+            fluid.fail("objectToArray requires a 'key' option.", transformSpec);
         }
         
         var newArray = [];
-        var pivot = expandSpec.key;
+        var pivot = transformSpec.key;
 
         fluid.each(hash, function (v, k) {
             var content = {};
             content[pivot] = k;
-            if (expandSpec.innerValue) {
-                v = fluid.model.transform.expandInnerValues([expandSpec.inputPath, k], [expandSpec.outputPath, newArray.length.toString()], 
-                    expander, expandSpec.innerValue);
+            if (transformSpec.innerValue) {
+                v = fluid.model.transform.expandInnerValues([transformSpec.inputPath, k], [transformSpec.outputPath, newArray.length.toString()], 
+                    transform, transformSpec.innerValue);
             }
             $.extend(true, content, v);
             newArray.push(content);
diff --git a/src/webapp/tests/framework-tests/core/js/ModelTransformationTests.js b/src/webapp/tests/framework-tests/core/js/ModelTransformationTests.js
index d51d8c3be5..af9e3fb198 100644
--- a/src/webapp/tests/framework-tests/core/js/ModelTransformationTests.js
+++ b/src/webapp/tests/framework-tests/core/js/ModelTransformationTests.js
@@ -51,20 +51,20 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
 
     jqUnit.module("Model Transformation");
     
-    function testOneExpander(message, model, expander, method, expected, expandWrap) {
+    function testOneTransform(message, model, transform, method, expected, expandWrap) {
         if (expandWrap) {
-            expander = {
+            transform = {
                 value: {
-                    expander: expander
+                    transform: transform
                 }
             };
         }
-        var transformed = fluid.model.transform(model, expander);
+        var transformed = fluid.model.transform(model, transform);
         jqUnit[method].apply(null, [message, expected, (expandWrap ? transformed.value : transformed) ]); 
     }
 
     function testOneInversion (test) {
-        var inverseRules = fluid.model.transform.invertConfiguration(test.expander);
+        var inverseRules = fluid.model.transform.invertConfiguration(test.transform);
         jqUnit.assertDeepEq(test.message + " -- inverted rules", test.invertedRules, inverseRules);
         if (test.fullyInvertable) {
             var transformed = fluid.model.transform(test.expected, inverseRules);
@@ -74,7 +74,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
 
     var testOneStructure = function (tests) {
         fluid.each(tests, function (v) {
-            testOneExpander(v.message, v.model || source, v.expander, v.method, v.expected, v.expandWrap);
+            testOneTransform(v.message, v.model || source, v.transform, v.method, v.expected, v.expandWrap);
             if (v.invertedRules) {
                 testOneInversion(v);
             }
@@ -83,16 +83,16 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     
     var linearScaleTests = [{
         message: "linearScale - no parameters given",
-        expander: {
+        transform: {
             value: {
-                expander: {
+                transform: {
                     type: "fluid.transforms.linearScale",
                     valuePath: "dozen"
                 }
             }
         },
         invertedRules: {
-            expander: [{
+            transform: [{
                 type: "fluid.transforms.inverseLinearScale",
                 outputPath: "dozen",
                 valuePath: "value"
@@ -111,9 +111,9 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         model: {
             dozen: 12
         },
-        expander: {
+        transform: {
             value: {
-                expander: {
+                transform: {
                     type: "fluid.transforms.linearScale",
                     valuePath: "dozen",
                     factor: 0.25
@@ -121,7 +121,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             }
         },
         invertedRules: {
-            expander: [{
+            transform: [{
                 type: "fluid.transforms.inverseLinearScale",
                 outputPath: "dozen",
                 valuePath: "value",
@@ -135,9 +135,9 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         fullyInvertable: true
     }, {
         message: "linearScale - factor parameter and offset",
-        expander: {
+        transform: {
             value: {
-                expander: {
+                transform: {
                     type: "fluid.transforms.linearScale",
                     value: 12,
                     factor: 0.50,
@@ -151,7 +151,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }
     }, {
         message: "linearScale - everything by path",
-        expander: {
+        transform: {
             type: "fluid.transforms.linearScale",
             valuePath: "dozen",
             factorPath: "halfdozen",
@@ -168,9 +168,9 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
 
     var inverseLinearScaleTests = [{
         message: "inverseLinearScale - factor parameter and offset",
-        expander: {
+        transform: {
             value: {
-                expander: {
+                transform: {
                     type: "fluid.transforms.inverseLinearScale",
                     value: 106,
                     factor: 0.50,
@@ -184,7 +184,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }
     }, {
         message: "inverseLinearScale - everything by path",
-        expander: {
+        transform: {
             type: "fluid.transforms.inverseLinearScale",
             valuePath: "lots",
             factorPath: "halfdozen",
@@ -202,7 +202,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     var binaryOpTests = [{
         message: "binaryOp - ===",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             leftPath: "dozen",
             operator: "===",
@@ -213,7 +213,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "binaryOp - !==",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             left: 100,
             operator: "!==",
@@ -224,7 +224,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "binaryOp - <=",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             leftPath: "dozen",
             operator: "<=",
@@ -235,7 +235,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "binaryOp - <",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             leftPath: "hundred",
             operator: "<",
@@ -246,7 +246,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "binaryOp - >=",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             leftPath: "dozen",
             operator: ">=",
@@ -257,7 +257,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "binaryOp - >",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             leftPath: "hundred",
             operator: ">",
@@ -268,7 +268,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "binaryOp - +",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             leftPath: "dozen",
             operator: "+",
@@ -279,7 +279,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "binaryOp - -",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             leftPath: "hundred",
             operator: "-",
@@ -290,7 +290,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "binaryOp - *",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             leftPath: "dozen",
             operator: "*",
@@ -301,7 +301,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "binaryOp - /",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             left: 96,
             operator: "/",
@@ -312,7 +312,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "binaryOp - %",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             leftPath: "hundred",
             operator: "%",
@@ -323,7 +323,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "binaryOp - &&",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             leftPath: "catsAreDecent",
             operator: "&&",
@@ -334,7 +334,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "binaryOp - ||",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             left: false,
             operator: "||",
@@ -345,7 +345,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "binaryOp - invalid operator",
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.binaryOp",
             left: false,
             operator: "-+",
@@ -363,7 +363,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         {
             message: "simple condition",
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.condition",
                 conditionPath: "catsAreDecent",
                 "true": "it was true",
@@ -374,7 +374,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }, {
             message: "truePath condition",
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.condition",
                 condition: true,
                 "truePath": "cow"
@@ -386,7 +386,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }, {
             message: "invalid truePath",
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.condition",
                 conditionPath: "catsAreDecent",
                 "true": source.bow
@@ -396,10 +396,10 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }, {
             message: "Nesting",
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.condition",
                 condition: {
-                    expander: {
+                    transform: {
                         type: "fluid.transforms.binaryOp",
                         left: true,
                         operator: "&&",
@@ -407,7 +407,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                     }
                 },
                 "false": {
-                    expander: {
+                    transform: {
                         type: "fluid.transforms.literalValue",
                         value: "Congratulations, you are a genius",
                         outputPath: "conclusion"
@@ -429,7 +429,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         {
             message: "A value transform should resolve the specified path.", 
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.value", 
                 inputPath: "hamster.wheel"
             }, 
@@ -438,7 +438,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }, {
             message: "When the path is valid, the value option should not be returned.", 
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.value", 
                 inputPath: "hamster.wheel",
                 input: "hello!"
@@ -448,7 +448,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }, {
             message: "When the path's value is null, the value option should not be returned.",
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.value", 
                 inputPath: "dog",
                 input: "hello!"
@@ -458,7 +458,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }, {
             message: "When the path's value is false, the value option should not be returned.",
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.value", 
                 inputPath: "goat",
                 input: "hello!"
@@ -468,7 +468,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }, {
             message: "When the path's value is undefined, the value option should be returned.",
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.value", 
                 inputPath: "gerbil",
                 input: "hello!"
@@ -478,7 +478,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }, {
             message: "When the path's value is not specified, the value option should be returned.",
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.value", 
                 input: "toothpick"
             }, 
@@ -487,7 +487,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }, {
             message: "When the path's value is defined, the referenced value should be returned.",
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.value", 
                 inputPath: "cat",
                 input: "rrrrr"
@@ -497,17 +497,17 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }, {
             message: "Where the path is a rules object, the result should be an expanded version of it.",
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.value", 
                 input: {
                     alligator: {
-                        expander: {
+                        transform: {
                             type: "fluid.transforms.value",
                             inputPath: "hamster"
                         }
                     },
                     tiger: {
-                        expander: {
+                        transform: {
                             type: "fluid.transforms.value",
                             inputPath: "hamster.wheel"
                         }
@@ -527,8 +527,8 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     });
 
     var transformToShortNames = {
-        expander: {
-            inputPath: "*.expander.type",
+        transform: {
+            inputPath: "*.transform.type",
             type: "fluid.computeNickName"  
         }
     };
@@ -537,12 +537,12 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         var shortened = fluid.model.transform(valueTests, transformToShortNames, {isomorphic: true});
         var expected = fluid.transform(valueTests, function (config) {
             return {
-                expander: {
-                    type: fluid.computeNickName(config.expander.type)
+                transform: {
+                    type: fluid.computeNickName(config.transform.type)
                 }
             };
         });
-        jqUnit.assertDeepEq("Transformed expander types to short names", expected, shortened);
+        jqUnit.assertDeepEq("Transformed transform types to short names", expected, shortened);
         var newConfig = $.extend(true, [], valueTests, shortened);
         testOneStructure(newConfig);
     });
@@ -550,7 +550,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     var arrayValueTests = [{
         message: "arrayValue() should box a non-array value up as one.", 
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.arrayValue", 
             inputPath: "cat"
         }, 
@@ -559,7 +559,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "arrayValue() should not box up an array value.", 
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.arrayValue", 
             inputPath: "sheep"
         }, 
@@ -574,7 +574,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     var countTests = [{
         message: "count() should return a length of 1 for a non-array value.", 
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.count", 
             inputPath: "cat"
         }, 
@@ -583,7 +583,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "count() should return the length for array values.", 
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.count", 
             inputPath: "sheep"
         }, 
@@ -598,7 +598,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     var roundTests = [{
         message: "round() expected to return round down number", 
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.round", 
             inputPath: "floatyLowy"
         }, 
@@ -607,7 +607,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {        
         message: "round() expected to return round up number", 
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.round", 
             inputPath: "floatyHighy"
         }, 
@@ -616,7 +616,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "round() should round up on negative float.", 
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.round", 
             inputPath: "floaty2"
         }, 
@@ -631,7 +631,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     var firstValueTests = [{
         message: "firstValue() should return the first non-undefined value in paths", 
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.firstValue", 
             values: ["cat", "dog"]
         }, 
@@ -640,7 +640,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "firstValue() should return the second path value when the first is undefined", 
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.firstValue", 
             values: ["gerbil", "cat"]
         }, 
@@ -649,7 +649,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "firstValue() should return the first path value when is false", 
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.firstValue", 
             values: ["goat", "cat"]
         }, 
@@ -658,7 +658,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "firstValue() should return the first path value when is null", 
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.firstValue", 
             values: ["dog", "cat"]
         }, 
@@ -667,7 +667,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     }, {
         message: "firstValue() should return the first path value when is 0", 
         expandWrap: true,
-        expander: {
+        transform: {
             type: "fluid.transforms.firstValue", 
             values: ["hippo", "cat"]
         }, 
@@ -703,7 +703,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             message: "valueMapper selects focus based on path",
             model: mapperModel, 
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.valueMapper",
                 inputPath: "tracking",
                 options: mapperOptions
@@ -719,7 +719,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 tracking: "unknown-thing"
             }, 
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.valueMapper",
                 inputPath: "tracking",
                 defaultInputValue: "mouse",
@@ -736,7 +736,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 condition: true
             }, 
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.valueMapper",
                 inputPath: "condition",
                 defaultOutputValue: "CATTOO",
@@ -760,7 +760,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 condition: true
             }, 
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.valueMapper",
                 inputPath: "condition",
                 defaultOutputValue: "CATTOO",
@@ -785,7 +785,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 condition: true
             }, 
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.valueMapper",
                 inputPath: "uncondition",
                 defaultOutputValue: "CATTOO",
@@ -811,7 +811,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             message: "valueMapper with unmatched input value mapped to definite value",
             model: {}, 
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.valueMapper",
                 inputPath: "uncondition",
                 options: [ 
@@ -831,7 +831,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             message: "valueMapper with unmatched input value mapped to undefined value with short form",
             model: {}, 
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.valueMapper",
                 inputPath: "uncondition",
                 defaultOutputPath: "wouldbeCATT",
@@ -850,7 +850,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 foo: "bar"
             }, 
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.valueMapper",
                 inputPath: "foo",
                 defaultOutputPath: "stupidCATT",
@@ -875,7 +875,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 }
             },
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.valueMapper",
                 inputPath: "display.screenEnhancement.tracking",
                 options: {
@@ -888,7 +888,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             expected: undefined
         }, 
         "nested-mapping": {
-            message: "valueMapper with nested expanders.",
+            message: "valueMapper with nested transforms.",
             model: {
                 animals: {
                     mammals: {
@@ -898,14 +898,14 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 }
             },
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.valueMapper",
                 inputPath: "animals.mammals.elephant",
                 options: {
                     big: {
                         outputPath: "correct",
                         outputValue: {
-                            expander: {
+                            transform: {
                                 type: "fluid.transforms.literalValue",
                                 value: "Elephant - Brilliant work, it is indeed big",
                                 outputPath: "path"
@@ -927,13 +927,13 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 screenReaderTTSEnabled: false
             },
             expandWrap: true,
-            expander: {
+            transform: {
                 type: "fluid.transforms.valueMapper",
                 inputPath: "screenReaderTTSEnabled",
                 options: {
                     "false": {
                         outputValue: {
-                            expander: [
+                            transform: [
                                 {
                                     type: "fluid.transforms.literalValue",
                                     value: "silence",
@@ -965,7 +965,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     
     var a4aFontRules = {
         "textFont": {
-            "expander": {
+            "transform": {
                 "type": "fluid.transforms.valueMapper",
                 "inputPath": "fontFace.genericFontFace",
                 "_comment": "TODO: For now, this ignores the actual 'fontName' setting",
@@ -1002,8 +1002,8 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                   
         testCompact(" - compact", a4aFontRules);
         var exRules = {
-            "textFont.expander.options.*": {
-                expander: {
+            "textFont.transform.options.*": {
+                transform: {
                     type: "fluid.tests.expandCompactRule"
                 }
             }, 
@@ -1011,7 +1011,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         };
         var expandedRules = fluid.model.transform(a4aFontRules, exRules);
         var expectedRules = fluid.copy(a4aFontRules);
-        fluid.set(expectedRules, "textFont.expander.options", fluid.transform(a4aFontRules.textFont.expander.options, function (value) {
+        fluid.set(expectedRules, "textFont.transform.options", fluid.transform(a4aFontRules.textFont.transform.options, function (value) {
             return fluid.tests.expandCompactRule(value);
         }));
         jqUnit.assertDeepEq("Rules transformed to expanded form", expectedRules, expandedRules);
@@ -1045,7 +1045,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }];
         var rules = {
             "*.*.settings.*": {
-                expander: {
+                transform: {
                     type: "value",
                     inputPath: "newValue"
                 }
@@ -1059,7 +1059,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             }
         }];
         var result = fluid.model.transform(gpiiSettingsResponse, rules, {isomorphic: true});
-        jqUnit.assertDeepEq("isomorphic structure with wildcards and recursive expander", expected, result);    
+        jqUnit.assertDeepEq("isomorphic structure with wildcards and recursive transform", expected, result);    
     });
     
     jqUnit.test("transform with no schema, wildcards and dot-paths", function () {
@@ -1072,7 +1072,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         };
         var rules = {
             "*.settings.*": {
-                expander: {
+                transform: {
                     type: "value",
                     inputPath: "newValue"
                 }
@@ -1086,7 +1086,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             }
         };
         var result = fluid.model.transform(flatterGpiiSettingsResponse, rules);
-        jqUnit.assertDeepEq("wildcards, recursive expander and dot-paths", expected, result);    
+        jqUnit.assertDeepEq("wildcards, recursive transform and dot-paths", expected, result);    
     });
     
     jqUnit.test("transform with schema, wildcards AFTER dot-paths", function () {
@@ -1099,7 +1099,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         };
         var rules = {
             "*.*.settings.*": {
-                expander: {
+                transform: {
                     type: "value",
                     inputPath: "newValue"
                 }
@@ -1113,7 +1113,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             }]
         };
         var result = fluid.model.transform(modernGpiiSettingsResponse, rules, {isomorphic: true});
-        jqUnit.assertDeepEq("wildcards, recursive expander and dot-paths", expected, result);    
+        jqUnit.assertDeepEq("wildcards, recursive transform and dot-paths", expected, result);    
     });
 
     jqUnit.test("transform with path named value and literalValue", function () {
@@ -1122,13 +1122,13 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         };
         var transform = {
             "Magnification": {
-                expander: {
+                transform: {
                     type: "fluid.transforms.value",
                     inputPath: "Magnification",
                     outputPath: "value"
                 },
                 dataType: {
-                    expander: {
+                    transform: {
                         type: "fluid.transforms.literalValue",
                         value: "REG_DWORD"
                     }
@@ -1176,7 +1176,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         var rules = {
             "farm": {
                 "goat": {
-                    expander: {
+                    transform: {
                         type: "fluid.transforms.value",
                         inputPath: "goat"
                     }
@@ -1198,7 +1198,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         };
         var inverseRules = fluid.model.transform.invertConfiguration(rules);
         var expectedInverse = {
-            expander: [{
+            transform: [{
                 type: "fluid.transforms.value",
                 inputPath: "farm",
                 outputPath: "goat"
@@ -1215,7 +1215,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
 
     jqUnit.test("invert valueMapper transformation", function () {
         var rules = {
-            expander: {
+            transform: {
                 type: "fluid.transforms.valueMapper",
                 inputPath: "tracking",
                 options: mapperOptions
@@ -1227,7 +1227,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         
         var inverseRules = fluid.model.transform.invertConfiguration(rules);
         var expectedInverse = {
-            expander: [{
+            transform: [{
                 type: "fluid.transforms.valueMapper",
                 defaultOutputPath: "tracking",
                 options: [
@@ -1257,10 +1257,10 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     
     jqUnit.test("invert long form valueMapper", function () {
         var cattoo = mapperTests["nonString-long"];
-        var rules = {expander: cattoo.expander};
+        var rules = {transform: cattoo.transform};
         var inverseRules = fluid.model.transform.invertConfiguration(rules);
         var expectedInverse = {
-            expander: [{
+            transform: [{
                 type: "fluid.transforms.valueMapper",
                 defaultOutputPath: "condition",
                 options: [ {
@@ -1284,7 +1284,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         "mag-factor": "display.screenEnhancement.magnification",
         "show-cross-hairs": "display.screenEnhancement.showCrosshairs",
         "mouse-tracking": {
-            "expander": {
+            "transform": {
                 "type": "fluid.transforms.valueMapper",
                 "inputPath": "display.screenEnhancement.tracking",
                 "options": {
@@ -1295,10 +1295,10 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             }
         },
         "foo-bar": {
-            expander: {
+            transform: {
                 type: "fluid.transforms.value",
                 input: {
-                    expander: {
+                    transform: {
                         type: "fluid.transforms.value",
                         inputPath: "im.nested"
                     }
@@ -1319,10 +1319,10 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     });
 
     var multiInputTransformations = {
-        expander: {
+        transform: {
             type: "fluid.transforms.condition",
             condition: {
-                expander: {
+                transform: {
                     type: "fluid.transforms.binaryOp",
                     leftPath: "hello.world",
                     operator: "&&",
@@ -1330,7 +1330,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 }
             },
             "false": {
-                expander: {
+                transform: {
                     type: "fluid.transforms.value",
                     inputPath: "falsey.goes.here",
                     outputPath: "conclusion"
@@ -1354,7 +1354,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         var rules = {
             // Rename a property
             feline: { 
-                expander: {
+                transform: {
                     type: "fluid.transforms.value",
                     inputPath: "cat"
                 }
@@ -1362,7 +1362,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
 
             // Use a default value
             gerbil: {
-                expander: {
+                transform: {
                     type: "fluid.transforms.value",
                     inputPath: "gerbil",
                     value: "sold out"
@@ -1371,7 +1371,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
 
             // Use a literal value
             kangaroo: {
-                expander: {
+                transform: {
                     type: "fluid.transforms.value",
                     value: "literal value"
                 }
@@ -1379,13 +1379,13 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
 
             // Restructuring/nesting
             "farm.goat": {                                          
-                expander: {
+                transform: {
                     type: "fluid.transforms.value",
                     inputPath: "goat"
                 }
             },
             "farm.sheep": {
-                expander: {
+                transform: {
                     type: "fluid.transforms.value",
                     inputPath: "sheep"
                 }
@@ -1393,17 +1393,17 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
 
             // First value
             "bear": {
-                expander: {
+                transform: {
                     type: "fluid.transforms.firstValue",
                     values: [
                         {
-                            expander: {
+                            transform: {
                                 type: "fluid.transforms.value",
                                 inputPath: "grizzly"
                             }
                         },
                         {
-                            expander: {
+                            transform: {
                                 type: "fluid.transforms.value",
                                 inputPath: "polar"
                             }
@@ -1434,17 +1434,17 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     jqUnit.test("fluid.model.transform() with idempotent rules", function () {
         var idempotentRules = {
             wheel: {
-                expander: {
+                transform: {
                     type: "fluid.transforms.firstValue",
                     values: [
                         {
-                            expander: {
+                            transform: {
                                 type: "fluid.transforms.value",
                                 inputPath: "wheel"
                             }
                         },
                         {
-                            expander: {
+                            transform: {
                                 type: "fluid.transforms.value",
                                 inputPath: "hamster.wheel"
                             }
@@ -1453,17 +1453,17 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 }
             },
             "barn.cat": {
-                expander: {
+                transform: {
                     type: "fluid.transforms.firstValue",
                     values: [
                         {
-                            expander: {
+                            transform: {
                                 type: "fluid.transforms.value",
                                 inputPath: "barn.cat"
                             }
                         },
                         {
-                            expander: {
+                            transform: {
                                 type: "fluid.transforms.value",
                                 inputPath: "cat"
                             }
@@ -1526,7 +1526,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
     var transformRules = {
         "components.cat": "cat",
         "components.fish.type": {
-            expander: {
+            transform: {
                 type: "fluid.transforms.value",
                 value: "bowl.fish"
             }
@@ -1557,7 +1557,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }, {
             message: "root transform rules, delete and sorting reverse",
             rules: {
-                expander: {
+                transform: {
                     outputPath: "numFish",
                     type: "fluid.transforms.delete"
                 },
@@ -1568,7 +1568,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             message: "root transform rules, delete and sorting forward",
             rules: {
                 "" : "",
-                expander: {
+                transform: {
                     outputPath: "numFish",
                     type: "fluid.transforms.delete"
                 }
@@ -1578,7 +1578,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             message: "merge directive",
             rules: {
                 "" : "",
-                expander: {
+                transform: {
                     outputPath: "cat",
                     inputPath: "",
                     merge: true,
@@ -1689,7 +1689,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             }, 
             rules: {
                 "a.c": {
-                    "expander": {
+                    "transform": {
                         type: "fluid.transforms.arrayToObject",
                         inputPath: "a.c",
                         key: "name"
@@ -1708,7 +1708,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 }
             },
             invertedRules: {
-                expander: [ 
+                transform: [ 
                     {
                         type: "fluid.transforms.objectToArray",
                         inputPath: "a.c",
@@ -1735,7 +1735,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             rules: {
                 b: "b",
                 "c.dotted\\.key": {
-                    "expander": {
+                    "transform": {
                         type: "fluid.transforms.arrayToObject",
                         inputPath: "a.dotted\\.key",
                         key: "uni.que"
@@ -1759,7 +1759,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 }
             },
             invertedRules: {
-                expander: [ 
+                transform: [ 
                     { 
                         type: 'fluid.transforms.value',
                         inputPath: 'b',
@@ -1784,12 +1784,12 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 }
             }, 
             rules: {
-                expander: {
+                transform: {
                     type: "fluid.transforms.arrayToObject",
                     inputPath: "foo.bar",
                     key: "product",
                     innerValue: [{
-                        expander: {
+                        transform: {
                             type: "fluid.transforms.value",
                             inputPath: "info.healthy"
                         }
@@ -1802,12 +1802,12 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 "salad": "yes"
             },
             invertedRules: {
-                expander: [{
+                transform: [{
                     type: "fluid.transforms.objectToArray",
                     outputPath: "foo.bar",
                     key: "product",
                     innerValue: [{
-                        expander: [{
+                        transform: [{
                             type: "fluid.transforms.value",
                             inputPath: "",
                             outputPath: "info.healthy"
@@ -1852,14 +1852,14 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             }, 
             rules: {
                 "outer": {
-                    "expander": {
+                    "transform": {
                         type: "fluid.transforms.arrayToObject",
                         inputPath: "outer",
                         key: "outerpivot",
                         innerValue: [
                             {
                                 "outervar": {
-                                    "expander": {
+                                    "transform": {
                                         type: "fluid.transforms.arrayToObject",
                                         inputPath: "outervar",
                                         key: "innerpivot"
@@ -1901,13 +1901,13 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 }
             },
             invertedRules: {
-                "expander": [{
+                "transform": [{
                     type: "fluid.transforms.objectToArray",
                     inputPath: "outer",
                     outputPath: "outer",
                     key: "outerpivot",
                     innerValue: [{
-                        expander: [{
+                        transform: [{
                             type: "fluid.transforms.objectToArray",
                             inputPath: "outervar",
                             outputPath: "outervar",
@@ -1950,14 +1950,14 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             }, 
             rules: {
                 "outer": {
-                    "expander": {
+                    "transform": {
                         type: "fluid.transforms.arrayToObject",
                         inputPath: "outer",
                         key: "outerpivot",
                         innerValue: [
                             {
                                 "outervar.arr1": {
-                                    "expander": {
+                                    "transform": {
                                         type: "fluid.transforms.arrayToObject",
                                         inputPath: "outervar.arr1",
                                         key: "innerpivot1"
@@ -1966,7 +1966,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                             }, 
                             {
                                 "outervar.arr2": {
-                                    "expander": {
+                                    "transform": {
                                         type: "fluid.transforms.arrayToObject",
                                         inputPath: "outervar.arr2",
                                         key: "innerpivot2"
@@ -1999,20 +1999,20 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
                 }
             },
             invertedRules: {
-                "expander": [{
+                "transform": [{
                     type: "fluid.transforms.objectToArray",
                     inputPath: "outer",
                     outputPath: "outer",
                     key: "outerpivot",
                     innerValue: [{
-                        expander: [{
+                        transform: [{
                             type: "fluid.transforms.objectToArray",
                             inputPath: "outervar.arr1",
                             outputPath: "outervar.arr1",
                             key: "innerpivot1"
                         }]
                     }, {
-                        expander: [{
+                        transform: [{
                             type: "fluid.transforms.objectToArray",
                             inputPath: "outervar.arr2",
                             outputPath: "outervar.arr2",
@@ -2053,7 +2053,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }, 
         rules: {
             "b": {
-                "expander": {
+                "transform": {
                     type: "fluid.transforms.arrayToSetMembership",
                     inputPath: "a",
                     presentValue: "yes",
@@ -2074,7 +2074,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             }
         },
         invertedRules: {
-            expander: [ 
+            transform: [ 
                 {
                     type: "fluid.transforms.setMembershipToArray",
                     outputPath: "a",
@@ -2095,7 +2095,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
         }, 
         rules: {
             "b": {
-                "expander": {
+                "transform": {
                     type: "fluid.transforms.arrayToSetMembership",
                     inputPath: "a",
                     options: { //(paths)
@@ -2114,7 +2114,7 @@ https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
             }
         },
         invertedRules: {
-            expander: [ 
+            transform: [ 
                 {
                     type: "fluid.transforms.setMembershipToArray",
                     outputPath: "a",